12a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Copyright 2011 The Chromium Authors. All rights reserved. 22a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Use of this source code is governed by a BSD-style license that can be 32a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// found in the LICENSE file. 42a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 52a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/trees/layer_tree_host_common.h" 62a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 72a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include <algorithm> 82a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 92a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "base/debug/trace_event.h" 102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/base/math_util.h" 112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/layers/heads_up_display_layer_impl.h" 122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/layers/layer.h" 132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/layers/layer_impl.h" 142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/layers/layer_iterator.h" 152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/layers/render_surface.h" 162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/layers/render_surface_impl.h" 172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/trees/layer_sorter.h" 182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "cc/trees/layer_tree_impl.h" 192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "ui/gfx/rect_conversions.h" 202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "ui/gfx/transform.h" 212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)namespace cc { 232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ScrollAndScaleSet::ScrollAndScaleSet() {} 252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ScrollAndScaleSet::~ScrollAndScaleSet() {} 272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 28c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static void SortLayers(LayerList::iterator forst, 29c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerList::iterator end, 302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void* layer_sorter) { 312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) NOTREACHED(); 322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 34c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static void SortLayers(LayerImplList::iterator first, 35c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImplList::iterator end, 362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerSorter* layer_sorter) { 372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer_sorter); 382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers"); 392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_sorter->Sort(first, end); 402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 42424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 43424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) { 44424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF scroll_delta = layer->ScrollDelta(); 45424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The scroll parent's scroll delta is the amount we've scrolled on the 46424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // compositor thread since the commit for this layer tree's source frame. 47424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // we last reported to the main thread. I.e., it's the discrepancy between 48424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // a scroll parent's scroll delta and offset, so we must add it here. 49424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->scroll_parent()) 50424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta += layer->scroll_parent()->ScrollDelta(); 51424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return scroll_delta; 52424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 53424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 54424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 55424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF GetEffectiveTotalScrollOffset(LayerType* layer) { 56424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF offset = layer->TotalScrollOffset(); 57424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The scroll parent's total scroll offset (scroll offset + scroll delta) 58424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // can't be used because its scroll offset has already been applied to the 59424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // scroll children's positions by the main thread layer positioning code. 60424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->scroll_parent()) 61424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) offset += layer->scroll_parent()->ScrollDelta(); 62424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return offset; 63424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 64424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)inline gfx::Rect CalculateVisibleRectWithCachedLayerRect( 665d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& target_surface_rect, 675d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_bound_rect, 685d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_rect_in_target_space, 692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& transform) { 70868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (layer_rect_in_target_space.IsEmpty()) 71868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return gfx::Rect(); 72868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Is this layer fully contained within the target surface? 742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (target_surface_rect.Contains(layer_rect_in_target_space)) 752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_bound_rect; 762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer doesn't fill up the entire surface, then find the part of 782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the surface rect where the layer could be visible. This avoids trying to 792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // project surface rect points that are behind the projection point. 802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect minimal_surface_rect = target_surface_rect; 812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) minimal_surface_rect.Intersect(layer_rect_in_target_space); 822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 833551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (minimal_surface_rect.IsEmpty()) 84f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) return gfx::Rect(); 853551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Project the corners of the target surface rect into the layer space. 872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This bounding rectangle may be larger than it needs to be (being 882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // axis-aligned), but is a reasonable filter on the space to consider. 892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Non-invertible transforms will create an empty rect here. 902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform surface_to_layer(gfx::Transform::kSkipInitialization); 922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!transform.GetInverse(&surface_to_layer)) { 933551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Because we cannot use the surface bounds to determine what portion of 943551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // the layer is visible, we must conservatively assume the full layer is 953551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // visible. 963551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) return layer_bound_rect; 972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 98c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 995d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) gfx::Rect layer_rect = MathUtil::ProjectEnclosingClippedRect( 1005d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) surface_to_layer, minimal_surface_rect); 1012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_rect.Intersect(layer_bound_rect); 1022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_rect; 1032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Rect LayerTreeHostCommon::CalculateVisibleRect( 1065d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& target_surface_rect, 1075d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_bound_rect, 1082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& transform) { 1092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect layer_in_surface_space = 1105d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) MathUtil::MapEnclosingClippedRect(transform, layer_bound_rect); 1112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return CalculateVisibleRectWithCachedLayerRect( 1122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) target_surface_rect, layer_bound_rect, layer_in_surface_space, transform); 1132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 115424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 116424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static LayerType* NextTargetSurface(LayerType* layer) { 117424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return layer->parent() ? layer->parent()->render_target() : 0; 118424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 119424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 120424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Given two layers, this function finds their respective render targets and, 121424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// computes a change of basis translation. It does this by accumulating the 122424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// translation components of the draw transforms of each target between the 123424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// ancestor and descendant. These transforms must be 2D translations, and this 124424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// requirement is enforced at every step. 1258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 126424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF ComputeChangeOfBasisTranslation( 127424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& ancestor_layer, 128424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& descendant_layer) { 129424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(descendant_layer.HasAncestor(&ancestor_layer)); 130424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* descendant_target = descendant_layer.render_target(); 131424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(descendant_target); 132424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* ancestor_target = ancestor_layer.render_target(); 133424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(ancestor_target); 134424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 135424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF translation; 136424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) for (const LayerType* target = descendant_target; target != ancestor_target; 1371e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) target = NextTargetSurface(target)) { 1381e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& trans = target->render_surface()->draw_transform(); 1391e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // Ensure that this translation is truly 2d. 1401e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) DCHECK(trans.IsIdentityOrTranslation()); 1411e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) DCHECK_EQ(0.f, trans.matrix().get(2, 3)); 1421e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) translation += trans.To2dTranslation(); 1431e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) } 144424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 145424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return translation; 146424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 147424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 148424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)enum TranslateRectDirection { 149424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToAncestor, 150424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToDescendant 151424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)}; 152424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1538bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 154424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Rect TranslateRectToTargetSpace(const LayerType& ancestor_layer, 155424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& descendant_layer, 1565d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& rect, 157424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirection direction) { 1588bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) gfx::Vector2dF translation = ComputeChangeOfBasisTranslation<LayerType>( 1598bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) ancestor_layer, descendant_layer); 160424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (direction == TranslateRectDirectionToDescendant) 161424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) translation.Scale(-1.f); 162424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return gfx::ToEnclosingRect( 163424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::RectF(rect.origin() + translation, rect.size())); 164424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 165424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 166424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Attempts to update the clip rects for the given layer. If the layer has a 167424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// clip_parent, it may not inherit its immediate ancestor's clip. 1688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 169424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static void UpdateClipRectsForClipChild( 170424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* layer, 171424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect* clip_rect_in_parent_target_space, 172424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool* subtree_should_be_clipped) { 173424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer has no clip_parent, or the ancestor is the same as its actual 174424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parent, then we don't need special clip rects. Bail now and leave the out 175424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parameters untouched. 1768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType* clip_parent = layer->scroll_parent(); 1778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 1788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (!clip_parent) 1798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) clip_parent = layer->clip_parent(); 1808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 181424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!clip_parent || clip_parent == layer->parent()) 182424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return; 183424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 184424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The root layer is never a clip child. 185424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(layer->parent()); 186424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 187424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Grab the cached values. 188424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *clip_rect_in_parent_target_space = clip_parent->clip_rect(); 189424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *subtree_should_be_clipped = clip_parent->is_clipped(); 190424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 191424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We may have to project the clip rect into our parent's target space. Note, 192424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // it must be our parent's target space, not ours. For one, we haven't 193424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // computed our transforms, so we couldn't put it in our space yet even if we 194424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // wanted to. But more importantly, this matches the expectations of 195424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // CalculateDrawPropertiesInternal. If we, say, create a render surface, these 196424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // clip rects will want to be in its target space, not ours. 1978bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (clip_parent == layer->clip_parent()) { 1988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>( 1998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_parent, 2008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer->parent(), 2018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space, 2028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectDirectionToDescendant); 2038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } else { 2048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // If we're being clipped by our scroll parent, we must translate through 2058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // our common ancestor. This happens to be our parent, so it is sufficent to 2068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // translate from our clip parent's space to the space of its ancestor (our 2078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // parent). 2088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space = 2098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectToTargetSpace<LayerType>(*layer->parent(), 2108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_parent, 2118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space, 2128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectDirectionToAncestor); 2138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 214424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 215424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 216424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// We collect an accumulated drawable content rect per render surface. 217424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Typically, a layer will contribute to only one surface, the surface 218424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// associated with its render target. Clip children, however, may affect 219424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// several surfaces since there may be several surfaces between the clip child 220424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// and its parent. 221424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// 222424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// NB: we accumulate the layer's *clipped* drawable content rect. 223424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 224424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)struct AccumulatedSurfaceState { 225424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) explicit AccumulatedSurfaceState(LayerType* render_target) 226424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : render_target(render_target) {} 227424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 228424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The accumulated drawable content rect for the surface associated with the 229424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // given |render_target|. 230424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect drawable_content_rect; 231424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 232424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The target owning the surface. (We hang onto the target rather than the 233424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surface so that we can DCHECK that the surface's draw transform is simply 234424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // a translation when |render_target| reports that it has no unclipped 235424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // descendants). 236424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* render_target; 237424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)}; 238424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2398bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 240424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)void UpdateAccumulatedSurfaceState( 241424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* layer, 2425d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& drawable_content_rect, 243424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerType> >* 244424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state) { 245424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (IsRootLayer(layer)) 246424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return; 247424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 248424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We will apply our drawable content rect to the accumulated rects for all 249424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surfaces between us and |render_target| (inclusive). This is either our 250424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // clip parent's target if we are a clip child, or else simply our parent's 251424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // target. We use our parent's target because we're either the owner of a 252424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // render surface and we'll want to add our rect to our *surface's* target, or 253424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // we're not and our target is the same as our parent's. In both cases, the 254424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parent's target gives us what we want. 255424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* render_target = layer->clip_parent() 256424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ? layer->clip_parent()->render_target() 257424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : layer->parent()->render_target(); 258424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 259424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer owns a surface, then the content rect is in the wrong space. 260424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Instead, we will use the surface's DrawableContentRect which is in target 261424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // space as required. 262424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect target_rect = drawable_content_rect; 263424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) { 264424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect = 265424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::ToEnclosedRect(layer->render_surface()->DrawableContentRect()); 266424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 267424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 268424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (render_target->is_clipped()) { 269424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect clip_rect = render_target->clip_rect(); 270424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer has a clip parent, the clip rect may be in the wrong space, 271424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // so we'll need to transform it before it is applied. 272424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_parent()) { 2738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) clip_rect = TranslateRectToTargetSpace<LayerType>( 274424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *layer->clip_parent(), 275424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *layer, 276424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect, 277424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToDescendant); 278424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 279424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect.Intersect(clip_rect); 280424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 281424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 282424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We must have at least one entry in the vector for the root. 283424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK_LT(0ul, accumulated_surface_state->size()); 284424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 285424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) typedef typename std::vector<AccumulatedSurfaceState<LayerType> > 286424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateVector; 287424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) typedef typename AccumulatedSurfaceStateVector::reverse_iterator 288424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateIterator; 289424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateIterator current_state = 290424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->rbegin(); 291424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 292424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Add this rect to the accumulated content rect for all surfaces until we 293424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // reach the target surface. 294424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool found_render_target = false; 295424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) for (; current_state != accumulated_surface_state->rend(); ++current_state) { 296424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_state->drawable_content_rect.Union(target_rect); 297424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 298424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we've reached |render_target| our work is done and we can bail. 299424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (current_state->render_target == render_target) { 300424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) found_render_target = true; 301424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) break; 302424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 303424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 304424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Transform rect from the current target's space to the next. 305424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* current_target = current_state->render_target; 306424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(current_target->render_surface()); 307424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const gfx::Transform& current_draw_transform = 308424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_target->render_surface()->draw_transform(); 309424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 310424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we have unclipped descendants, the draw transform is a translation. 311424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(current_target->num_unclipped_descendants() == 0 || 312424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_draw_transform.IsIdentityOrTranslation()); 313424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 314424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect = gfx::ToEnclosingRect( 315424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) MathUtil::MapClippedRect(current_draw_transform, target_rect)); 316424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 317424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 318424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // It is an error to not reach |render_target|. If this happens, it means that 319424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // either the clip parent is not an ancestor of the clip child or the surface 320424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // state vector is empty, both of which should be impossible. 321424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(found_render_target); 322424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 323424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 3242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> static inline bool IsRootLayer(LayerType* layer) { 3252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->parent(); 3262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) { 3306d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) return layer->Is3dSorted() && layer->parent() && 3316d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) layer->parent()->Is3dSorted(); 3322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsRootLayerOfNewRenderingContext(LayerType* layer) { 3362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) 3376d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) return !layer->parent()->Is3dSorted() && layer->Is3dSorted(); 3382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3396d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) return layer->Is3dSorted(); 3402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsLayerBackFaceVisible(LayerType* layer) { 3442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The current W3C spec on CSS transforms says that backface visibility should 3452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // be determined differently depending on whether the layer is in a "3d 3462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // rendering context" or not. For Chromium code, we can determine whether we 3472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // are in a 3d rendering context by checking if the parent preserves 3d. 3482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer)) 3502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->draw_transform().IsBackFaceVisible(); 3512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // In this case, either the layer establishes a new 3d rendering context, or 3532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // is not in a 3d rendering context at all. 3542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->transform().IsBackFaceVisible(); 3552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsSurfaceBackFaceVisible(LayerType* layer, 3592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& draw_transform) { 3602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer)) 3612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return draw_transform.IsBackFaceVisible(); 3622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (IsRootLayerOfNewRenderingContext(layer)) 3642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->transform().IsBackFaceVisible(); 3652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the render_surface is not part of a new or existing rendering context, 3672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // then the layers that contribute to this surface will decide back-face 3682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // visibility for themselves. 3692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 3702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool LayerClipsSubtree(LayerType* layer) { 3742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->masks_to_bounds() || layer->mask_layer(); 3752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static gfx::Rect CalculateVisibleContentRect( 3792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 3805d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& clip_rect_of_target_surface_in_target_space, 3815d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_rect_in_target_space) { 3822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->render_target()); 3832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Nothing is visible if the layer bounds are empty. 3852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() || 3862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->drawable_content_rect().IsEmpty()) 3872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Rect(); 3882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute visible bounds in target surface space. 3902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect visible_rect_in_target_surface_space = 3912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->drawable_content_rect(); 3922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->render_target()->render_surface()->clip_rect().IsEmpty()) { 394a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // The |layer| L has a target T which owns a surface Ts. The surface Ts 395a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // has a target TsT. 396a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // 397a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // In this case the target surface Ts does clip the layer L that contributes 398a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // to it. So, we have to convert the clip rect of Ts from the target space 399a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // of Ts (that is the space of TsT), to the current render target's space 400a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // (that is the space of T). This conversion is done outside this function 401a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // so that it can be cached instead of computing it redundantly for every 402a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // layer. 4032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) visible_rect_in_target_surface_space.Intersect( 404a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space); 4052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (visible_rect_in_target_surface_space.IsEmpty()) 4082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Rect(); 4092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return CalculateVisibleRectWithCachedLayerRect( 4112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) visible_rect_in_target_surface_space, 4122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()), 4132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_rect_in_target_space, 4142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_transform()); 4152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToParentIsKnown(LayerImpl* layer) { return true; } 4182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToParentIsKnown(Layer* layer) { 4202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->TransformIsAnimating(); 4212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToScreenIsKnown(LayerImpl* layer) { return true; } 4242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToScreenIsKnown(Layer* layer) { 4262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->screen_space_transform_is_animating(); 4272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 4305d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static bool LayerShouldBeSkipped(LayerType* layer, bool layer_is_drawn) { 4312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers can be skipped if any of these conditions are met. 4325d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // - is not drawn due to it or one of its ancestors being hidden (or having 4335d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // no copy requests). 434cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // - does not draw content. 435cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // - is transparent. 4362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - has empty bounds 4372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the layer is not double-sided, but its back face is visible. 4382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some additional conditions need to be computed at a later point after the 4402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // recursion is finished. 4412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the intersection of render_surface content and layer clip_rect is empty 4422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the visible_content_rect is empty 4432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note, if the layer should not have been drawn due to being fully 4452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transparent, we would have skipped the entire subtree and never made it 4462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // into this function, so it is safe to omit this check here. 4472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4485d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 4497dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return true; 4507dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 451cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) if (!layer->DrawsContent() || layer->bounds().IsEmpty()) 4522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 4532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* backface_test_layer = layer; 4552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->use_parent_backface_visibility()) { 4562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->parent()); 4572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(!layer->parent()->use_parent_backface_visibility()); 4582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) backface_test_layer = layer->parent(); 4592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The layer should not be drawn if (1) it is not double-sided and (2) the 4622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // back of the layer is known to be facing the screen. 4632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!backface_test_layer->double_sided() && 4642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TransformToScreenIsKnown(backface_test_layer) && 4652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) IsLayerBackFaceVisible(backface_test_layer)) 4662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 4672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 4692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4715c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liutemplate <typename LayerType> 4725c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic bool HasInvertibleOrAnimatedTransform(LayerType* layer) { 4735c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu return layer->transform_is_invertible() || layer->TransformIsAnimating(); 4745c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu} 4755c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu 4767dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstatic inline bool SubtreeShouldBeSkipped(LayerImpl* layer, 4775d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) bool layer_is_drawn) { 4780529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // If the layer transform is not invertible, it should not be drawn. 4790529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // TODO(ajuma): Correctly process subtrees with singular transform for the 4800529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // case where we may animate to a non-singular transform and wish to 4810529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // pre-raster. 4825c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu if (!HasInvertibleOrAnimatedTransform(layer)) 4830529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 4840529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 4857dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // When we need to do a readback/copy of a layer's output, we can not skip 4867dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // it or any of its ancestors. 4877dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->draw_properties().layer_or_descendant_has_copy_request) 4887dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return false; 4897dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 490f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // We cannot skip the the subtree if a descendant has a wheel or touch handler 491f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // or the hit testing code will break (it requires fresh transforms, etc). 492f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (layer->draw_properties().layer_or_descendant_has_input_handler) 493f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) return false; 494f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 4955d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer is not drawn, then skip it and its subtree. 4965d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 497eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return true; 498eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 499c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // If layer is on the pending tree and opacity is being animated then 500c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // this subtree can't be skipped as we need to create, prioritize and 501c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // include tiles for this layer when deciding if tree can be activated. 502c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating()) 503c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 504c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The opacity of a layer always applies to its children (either implicitly 5062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // via a render surface or explicitly if the parent preserves 3D), so the 5072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // entire subtree can be skipped if this layer is fully transparent. 5082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->opacity(); 5092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 5102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5115d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static inline bool SubtreeShouldBeSkipped(Layer* layer, bool layer_is_drawn) { 5120529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // If the layer transform is not invertible, it should not be drawn. 5130529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!layer->transform_is_invertible() && !layer->TransformIsAnimating()) 5140529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 5150529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 5167dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // When we need to do a readback/copy of a layer's output, we can not skip 5177dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // it or any of its ancestors. 5187dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->draw_properties().layer_or_descendant_has_copy_request) 5197dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return false; 5207dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 521f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // We cannot skip the the subtree if a descendant has a wheel or touch handler 522f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // or the hit testing code will break (it requires fresh transforms, etc). 523f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (layer->draw_properties().layer_or_descendant_has_input_handler) 524f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) return false; 525f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 5265d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer is not drawn, then skip it and its subtree. 5275d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 528eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return true; 529eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 5302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the opacity is being animated then the opacity on the main thread is 5312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // unreliable (since the impl thread may be using a different opacity), so it 5322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // should not be trusted. 5332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // In particular, it should not cause the subtree to be skipped. 5342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Similarly, for layers that might animate opacity using an impl-only 5352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // animation, their subtree should also not be skipped. 5362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->opacity() && !layer->OpacityIsAnimating() && 5372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !layer->OpacityCanAnimateOnImplThread(); 5382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 5392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 540c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static inline void SavePaintPropertiesLayer(LayerImpl* layer) {} 541c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 542c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static inline void SavePaintPropertiesLayer(Layer* layer) { 543c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->SavePaintProperties(); 544c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 545c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->mask_layer()) 546c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->mask_layer()->SavePaintProperties(); 547c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) 548c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->replica_layer()->mask_layer()->SavePaintProperties(); 549c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 550c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 5522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool SubtreeShouldRenderToSeparateSurface( 5532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 5542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool axis_aligned_with_respect_to_parent) { 5552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 5562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A layer and its descendants should render onto a new RenderSurfaceImpl if 5572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // any of these rules hold: 5582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 5592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 560b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // The root layer owns a render surface, but it never acts as a contributing 561b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // surface to another render target. Compositor features that are applied via 562b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // a contributing surface can not be applied to the root layer. In order to 563b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // use these effects, another child of the root would need to be introduced 564b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // in order to act as a contributing surface to the root layer's surface. 565b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool is_root = IsRootLayer(layer); 566c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer uses a mask. 568b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->mask_layer()) { 569b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 571b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer has a reflection. 574b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->replica_layer()) { 575b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 577b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer uses a CSS filter. 58068043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) { 581b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 583b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) int num_descendants_that_draw_content = 5862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_properties().num_descendants_that_draw_content; 5872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5885d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer flattens its subtree, but it is treated as a 3D object by its 5895d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // parent (i.e. parent participates in a 3D rendering context). 5905d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer) && 5915d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) layer->should_flatten_transform() && 5922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content > 0) { 5932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 5942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 595c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface flattening", 596c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 597b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 5992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 601f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // If the layer has blending. 602f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // TODO(rosca): this is temporary, until blending is implemented for other 603f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // types of quads than RenderPassDrawQuad. Layers having descendants that draw 604f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // content will still create a separate rendering surface. 605f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (!layer->uses_default_blend_mode()) { 606f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_INSTANT0( 607f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "cc", 608f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface blending", 609f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 610f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) DCHECK(!is_root); 611f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return true; 612f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 613f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 6142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer clips its descendants but it is not axis-aligned with respect 6152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to its parent. 6162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool layer_clips_external_content = 6172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerClipsSubtree(layer) || layer->HasDelegatedContent(); 6182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer_clips_external_content && !axis_aligned_with_respect_to_parent && 6194e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content > 0) { 6202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 6212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 622c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface clipping", 623c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 624b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 6282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer has some translucency and does not have a preserves-3d 6292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform style. This condition only needs a render surface if two or more 6302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers in the subtree overlap. But checking layer overlaps is unnecessarily 6312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // costly so instead we conservatively create a surface whenever at least two 6322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers draw content for this subtree. 6332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool at_least_two_layers_in_subtree_draw_content = 6342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content > 0 && 6352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer->DrawsContent() || num_descendants_that_draw_content > 1); 6362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 6375d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->opacity() != 1.f && layer->should_flatten_transform() && 6382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) at_least_two_layers_in_subtree_draw_content) { 6392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 6402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 641c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface opacity", 642c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 643b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 647b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // The root layer should always have a render_surface. 648b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (is_root) 649b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 650b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 651b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // 652b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // These are allowed on the root surface, as they don't require the surface to 653b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // be used as a contributing surface in order to apply correctly. 654b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // 655b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 656f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // If the layer has isolation. 657f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // TODO(rosca): to be optimized - create separate rendering surface only when 658f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // the blending descendants might have access to the content behind this layer 659f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // (layer has transparent background or descendants overflow). 660f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // https://code.google.com/p/chromium/issues/detail?id=301738 661f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->is_root_for_isolated_group()) { 662f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_INSTANT0( 663f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "cc", 664f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface isolation", 665f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 666f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return true; 667f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 668f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 669b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If we force it. 670b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->force_render_surface()) 671b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 672b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 673b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If we'll make a copy of the layer's contents. 67490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (layer->HasCopyRequest()) 675b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 676b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 6772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 6782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 6792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 680c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// This function returns a translation matrix that can be applied on a vector 681c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// that's in the layer's target surface coordinate, while the position offset is 682c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// specified in some ancestor layer's coordinate. 683c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)gfx::Transform ComputeSizeDeltaCompensation( 684c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* layer, 685c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* container, 6865d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& position_offset) { 687c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform result_transform; 688c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 689c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // To apply a translate in the container's layer space, 690c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the following steps need to be done: 691c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 1a. transform from target surface space to the container's target 692c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // surface space 693c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 1b. transform from container's target surface space to the 694c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // container's layer space 695c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 2. apply the compensation 696c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 3. transform back to target surface space 697c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 698c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform target_surface_space_to_container_layer_space; 699c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Calculate step 1a 700868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerImpl* container_target_surface = container->render_target(); 701c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (LayerImpl* current_target_surface = NextTargetSurface(layer); 702c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface && 703c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface != container_target_surface; 704c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface = NextTargetSurface(current_target_surface)) { 705c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note: Concat is used here to convert the result coordinate space from 706c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // current render surface to the next render surface. 707c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) target_surface_space_to_container_layer_space.ConcatTransform( 708c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface->render_surface()->draw_transform()); 709c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 710c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Calculate step 1b 711868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) gfx::Transform container_layer_space_to_container_target_surface_space = 712868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container->draw_transform(); 713868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container_layer_space_to_container_target_surface_space.Scale( 714868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container->contents_scale_x(), container->contents_scale_y()); 715868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 716868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) gfx::Transform container_target_surface_space_to_container_layer_space; 717868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (container_layer_space_to_container_target_surface_space.GetInverse( 718868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) &container_target_surface_space_to_container_layer_space)) { 719868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Note: Again, Concat is used to conver the result coordinate space from 720868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // the container render surface to the container layer. 721868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) target_surface_space_to_container_layer_space.ConcatTransform( 722868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container_target_surface_space_to_container_layer_space); 723c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 724c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 725c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 3 726c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform container_layer_space_to_target_surface_space; 727c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (target_surface_space_to_container_layer_space.GetInverse( 728c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) &container_layer_space_to_target_surface_space)) { 729c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.PreconcatTransform( 730c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) container_layer_space_to_target_surface_space); 731c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } else { 732eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // TODO(shawnsingh): A non-invertible matrix could still make meaningful 733eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // projection. For example ScaleZ(0) is non-invertible but the layer is 734eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // still visible. 735c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return gfx::Transform(); 736c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 737c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 738c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 2 739c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.Translate(position_offset.x(), position_offset.y()); 740c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 741c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 1 742c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.PreconcatTransform( 743c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) target_surface_space_to_container_layer_space); 744c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 745c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return result_transform; 746c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 747c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 748c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ApplyPositionAdjustment( 749c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) Layer* layer, 750c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) Layer* container, 751c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const gfx::Transform& scroll_compensation, 752c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform* combined_transform) {} 753c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ApplyPositionAdjustment( 754c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* layer, 755c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* container, 756c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const gfx::Transform& scroll_compensation, 757c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform* combined_transform) { 758c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (!layer->position_constraint().is_fixed_position()) 759c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return; 760c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 761c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Special case: this layer is a composited fixed-position layer; we need to 762c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // explicitly compensate for all ancestors' nonzero scroll_deltas to keep 763c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // this layer fixed correctly. 764c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note carefully: this is Concat, not Preconcat 765c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // (current_scroll_compensation * combined_transform). 766c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform->ConcatTransform(scroll_compensation); 767c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 768c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // For right-edge or bottom-edge anchored fixed position layers, 769c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the layer should relocate itself if the container changes its size. 770c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) bool fixed_to_right_edge = 771c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->position_constraint().is_fixed_to_right_edge(); 772c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) bool fixed_to_bottom_edge = 773c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->position_constraint().is_fixed_to_bottom_edge(); 774a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) gfx::Vector2dF position_offset = container->FixedContainerSizeDelta(); 775c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) position_offset.set_x(fixed_to_right_edge ? position_offset.x() : 0); 776c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) position_offset.set_y(fixed_to_bottom_edge ? position_offset.y() : 0); 777c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (position_offset.IsZero()) 778c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return; 779c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 780c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note: Again, this is Concat. The compensation matrix will be applied on 781c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the vector in target surface space. 782c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform->ConcatTransform( 783c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ComputeSizeDeltaCompensation(layer, container, position_offset)); 784c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 785c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 7862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationForThisLayer( 7872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* scrolling_layer, 7881e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& parent_matrix, 7895d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 7902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // For every layer that has non-zero scroll_delta, we have to compute a 7912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform that can undo the scroll_delta translation. In particular, we 7922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // want this matrix to premultiply a fixed-position layer's parent_matrix, so 7932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // we design this transform in three steps as follows. The steps described 7942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here apply from right-to-left, so Step 1 would be the right-most matrix: 7952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 7962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 1. transform from target surface space to the exact space where 7972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // scroll_delta is actually applied. 7989ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // -- this is inverse of parent_matrix 7992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 2. undo the scroll_delta 8002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // -- this is just a translation by scroll_delta. 8012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 3. transform back to target surface space. 8029ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // -- this transform is the parent_matrix 8032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // These steps create a matrix that both start and end in target surface 8052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. So this matrix can pre-multiply any fixed-position layer's 8062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw_transform to undo the scroll_deltas -- as long as that fixed position 8072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer is fixed onto the same render_target as this scrolling_layer. 8082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8109ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch gfx::Transform scroll_compensation_for_this_layer = parent_matrix; // Step 3 8112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer.Translate( 812424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.x(), 813424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.y()); // Step 2 8142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8159ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch gfx::Transform inverse_parent_matrix(gfx::Transform::kSkipInitialization); 8169ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch if (!parent_matrix.GetInverse(&inverse_parent_matrix)) { 8172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 8182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 8192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 8202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer.PreconcatTransform( 8219ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch inverse_parent_matrix); // Step 1 8222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return scroll_compensation_for_this_layer; 8232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationMatrixForChildren( 8262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Layer* current_layer, 8272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& current_parent_matrix, 8281e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& current_scroll_compensation, 8295d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 8302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The main thread (i.e. Layer) does not need to worry about scroll 8312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // compensation. So we can just return an identity matrix here. 8322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Transform(); 8332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationMatrixForChildren( 8362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer, 8372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& parent_matrix, 8381e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& current_scroll_compensation_matrix, 8395d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 8402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // "Total scroll compensation" is the transform needed to cancel out all 8412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // scroll_delta translations that occurred since the nearest container layer, 8422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // even if there are render_surfaces in-between. 8432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // There are some edge cases to be aware of, that are not explicit in the 8452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // code: 8462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that is both a fixed-position and container should not be its 8472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // own container, instead, that means it is fixed to an ancestor, and is a 8482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // container for any fixed-position descendants. 8492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that is a fixed-position container and has a render_surface 8502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // should behave the same as a container without a render_surface, the 8512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surface is irrelevant in that case. 8522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that does not have an explicit container is simply fixed to the 8532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // viewport. (i.e. the root render_surface.) 8542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - If the fixed-position layer has its own render_surface, then the 8552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surface is the one who gets fixed. 8562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This function needs to be called AFTER layers create their own 8582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surfaces. 8592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8614e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // Scroll compensation restarts from identity under two possible conditions: 8624e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - the current layer is a container for fixed-position descendants 8634e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - the current layer is fixed-position itself, so any fixed-position 8644e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // descendants are positioned with respect to this layer. Thus, any 8654e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // fixed position descendants only need to compensate for scrollDeltas 8664e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // that occur below this layer. 8674e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool current_layer_resets_scroll_compensation_for_descendants = 8684e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->IsContainerForFixedPositionLayers() || 8694e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->position_constraint().is_fixed_position(); 8704e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) 8712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Avoid the overheads (including stack allocation and matrix 8722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // initialization/copy) if we know that the scroll compensation doesn't need 8732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to be reset or adjusted. 8744e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!current_layer_resets_scroll_compensation_for_descendants && 875424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.IsZero() && !layer->render_surface()) 8762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return current_scroll_compensation_matrix; 8772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Start as identity matrix. 8792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform next_scroll_compensation_matrix; 8802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8814e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // If this layer does not reset scroll compensation, then it inherits the 8824e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // existing scroll compensations. 8834e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!current_layer_resets_scroll_compensation_for_descendants) 8842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix = current_scroll_compensation_matrix; 8852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the current layer has a non-zero scroll_delta, then we should compute 8872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // its local scroll compensation and accumulate it to the 8882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // next_scroll_compensation_matrix. 889424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!scroll_delta.IsZero()) { 8902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform scroll_compensation_for_this_layer = 891c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ComputeScrollCompensationForThisLayer( 8921e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) layer, parent_matrix, scroll_delta); 8932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix.PreconcatTransform( 8942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer); 8952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 8962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer created its own render_surface, we have to adjust 8982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // next_scroll_compensation_matrix. The adjustment allows us to continue 8992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // using the scroll compensation on the next surface. 9002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 1 (right-most in the math): transform from the new surface to the 9012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // original ancestor surface 9022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 2: apply the scroll compensation 9032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 3: transform back to the new surface. 9042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->render_surface() && 9052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !next_scroll_compensation_matrix.IsIdentity()) { 9062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_surface_draw_transform( 9072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 9082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->render_surface()->draw_transform().GetInverse( 9092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_surface_draw_transform)) { 9102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 9112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 9122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix = 9142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) inverse_surface_draw_transform * next_scroll_compensation_matrix * 9152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->draw_transform(); 9162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return next_scroll_compensation_matrix; 9192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 922f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)static inline void UpdateLayerScaleDrawProperties( 923c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerType* layer, 924f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float ideal_contents_scale, 925f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float maximum_animation_contents_scale, 926f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float page_scale_factor, 927f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float device_scale_factor) { 928f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().ideal_contents_scale = ideal_contents_scale; 929f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().maximum_animation_contents_scale = 930f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) maximum_animation_contents_scale; 931f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().page_scale_factor = page_scale_factor; 932f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().device_scale_factor = device_scale_factor; 933f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)} 934f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 935f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)static inline void CalculateContentsScale( 936f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) LayerImpl* layer, 937f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float contents_scale, 938f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float device_scale_factor, 939f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float page_scale_factor, 940f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float maximum_animation_contents_scale, 941f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) bool animating_transform_to_screen) { 942f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // LayerImpl has all of its content scales and bounds pushed from the Main 943f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // thread during commit and just uses those values as-is. 944f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)} 945f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 946f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)static inline void CalculateContentsScale( 947f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) Layer* layer, 948c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float contents_scale, 949c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float device_scale_factor, 950c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float page_scale_factor, 951c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale, 952c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool animating_transform_to_screen) { 9532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->CalculateContentsScale(contents_scale, 954b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 955b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 956c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 9572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen, 9582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().contents_scale_x, 9592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().contents_scale_y, 9602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().content_bounds); 9612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 962f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) Layer* mask_layer = layer->mask_layer(); 9632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (mask_layer) { 9642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer->CalculateContentsScale( 9652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) contents_scale, 966b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 967b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 968c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 9692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen, 9702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().contents_scale_x, 9712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().contents_scale_y, 9722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().content_bounds); 9732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 975f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) Layer* replica_mask_layer = 9762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL; 9772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (replica_mask_layer) { 9782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_layer->CalculateContentsScale( 9792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) contents_scale, 980b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 981b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 982c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 9832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen, 9842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().contents_scale_x, 9852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().contents_scale_y, 9862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().content_bounds); 9872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void UpdateLayerContentsScale( 9912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer, 992b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool can_adjust_raster_scale, 993c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale, 9942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float device_scale_factor, 9952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float page_scale_factor, 996c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale, 9972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen) { 998c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CalculateContentsScale(layer, 999c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale, 1000b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 1001b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 1002c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 1003c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) animating_transform_to_screen); 10042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 10052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 10062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void UpdateLayerContentsScale( 10072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Layer* layer, 1008b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool can_adjust_raster_scale, 1009c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale, 10102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float device_scale_factor, 10112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float page_scale_factor, 1012c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale, 10132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen) { 1014b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (can_adjust_raster_scale) { 1015c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_raster_scale = 1016c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale / (device_scale_factor * page_scale_factor); 10172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1018b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool need_to_set_raster_scale = layer->raster_scale_is_unknown(); 10192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 10202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If we've previously saved a raster_scale but the ideal changes, things 10212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // are unpredictable and we should just use 1. 1022b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (!need_to_set_raster_scale && layer->raster_scale() != 1.f && 1023b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ideal_raster_scale != layer->raster_scale()) { 10242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ideal_raster_scale = 1.f; 10252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) need_to_set_raster_scale = true; 10262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 10282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (need_to_set_raster_scale) { 10292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool use_and_save_ideal_scale = 10302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ideal_raster_scale >= 1.f && !animating_transform_to_screen; 1031b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (use_and_save_ideal_scale) 1032b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) layer->set_raster_scale(ideal_raster_scale); 10332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1036b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) float raster_scale = 1.f; 1037b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (!layer->raster_scale_is_unknown()) 1038b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) raster_scale = layer->raster_scale(); 1039b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 1040a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) gfx::Size old_content_bounds = layer->content_bounds(); 1041a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) float old_contents_scale_x = layer->contents_scale_x(); 1042a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) float old_contents_scale_y = layer->contents_scale_y(); 10432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1044c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float contents_scale = raster_scale * device_scale_factor * page_scale_factor; 1045b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) CalculateContentsScale(layer, 1046b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) contents_scale, 1047b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 1048b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 1049c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 1050b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) animating_transform_to_screen); 1051a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) 1052a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) if (layer->content_bounds() != old_content_bounds || 1053a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->contents_scale_x() != old_contents_scale_x || 1054a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->contents_scale_y() != old_contents_scale_y) 1055a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->SetNeedsPushProperties(); 10562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 10572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1058c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateAnimationContentsScale( 1059c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch Layer* layer, 1060c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale, 1061c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float ancestor_maximum_animation_contents_scale, 1062c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& parent_transform, 1063c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& combined_transform, 1064c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool* combined_is_animating_scale, 1065c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float* combined_maximum_animation_contents_scale) { 1066c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = false; 1067c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1068c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 1069c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1070c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateAnimationContentsScale( 1071c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerImpl* layer, 1072c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale, 1073c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float ancestor_maximum_animation_contents_scale, 1074c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& ancestor_transform, 1075c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& combined_transform, 1076c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool* combined_is_animating_scale, 1077c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float* combined_maximum_animation_contents_scale) { 1078c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (ancestor_is_animating_scale && 1079c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ancestor_maximum_animation_contents_scale == 0.f) { 1080c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We've already failed to compute a maximum animated scale at an 1081c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // ancestor, so we'll continue to fail. 1082c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1083c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1084c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1085c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1086c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1087c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!combined_transform.IsScaleOrTranslation()) { 1088c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // Computing maximum animated scale in the presence of 1089c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // non-scale/translation transforms isn't supported. 1090c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1091c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1092c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1093c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1094c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1095c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We currently only support computing maximum scale for combinations of 1096c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // scales and translations. We treat all non-translations as potentially 1097c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // affecting scale. Animations that include non-translation/scale components 1098c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // will cause the computation of MaximumScale below to fail. 1099c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool layer_is_animating_scale = 1100c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch !layer->layer_animation_controller()->HasOnlyTranslationTransforms(); 1101c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1102c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer_is_animating_scale && !ancestor_is_animating_scale) { 1103c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1104c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = false; 1105c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1106c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1107c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1108c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We don't attempt to accumulate animation scale from multiple nodes, 1109c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // because of the risk of significant overestimation. For example, one node 1110c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // may be increasing scale from 1 to 10 at the same time as a descendant is 1111c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // decreasing scale from 10 to 1. Naively combining these scales would produce 1112c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // a scale of 100. 1113c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (layer_is_animating_scale && ancestor_is_animating_scale) { 1114c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1115c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1116c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1117c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1118c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1119c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // At this point, we know either the layer or an ancestor, but not both, 1120c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // is animating scale. 1121c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1122c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer_is_animating_scale) { 1123c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF layer_transform_scales = 1124c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(layer->transform(), 0.f); 1125c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 1126c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ancestor_maximum_animation_contents_scale * 1127c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(layer_transform_scales.x(), layer_transform_scales.y()); 1128c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1129c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1130c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1131c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float layer_maximum_animated_scale = 0.f; 1132c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer->layer_animation_controller()->MaximumScale( 1133c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &layer_maximum_animated_scale)) { 1134c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1135c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1136c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1137c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF ancestor_transform_scales = 1138c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f); 1139c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 1140c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch layer_maximum_animated_scale * 1141c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y()); 1142c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 1143c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 11445c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liutemplate <typename LayerType> 11455c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic inline typename LayerType::RenderSurfaceType* CreateOrReuseRenderSurface( 11465c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerType* layer) { 1147ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch if (!layer->render_surface()) { 1148ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->CreateRenderSurface(); 1149ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1150ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch } 1151ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 1152ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->render_surface()->ClearLayerLists(); 1153ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1154ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch} 1155ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 11560de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)template <typename LayerTypePtr> 11570de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)static inline void MarkLayerWithRenderSurfaceLayerListId( 11580de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) LayerTypePtr layer, 11590de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 11600de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) layer->draw_properties().last_drawn_render_surface_layer_list_id = 11610de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id; 11620de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)} 11630de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11640de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)template <typename LayerTypePtr> 11650de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)static inline void MarkMasksWithRenderSurfaceLayerListId( 11660de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) LayerTypePtr layer, 11670de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 11680de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) if (layer->mask_layer()) { 11690de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer->mask_layer(), 11700de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11710de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 11720de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { 11730de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer->replica_layer()->mask_layer(), 11740de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11750de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 11760de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)} 11770de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11780de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)template <typename LayerListType> 11790de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)static inline void MarkLayerListWithRenderSurfaceLayerListId( 11800de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) LayerListType* layer_list, 11810de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 11820de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) for (typename LayerListType::iterator it = layer_list->begin(); 11830de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) it != layer_list->end(); 11840de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) ++it) { 11850de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(*it, 11860de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11870de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkMasksWithRenderSurfaceLayerListId(*it, 11880de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11890de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 11900de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)} 11910de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11928bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 11932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void RemoveSurfaceForEarlyExit( 11942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer_to_remove, 11958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* render_surface_layer_list) { 11962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer_to_remove->render_surface()); 11972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Technically, we know that the layer we want to remove should be 11982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // at the back of the render_surface_layer_list. However, we have had 11992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // bugs before that added unnecessary layers here 12002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes 12012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // things to crash. So here we proactively remove any additional 12022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers from the end of the list. 12032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) while (render_surface_layer_list->back() != layer_to_remove) { 12040de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerListWithRenderSurfaceLayerListId( 12050de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &render_surface_layer_list->back()->render_surface()->layer_list(), 0); 12060de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(render_surface_layer_list->back(), 0); 12070de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 12085c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu render_surface_layer_list->back()->ClearRenderSurfaceLayerList(); 12092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->pop_back(); 12102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 12112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove); 12120de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerListWithRenderSurfaceLayerListId( 12130de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &layer_to_remove->render_surface()->layer_list(), 0); 12140de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer_to_remove, 0); 12152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->pop_back(); 12165c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu layer_to_remove->ClearRenderSurfaceLayerList(); 12172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 12182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12197dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstruct PreCalculateMetaInformationRecursiveData { 12207dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool layer_or_descendant_has_copy_request; 1221f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) bool layer_or_descendant_has_input_handler; 1222424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) int num_unclipped_descendants; 12237dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12247dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData() 1225424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : layer_or_descendant_has_copy_request(false), 1226f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer_or_descendant_has_input_handler(false), 1227424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) num_unclipped_descendants(0) {} 12287dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12297dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch void Merge(const PreCalculateMetaInformationRecursiveData& data) { 12307dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer_or_descendant_has_copy_request |= 12317dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch data.layer_or_descendant_has_copy_request; 1232f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer_or_descendant_has_input_handler |= 1233f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data.layer_or_descendant_has_input_handler; 1234424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) num_unclipped_descendants += 1235424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) data.num_unclipped_descendants; 12367dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch } 12377dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch}; 12387dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Recursively walks the layer tree to compute any information that is needed 12402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// before doing the main recursion. 12412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 12427dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstatic void PreCalculateMetaInformation( 12437dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch LayerType* layer, 12447dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData* recursive_data) { 12457dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool has_delegated_content = layer->HasDelegatedContent(); 12462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) int num_descendants_that_draw_content = 0; 12477dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 1248010d83a9304c5a91596085d917d248abff47903aTorne (Richard Coles) layer->draw_properties().sorted_for_recursion = false; 1249010d83a9304c5a91596085d917d248abff47903aTorne (Richard Coles) layer->draw_properties().has_child_with_a_scroll_parent = false; 1250010d83a9304c5a91596085d917d248abff47903aTorne (Richard Coles) 12515c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu if (!HasInvertibleOrAnimatedTransform(layer)) { 12520529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // Layers with singular transforms should not be drawn, the whole subtree 12530529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // can be skipped. 12540529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return; 12550529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch } 12560529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 12577dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (has_delegated_content) { 12587dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // Layers with delegated content need to be treated as if they have as 12597dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // many children as the number of layers they own delegated quads for. 12607dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // Since we don't know this number right now, we choose one that acts like 12617dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // infinity for our purposes. 12627dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch num_descendants_that_draw_content = 1000; 12637dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch } 12642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1265424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_parent()) 1266424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants++; 1267424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 12682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (size_t i = 0; i < layer->children().size(); ++i) { 1269868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerType* child_layer = 12705c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i); 12712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12727dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData data_for_child; 12737dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformation(child_layer, &data_for_child); 12747dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12754e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content += child_layer->DrawsContent() ? 1 : 0; 12764e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content += 12774e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) child_layer->draw_properties().num_descendants_that_draw_content; 12787dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child_layer->scroll_parent()) 12808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->draw_properties().has_child_with_a_scroll_parent = true; 12817dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->Merge(data_for_child); 12822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 12832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1284424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_children()) { 1285424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) int num_clip_children = layer->clip_children()->size(); 1286424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children); 1287424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants -= num_clip_children; 1288424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1289424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 12907dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->HasCopyRequest()) 12917dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->layer_or_descendant_has_copy_request = true; 12927dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 1293f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (!layer->touch_event_handler_region().IsEmpty() || 1294f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->have_wheel_event_handlers()) 1295f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) recursive_data->layer_or_descendant_has_input_handler = true; 1296f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 12972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_properties().num_descendants_that_draw_content = 12982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content; 1299424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer->draw_properties().num_unclipped_descendants = 1300424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants; 13017dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->draw_properties().layer_or_descendant_has_copy_request = 13027dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->layer_or_descendant_has_copy_request; 1303f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().layer_or_descendant_has_input_handler = 1304f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) recursive_data->layer_or_descendant_has_input_handler; 13052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 13062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 13072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static void RoundTranslationComponents(gfx::Transform* transform) { 130868043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) transform->matrix().set(0, 3, MathUtil::Round(transform->matrix().get(0, 3))); 130968043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) transform->matrix().set(1, 3, MathUtil::Round(transform->matrix().get(1, 3))); 13102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 13112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 13122385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochtemplate <typename LayerType> 13132385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochstruct SubtreeGlobals { 13142385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch LayerSorter* layer_sorter; 13152385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch int max_texture_size; 13162385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float device_scale_factor; 13172385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float page_scale_factor; 13181e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const LayerType* page_scale_application_layer; 13192385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool can_adjust_raster_scales; 13204e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool can_render_to_separate_surface; 13212385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch}; 13222385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13238bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template<typename LayerType> 13242385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochstruct DataForRecursion { 13252385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The accumulated sequence of transforms a layer will use to determine its 13262385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // own draw transform. 13272385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform parent_matrix; 13282385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13292385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The accumulated sequence of transforms a layer will use to determine its 13302385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // own screen-space transform. 13312385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform full_hierarchy_matrix; 13322385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13332385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The transform that removes all scrolling that may have occurred between a 13342385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // fixed-position layer and its container, so that the layer actually does 13352385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // remain fixed. 13362385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform scroll_compensation_matrix; 13372385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13382385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The ancestor that would be the container for any fixed-position / sticky 13392385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // layers. 13402385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch LayerType* fixed_container; 13412385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13422385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // This is the normal clip rect that is propagated from parent to child. 13432385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Rect clip_rect_in_target_space; 13442385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13452385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // When the layer's children want to compute their visible content rect, they 13462385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // want to know what their target surface's clip rect will be. BUT - they 13472385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // want to know this clip rect represented in their own target space. This 13482385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // requires inverse-projecting the surface's clip rect from the surface's 13492385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // render target space down to the surface's own space. Instead of computing 13502385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // this value redundantly for each child layer, it is computed only once 13512385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // while dealing with the parent layer, and then this precomputed value is 13522385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // passed down the recursion to the children that actually use it. 13532385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Rect clip_rect_of_target_surface_in_target_space; 13542385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 1355c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // The maximum amount by which this layer will be scaled during the lifetime 1356c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // of currently running animations. 1357c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale; 1358c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1359c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale; 13602385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool ancestor_clips_subtree; 13618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* 1362f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface; 13632385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool in_subtree_of_page_scale_application_layer; 13642385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool subtree_can_use_lcd_text; 13652385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool subtree_is_visible_from_ancestor; 13662385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch}; 13672385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static LayerType* GetChildContainingLayer(const LayerType& parent, 13708bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* layer) { 13718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (LayerType* ancestor = layer; ancestor; ancestor = ancestor->parent()) { 13728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (ancestor->parent() == &parent) 13738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return ancestor; 13748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) NOTREACHED(); 13768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return 0; 13778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void AddScrollParentChain(std::vector<LayerType*>* out, 13818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent, 13828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* layer) { 13838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // At a high level, this function walks up the chain of scroll parents 13848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // recursively, and once we reach the end of the chain, we add the child 13858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // of |parent| containing each scroll ancestor as we unwind. The result is 13868bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // an ordering of parent's children that ensures that scroll parents are 13878bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visited before their descendants. 13888bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Take for example this layer tree: 13898bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13908bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + stacking_context 13918bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_child (1) 13928bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_parent_graphics_layer (*) 13938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // | + scroll_parent_scrolling_layer 13948bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // | + scroll_parent_scrolling_content_layer (2) 13958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_graphics_layer (**) 13968bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_scrolling_layer 13978bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_scrolling_content_layer (3) 13988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // The scroll child is (1), its scroll parent is (2) and its scroll 14008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // grandparent is (3). Note, this doesn't mean that (2)'s scroll parent is 14018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // (3), it means that (*)'s scroll parent is (3). We don't want our list to 14028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // look like [ (3), (2), (1) ], even though that does have the ancestor chain 14038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // in the right order. Instead, we want [ (**), (*), (1) ]. That is, only want 14048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // (1)'s siblings in the list, but we want them to appear in such an order 14058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // that the scroll ancestors get visited in the correct order. 14068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 14078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // So our first task at this step of the recursion is to determine the layer 14088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // that we will potentionally add to the list. That is, the child of parent 14098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // containing |layer|. 14108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* child = GetChildContainingLayer(parent, layer); 14118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child->draw_properties().sorted_for_recursion) 14128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return; 14138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (LayerType* scroll_parent = child->scroll_parent()) 14158bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) AddScrollParentChain(out, parent, scroll_parent); 14168bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14178bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) out->push_back(child); 14188bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().sorted_for_recursion = true; 14198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14208bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14228bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static bool SortChildrenForRecursion(std::vector<LayerType*>* out, 14238bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent) { 14248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) out->reserve(parent.children().size()); 14258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) bool order_changed = false; 14268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < parent.children().size(); ++i) { 14278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* current = 14285c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerTreeHostCommon::get_layer_as_raw_ptr(parent.children(), i); 14298bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14308bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (current->draw_properties().sorted_for_recursion) { 14318bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) order_changed = true; 14328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) continue; 14338bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 14348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) AddScrollParentChain(out, parent, current); 14368bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 14378bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14388bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DCHECK_EQ(parent.children().size(), out->size()); 14398bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return order_changed; 14408bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14418bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14438bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void GetNewDescendantsStartIndexAndCount(LayerType* layer, 14448bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* start_index, 14458bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* count) { 14468bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *start_index = layer->draw_properties().index_of_first_descendants_addition; 14478bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *count = layer->draw_properties().num_descendants_added; 14488bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14498bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14508bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void GetNewRenderSurfacesStartIndexAndCount(LayerType* layer, 14528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* start_index, 14538bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* count) { 14548bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *start_index = layer->draw_properties() 14558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) .index_of_first_render_surface_layer_list_addition; 14568bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *count = layer->draw_properties().num_render_surfaces_added; 14578bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14588bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14595c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu// We need to extract a list from the the two flavors of RenderSurfaceListType 14605c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu// for use in the sorting function below. 14615c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic LayerList* GetLayerListForSorting(RenderSurfaceLayerList* rsll) { 14625c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu return &rsll->AsLayerList(); 14635c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu} 14645c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu 14655c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic LayerImplList* GetLayerListForSorting(LayerImplList* layer_list) { 14665c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu return layer_list; 14675c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu} 14685c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu 14695c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liutemplate <typename LayerType, typename GetIndexAndCountType> 14708bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void SortLayerListContributions( 14718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent, 14725c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu typename LayerType::LayerListType* unsorted, 14738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t start_index_for_all_contributions, 14748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) GetIndexAndCountType get_index_and_count) { 14758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::LayerListType buffer; 14768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < parent.children().size(); ++i) { 14778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* child = 14785c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerTreeHostCommon::get_layer_as_raw_ptr(parent.children(), i); 14798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t start_index = 0; 14818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t count = 0; 14828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) get_index_and_count(child, &start_index, &count); 14838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t j = start_index; j < start_index + count; ++j) 14848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) buffer.push_back(unsorted->at(j)); 14858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 14868bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14878bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DCHECK_EQ(buffer.size(), 14888bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) unsorted->size() - start_index_for_all_contributions); 14898bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14908bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < buffer.size(); ++i) 14918bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) (*unsorted)[i + start_index_for_all_contributions] = buffer[i]; 14928bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Recursively walks the layer tree starting at the given node and computes all 14952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// the necessary transformations, clip rects, render surfaces, etc. 14968bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static void CalculateDrawPropertiesInternal( 14982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 14992385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch const SubtreeGlobals<LayerType>& globals, 15008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const DataForRecursion<LayerType>& data_from_ancestor, 15018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* render_surface_layer_list, 15025c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu typename LayerType::LayerListType* layer_list, 15030de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerType> >* accumulated_surface_state, 15040de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 15052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This function computes the new matrix transformations recursively for this 15062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer and all its descendants. It also computes the appropriate render 15072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surfaces. 15082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some important points to remember: 15092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 0. Here, transforms are notated in Matrix x Vector order, and in words we 15112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // describe what the transform does from left to right. 15122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 1. In our terminology, the "layer origin" refers to the top-left corner of 15142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // a layer, and the positive Y-axis points downwards. This interpretation is 15152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // valid because the orthographic projection applied at draw time flips the Y 15162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // axis appropriately. 15172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 2. The anchor point, when given as a PointF object, is specified in "unit 15192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer space", where the bounds of the layer map to [0, 1]. However, as a 15202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Transform object, the transform to the anchor point is specified in "layer 15212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space", where the bounds of the layer map to [bounds.width(), 15222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // bounds.height()]. 15232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 3. Definition of various transforms used: 15252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[parent] is the parent matrix, with respect to the nearest render 15262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surface, passed down recursively. 15272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[root] is the full hierarchy, with respect to the root, passed down 15292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // recursively. 15302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin] is the translation matrix from the parent's origin to 15322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this layer's origin. 15332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor] is the translation from the layer's origin to its 15352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // anchor point 15362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2center] is the translation from the layer's origin to its 15382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // center 15392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[layer] is the layer's matrix (applied at the anchor point) 15412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] is the ratio of a layer's content_bounds() to its 15432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Bounds(). 15442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some composite transforms can help in understanding the sequence of 15462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transforms: 15472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // composite_layer_transform = Tr[origin2anchor] * M[layer] * 15482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor].inverse() 15492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4. When a layer (or render surface) is drawn, it is drawn into a "target 15512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render surface". Therefore the draw transform does not necessarily 15522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform from screen space to local layer space. Instead, the draw 15532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform is the transform between the "target render surface space" and 15542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // local layer space. Note that render surfaces, except for the root, also 15552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw themselves into a different target render surface, and so their draw 15562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform and origin transforms are also described with respect to the 15572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // target. 15582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Using these definitions, then: 15602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The draw transform for the layer is: 15622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] = M[parent] * Tr[origin] * composite_layer_transform * 15632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] = M[parent] * Tr[layer->position() + anchor] * 15642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[layer] * Tr[anchor2origin] * S[layer2content] 15652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Interpreting the math left-to-right, this transforms from the 15672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's render surface to the origin of the layer in content space. 15682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The screen space transform is: 15702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[screenspace] = M[root] * Tr[origin] * composite_layer_transform * 15712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] 15722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // = M[root] * Tr[layer->position() + anchor] * M[layer] 15732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // * Tr[anchor2origin] * S[layer2content] 15742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Interpreting the math left-to-right, this transforms from the root 15762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render surface's content space to the origin of the layer in content 15772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. 15782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The transform hierarchy that is passed on to children (i.e. the child's 15802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // parent_matrix) is: 15812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[parent]_for_child = M[parent] * Tr[origin] * 15825d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // composite_layer_transform 15832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // = M[parent] * Tr[layer->position() + anchor] * 15845d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // M[layer] * Tr[anchor2origin] 15852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and a similar matrix for the full hierarchy with respect to the 15872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // root. 15882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Finally, note that the final matrix used by the shader for the layer is P * 15902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] * S . This final product is computed in drawTexturedQuad(), where: 15912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // P is the projection matrix 15922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S is the scale adjustment (to scale up a canonical quad to the 15932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's size) 15942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // When a render surface has a replica layer, that layer's transform is used 15962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to draw a second copy of the surface. gfx::Transforms named here are 15972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // relative to the surface, unless they specify they are relative to the 15982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // replica layer. 15992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 16002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // We will denote a scale by device scale S[deviceScale] 16012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 16022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The render surface draw transform to its target surface origin is: 16032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[surfaceDraw] = M[owningLayer->Draw] 16042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 16052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The render surface origin transform to its the root (screen space) origin 16062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // is: 16072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[surface2root] = M[owningLayer->screenspace] * 16082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[deviceScale].inverse() 16092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 16102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The replica draw transform to its target surface origin is: 16112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * 16122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[replica->position() + replica->anchor()] * Tr[replica] * 16132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor].inverse() * S[contents_scale].inverse() 16142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 16152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The replica draw transform to the root (screen space) origin is: 16162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[replica2root] = M[surface2root] * Tr[replica->position()] * 16172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[replica] * Tr[origin2anchor].inverse() 16182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 16192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1620c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // It makes no sense to have a non-unit page_scale_factor without specifying 1621c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // which layer roots the subtree the scale is applied to. 16222385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch DCHECK(globals.page_scale_application_layer || 16232385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch (globals.page_scale_factor == 1.f)); 1624c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 16258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<LayerType> data_for_children; 16268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* 1627f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface = 1628f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) data_from_ancestor.nearest_occlusion_immune_ancestor_surface; 16292385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.in_subtree_of_page_scale_application_layer = 16302385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.in_subtree_of_page_scale_application_layer; 16312385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.subtree_can_use_lcd_text = 16322385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_can_use_lcd_text; 16332385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 16345d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Layers that are marked as hidden will hide themselves and their subtree. 16355d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Exception: Layers with copy requests, whether hidden or not, must be drawn 16365d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // anyway. In this case, we will inform their subtree they are visible to get 16375d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // the right results. 16385d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const bool layer_is_visible = 16392385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_is_visible_from_ancestor && 16402385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch !layer->hide_layer_and_subtree(); 16415d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest(); 16427dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 16432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer cannot skip CalcDrawProperties. 16445d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) { 1645424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) 16465c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu layer->ClearRenderSurfaceLayerList(); 16472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 1648424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1649424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1650424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We need to circumvent the normal recursive flow of information for clip 1651424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // children (they don't inherit their direct ancestor's clip information). 1652424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // This is unfortunate, and would be unnecessary if we were to formally 1653424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // separate the clipping hierarchy from the layer hierarchy. 1654424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree; 1655424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect ancestor_clip_rect_in_target_space = 1656424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) data_from_ancestor.clip_rect_in_target_space; 1657424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1658424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Update our clipping state. If we have a clip parent we will need to pull 1659424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // from the clip state cache rather than using the clip state passed from our 1660424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // immediate ancestor. 16618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) UpdateClipRectsForClipChild<LayerType>( 1662424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer, &ancestor_clip_rect_in_target_space, &ancestor_clips_subtree); 16632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // As this function proceeds, these are the properties for the current 16652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer that actually get computed. To avoid unnecessary copies 16662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // (particularly for matrices), we do computations directly on these values 16672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // when possible. 16688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& layer_draw_properties = layer->draw_properties(); 16692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1670a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch gfx::Rect clip_rect_in_target_space; 1671a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch bool layer_or_ancestor_clips_descendants = false; 16722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This value is cached on the stack so that we don't have to inverse-project 16742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the surface's clip rect redundantly for every layer. This value is the 1675a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // same as the target surface's clip rect, except that instead of being 1676a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // described in the target surface's target's space, it is described in the 1677a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // current render target's space. 1678a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch gfx::Rect clip_rect_of_target_surface_in_target_space; 16792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float accumulated_draw_opacity = layer->opacity(); 16812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_opacity_to_target = layer->OpacityIsAnimating(); 16822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_opacity_to_screen = animating_opacity_to_target; 16832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) { 16842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) accumulated_draw_opacity *= layer->parent()->draw_opacity(); 16852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_target |= layer->parent()->draw_opacity_is_animating(); 16862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen |= 16872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->screen_space_opacity_is_animating(); 16882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_target = layer->TransformIsAnimating(); 16912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen = animating_transform_to_target; 16922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) { 16932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target |= 16942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->draw_transform_is_animating(); 16952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen |= 16962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->screen_space_transform_is_animating(); 16972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 169846d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) gfx::Point3F transform_origin = layer->transform_origin(); 1699424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF scroll_offset = GetEffectiveTotalScrollOffset(layer); 1700424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::PointF position = layer->position() - scroll_offset; 17012385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform combined_transform = data_from_ancestor.parent_matrix; 17022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->transform().IsIdentity()) { 170346d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2transformOrigin] 170446d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) combined_transform.Translate3d(position.x() + transform_origin.x(), 170546d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) position.y() + transform_origin.y(), 170646d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) transform_origin.z()); 170746d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2origin] * M[layer] 17082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.PreconcatTransform(layer->transform()); 170946d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2origin] * M[layer] * 171046d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // Tr[transformOrigin2origin] 171146d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) combined_transform.Translate3d( 171246d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) -transform_origin.x(), -transform_origin.y(), -transform_origin.z()); 17132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 17142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.Translate(position.x(), position.y()); 17152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 17162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17171e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF effective_scroll_delta = GetEffectiveScrollDelta(layer); 17182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!animating_transform_to_target && layer->scrollable() && 17192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.IsScaleOrTranslation()) { 17202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Align the scrollable layer's position to screen space pixels to avoid 17212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // blurriness. To avoid side-effects, do this only if the transform is 17222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // simple. 17231e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF previous_translation = combined_transform.To2dTranslation(); 17242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RoundTranslationComponents(&combined_transform); 17251e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF current_translation = combined_transform.To2dTranslation(); 17261e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 17271e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // This rounding changes the scroll delta, and so must be included 1728e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // in the scroll compensation matrix. The scaling converts from physical 1729e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // coordinates to the scroll delta's CSS coordinates (using the parent 1730e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // matrix instead of combined transform since scrolling is applied before 1731e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // the layer's transform). For example, if we have a total scale factor of 1732e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // 3.0, then 1 physical pixel is only 1/3 of a CSS pixel. 1733e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch gfx::Vector2dF parent_scales = MathUtil::ComputeTransform2dScaleComponents( 1734e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch data_from_ancestor.parent_matrix, 1.f); 1735e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch effective_scroll_delta -= 1736e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch gfx::ScaleVector2d(current_translation - previous_translation, 1737e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch 1.f / parent_scales.x(), 1738e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch 1.f / parent_scales.y()); 17392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 17402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1741c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply adjustment from position constraints. 17422385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch ApplyPositionAdjustment(layer, data_from_ancestor.fixed_container, 17432385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.scroll_compensation_matrix, &combined_transform); 1744c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1745c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool combined_is_animating_scale = false; 1746c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float combined_maximum_animation_contents_scale = 0.f; 1747c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (globals.can_adjust_raster_scales) { 1748c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch CalculateAnimationContentsScale( 1749c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch layer, 1750c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.ancestor_is_animating_scale, 1751c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.maximum_animation_contents_scale, 1752c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.parent_matrix, 1753c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_transform, 1754c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &combined_is_animating_scale, 1755c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &combined_maximum_animation_contents_scale); 1756c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1757c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_children.ancestor_is_animating_scale = combined_is_animating_scale; 1758c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_children.maximum_animation_contents_scale = 1759c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_maximum_animation_contents_scale; 1760c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1761c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Compute the 2d scale components of the transform hierarchy up to the target 1762c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // surface. From there, we can decide on a contents scale for the layer. 17632385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float layer_scale_factors = globals.device_scale_factor; 17642385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch if (data_from_ancestor.in_subtree_of_page_scale_application_layer) 17652385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_scale_factors *= globals.page_scale_factor; 1766c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Vector2dF combined_transform_scales = 1767c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) MathUtil::ComputeTransform2dScaleComponents( 1768c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform, 1769b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) layer_scale_factors); 1770b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 1771c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale = 17722385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales 1773b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ? std::max(combined_transform_scales.x(), 1774b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) combined_transform_scales.y()) 1775b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) : layer_scale_factors; 1776c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) UpdateLayerContentsScale( 1777c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer, 17782385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales, 1779c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale, 17802385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.device_scale_factor, 1781c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.in_subtree_of_page_scale_application_layer 1782c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ? globals.page_scale_factor 1783c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch : 1.f, 1784c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_maximum_animation_contents_scale, 1785c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) animating_transform_to_screen); 17862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1787f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) UpdateLayerScaleDrawProperties( 1788f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer, 1789f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ideal_contents_scale, 1790f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) combined_maximum_animation_contents_scale, 1791f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data_from_ancestor.in_subtree_of_page_scale_application_layer 1792f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ? globals.page_scale_factor 1793f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) : 1.f, 1794f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) globals.device_scale_factor); 1795f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 1796f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) LayerType* mask_layer = layer->mask_layer(); 1797f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (mask_layer) { 1798f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) UpdateLayerScaleDrawProperties( 1799f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) mask_layer, 1800f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ideal_contents_scale, 1801f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) combined_maximum_animation_contents_scale, 1802f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data_from_ancestor.in_subtree_of_page_scale_application_layer 1803f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ? globals.page_scale_factor 1804f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) : 1.f, 1805f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) globals.device_scale_factor); 1806f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) } 1807f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 1808f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) LayerType* replica_mask_layer = 1809f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL; 1810f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (replica_mask_layer) { 1811f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) UpdateLayerScaleDrawProperties( 1812f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) replica_mask_layer, 1813f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ideal_contents_scale, 1814f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) combined_maximum_animation_contents_scale, 1815f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data_from_ancestor.in_subtree_of_page_scale_application_layer 1816f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ? globals.page_scale_factor 1817f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) : 1.f, 1818f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) globals.device_scale_factor); 1819f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) } 1820f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 18212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The draw_transform that gets computed below is effectively the layer's 18222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw_transform, unless the layer itself creates a render_surface. In that 18232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // case, the render_surface re-parents the transforms. 18242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform = combined_transform; 18252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] = M[parent] * LT * S[layer2content] 182658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) layer_draw_properties.target_space_transform.Scale( 182758537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) SK_MScalar1 / layer->contents_scale_x(), 182858537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) SK_MScalar1 / layer->contents_scale_y()); 18292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The layer's screen_space_transform represents the transform between root 18312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's "screen space" and local content space. 18322385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_draw_properties.screen_space_transform = 18332385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.full_hierarchy_matrix; 18345d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->should_flatten_transform()) 18352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform.FlattenTo2d(); 18362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform.PreconcatTransform 18372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer_draw_properties.target_space_transform); 18382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Adjusting text AA method during animation may cause repaints, which in-turn 18402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // causes jank. 18412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool adjust_text_aa = 18422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !animating_opacity_to_screen && !animating_transform_to_screen; 18432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // To avoid color fringing, LCD text should only be used on opaque layers with 18442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // just integral translation. 18452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool layer_can_use_lcd_text = 18462385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_can_use_lcd_text && 18472385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch accumulated_draw_opacity == 1.f && 18482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform. 18492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) IsIdentityOrIntegerTranslation(); 18502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1851f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) gfx::Rect content_rect(layer->content_bounds()); 18522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // full_hierarchy_matrix is the matrix that transforms objects between screen 18542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space (except projection matrix) and the most recent RenderSurfaceImpl's 18552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. next_hierarchy_matrix will only change if this layer uses a new 18562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // RenderSurfaceImpl, otherwise remains the same. 18572385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.full_hierarchy_matrix = 18582385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.full_hierarchy_matrix; 18592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1860b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If the subtree will scale layer contents by the transform hierarchy, then 1861b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // we should scale things into the render surface by the transform hierarchy 1862b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // to take advantage of that. 1863b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) gfx::Vector2dF render_surface_sublayer_scale = 18642385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales 1865b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ? combined_transform_scales 1866b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) : gfx::Vector2dF(layer_scale_factors, layer_scale_factors); 18672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18684e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool render_to_separate_surface; 18694e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (globals.can_render_to_separate_surface) { 18704e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) render_to_separate_surface = SubtreeShouldRenderToSeparateSurface( 18714e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer, combined_transform.Preserves2dAxisAlignment()); 18724e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } else { 18734e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) render_to_separate_surface = IsRootLayer(layer); 18744e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } 18754e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (render_to_separate_surface) { 18762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Check back-face visibility before continuing with this surface and its 18772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // subtree 18782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->double_sided() && TransformToParentIsKnown(layer) && 1879424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) IsSurfaceBackFaceVisible(layer, combined_transform)) { 18805c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu layer->ClearRenderSurfaceLayerList(); 18812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 1882424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 18832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* render_surface = 18858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) CreateOrReuseRenderSurface(layer); 18862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1887b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (IsRootLayer(layer)) { 1888868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The root layer's render surface size is predetermined and so the root 1889868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // layer can't directly support non-identity transforms. It should just 1890868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // forward top-level transforms to the rest of the tree. 18912385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix = combined_transform; 18927dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 18937dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // The root surface does not contribute to any other surface, it has no 18947dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // target. 18957dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->render_surface()->set_contributes_to_drawn_surface(false); 1896868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } else { 1897868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The owning layer's draw transform has a scale from content to layer 1898868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // space which we do not want; so here we use the combined_transform 1899868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // instead of the draw_transform. However, we do need to add a different 1900868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale factor that accounts for the surface's pixel dimensions. 1901868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) combined_transform.Scale(1.0 / render_surface_sublayer_scale.x(), 1902868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1.0 / render_surface_sublayer_scale.y()); 1903868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface->SetDrawTransform(combined_transform); 1904868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1905868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The owning layer's transform was re-parented by the surface, so the 1906868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // layer's new draw_transform only needs to scale the layer to surface 1907868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // space. 1908868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) layer_draw_properties.target_space_transform.MakeIdentity(); 1909868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) layer_draw_properties.target_space_transform. 1910868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) Scale(render_surface_sublayer_scale.x() / layer->contents_scale_x(), 1911868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface_sublayer_scale.y() / layer->contents_scale_y()); 1912868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1913868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Inside the surface's subtree, we scale everything to the owning layer's 1914868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale. The sublayer matrix transforms layer rects into target surface 1915868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // content space. Conceptually, all layers in the subtree inherit the 1916868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale at the point of the render surface in the transform hierarchy, 1917868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // but we apply it explicitly to the owning layer and the remainder of the 1918868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // subtree independently. 19192385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch DCHECK(data_for_children.parent_matrix.IsIdentity()); 19202385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix.Scale(render_surface_sublayer_scale.x(), 1921868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface_sublayer_scale.y()); 19227dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 19235d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Even if the |layer_is_drawn|, it only contributes to a drawn surface 19245d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // when the |layer_is_visible|. 19257dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->render_surface()->set_contributes_to_drawn_surface( 19262385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_is_visible); 1927b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 1928b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 19292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The opacity value is moved from the layer to its surface, so that the 19302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // entire subtree properly inherits opacity. 19312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetDrawOpacity(accumulated_draw_opacity); 19322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetDrawOpacityIsAnimating(animating_opacity_to_target); 19332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_target = false; 19342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity = 1.f; 19352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity_is_animating = animating_opacity_to_target; 19362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_opacity_is_animating = 19372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen; 19382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetTargetSurfaceTransformsAreAnimating( 19402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target); 19412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetScreenSpaceTransformsAreAnimating( 19422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen); 19432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target = false; 19442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform_is_animating = 19452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target; 19462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform_is_animating = 19472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen; 19482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Update the aggregate hierarchy matrix to include the transform of the 19502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // newly created RenderSurfaceImpl. 19512385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.full_hierarchy_matrix.PreconcatTransform( 19522385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch render_surface->draw_transform()); 19532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->mask_layer()) { 19558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& mask_layer_draw_properties = 19562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->mask_layer()->draw_properties(); 19572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer_draw_properties.render_target = layer; 19582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer_draw_properties.visible_content_rect = 19592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()); 19602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { 19638bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& replica_mask_draw_properties = 19642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->mask_layer()->draw_properties(); 19652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_draw_properties.render_target = layer; 19662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_draw_properties.visible_content_rect = 19672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()); 19682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1970f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Ignore occlusion from outside the surface when surface contents need to 1971f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // be fully drawn. Layers with copy-request need to be complete. 1972f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // We could be smarter about layers with replica and exclude regions 1973f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // where both layer and the replica are occluded, but this seems like an 1974f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // overkill. The same is true for layers with filters that move pixels. 19752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(senorblanco): make this smarter for the SkImageFilter case (check 19762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // for pixel-moving filters) 1977f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->HasCopyRequest() || 1978f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->has_replica() || 1979f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->filters().HasReferenceFilter() || 1980f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->filters().HasFilterThatMovesPixels()) { 1981f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface = render_surface; 1982f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 1983f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) render_surface->SetNearestOcclusionImmuneAncestor( 1984f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface); 19852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1986424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = false; 1987424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool subtree_is_clipped_by_surface_bounds = false; 1988424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree) { 1989424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // It may be the layer or the surface doing the clipping of the subtree, 1990424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // but in either case, we'll be clipping to the projected clip rect of our 1991424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // ancestor. 19922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_surface_draw_transform( 19932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 19942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!render_surface->draw_transform().GetInverse( 19952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_surface_draw_transform)) { 19962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 19972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 19982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 1999424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 20005d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) gfx::Rect projected_surface_rect = MathUtil::ProjectEnclosingClippedRect( 20015d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) inverse_surface_draw_transform, ancestor_clip_rect_in_target_space); 2002424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2003424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer_draw_properties.num_unclipped_descendants > 0) { 2004424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we have unclipped descendants, we cannot count on the render 2005424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surface's bounds clipping our subtree: the unclipped descendants 2006424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // could cause us to expand our bounds. In this case, we must rely on 2007424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // layer clipping for correctess. NB: since we can only encounter 2008424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // translations between a clip child and its clip parent, clipping is 2009424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // guaranteed to be exact in this case. 2010424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = true; 2011424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect_in_target_space = projected_surface_rect; 2012424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } else { 2013424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The new render_surface here will correctly clip the entire subtree. 2014424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // So, we do not need to continue propagating the clipping state further 2015424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // down the tree. This way, we can avoid transforming clip rects from 2016424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // ancestor target surface space to current target surface space that 2017424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // could cause more w < 0 headaches. The render surface clip rect is 2018424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // expressed in the space where this surface draws, i.e. the same space 2019424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // as clip_rect_from_ancestor_in_ancestor_target_space. 2020424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) render_surface->SetClipRect(ancestor_clip_rect_in_target_space); 2021424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect_of_target_surface_in_target_space = projected_surface_rect; 2022424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) subtree_is_clipped_by_surface_bounds = true; 2023424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2024424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2025424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2026424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(layer->render_surface()); 2027424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(!layer->parent() || layer->parent()->render_target() == 2028424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->back().render_target); 2029424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2030424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->push_back( 2031424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceState<LayerType>(layer)); 2032424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2033424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) render_surface->SetIsClipped(subtree_is_clipped_by_surface_bounds); 2034424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!subtree_is_clipped_by_surface_bounds) { 20352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetClipRect(gfx::Rect()); 2036a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space = 20372385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.clip_rect_of_target_surface_in_target_space; 20382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the new render surface is drawn translucent or with a non-integral 20412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // translation then the subtree that gets drawn on this render surface 20422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // cannot use LCD text. 20432385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.subtree_can_use_lcd_text = layer_can_use_lcd_text; 20442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->push_back(layer); 20462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 20472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->parent()); 20482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note: layer_draw_properties.target_space_transform is computed above, 20502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // before this if-else statement. 20512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform_is_animating = 20522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target; 20532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform_is_animating = 20542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen; 20552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity = accumulated_draw_opacity; 20562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity_is_animating = animating_opacity_to_target; 20572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_opacity_is_animating = 20582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen; 20592385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix = combined_transform; 20602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->ClearRenderSurface(); 20622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers without render_surfaces directly inherit the ancestor's clip 20642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // status. 2065424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = ancestor_clips_subtree; 2066424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree) { 2067a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = 2068424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space; 2069a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch } 20702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The surface's cached clip rect value propagates regardless of what 20722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clipping goes on between layers here. 2073a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space = 20742385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.clip_rect_of_target_surface_in_target_space; 20752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers that are not their own render_target will render into the target 20772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // of their nearest ancestor. 20782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.render_target = layer->parent()->render_target(); 20792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (adjust_text_aa) 20822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text; 20832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2084f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) gfx::Rect rect_in_target_space = 2085f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) MathUtil::MapEnclosingClippedRect(layer->draw_transform(), content_rect); 20862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerClipsSubtree(layer)) { 2088a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer_or_ancestor_clips_descendants = true; 2089424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree && !layer->render_surface()) { 2090a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // A layer without render surface shares the same target as its ancestor. 2091a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = 2092424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space; 2093a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space.Intersect(rect_in_target_space); 20942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 2095a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = rect_in_target_space; 20962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2099424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Tell the layer the rect that it's clipped by. In theory we could use a 2100424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // tighter clip rect here (drawable_content_rect), but that actually does not 2101424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // reduce how much would be drawn, and instead it would create unnecessary 2102424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // changes to scissor state affecting GPU performance. Our clip information 2103424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // is used in the recursion below, so we must set it beforehand. 2104424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants; 2105424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer_or_ancestor_clips_descendants) { 2106424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.clip_rect = clip_rect_in_target_space; 2107424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } else { 2108424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Initialize the clip rect to a safe value that will not clip the 2109424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // layer, just in case clipping is still accidentally used. 2110424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.clip_rect = rect_in_target_space; 2111424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2112424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 21135c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu typename LayerType::LayerListType& descendants = 21142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer->render_surface() ? layer->render_surface()->layer_list() 21152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) : *layer_list); 21162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Any layers that are appended after this point are in the layer's subtree 21182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and should be included in the sorting process. 21192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) size_t sorting_start_index = descendants.size(); 21202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21210de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) if (!LayerShouldBeSkipped(layer, layer_is_drawn)) { 21220de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer, 21230de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 21242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) descendants.push_back(layer); 21250de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 21262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Any layers that are appended after this point may need to be sorted if we 21288bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visit the children out of order. 21298bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t render_surface_layer_list_child_sorting_start_index = 21308bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size(); 21318bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t layer_list_child_sorting_start_index = descendants.size(); 21328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21333551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (!layer->children().empty()) { 21343551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (layer == globals.page_scale_application_layer) { 21353551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.parent_matrix.Scale( 21363551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) globals.page_scale_factor, 21373551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) globals.page_scale_factor); 21383551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.in_subtree_of_page_scale_application_layer = true; 21393551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) } 21403551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 21413551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Flatten to 2D if the layer doesn't preserve 3D. 21425d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->should_flatten_transform()) 21433551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.parent_matrix.FlattenTo2d(); 21443551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 21453551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.scroll_compensation_matrix = 21463551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) ComputeScrollCompensationMatrixForChildren( 21473551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer, 21483551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_from_ancestor.parent_matrix, 21491e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) data_from_ancestor.scroll_compensation_matrix, 21501e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) effective_scroll_delta); 21513551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.fixed_container = 21523551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer->IsContainerForFixedPositionLayers() ? 21533551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer : data_from_ancestor.fixed_container; 21543551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 21553551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.clip_rect_in_target_space = clip_rect_in_target_space; 21563551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.clip_rect_of_target_surface_in_target_space = 21573551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) clip_rect_of_target_surface_in_target_space; 21583551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.ancestor_clips_subtree = 21593551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer_or_ancestor_clips_descendants; 2160f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) data_for_children.nearest_occlusion_immune_ancestor_surface = 2161f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface; 21625d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) data_for_children.subtree_is_visible_from_ancestor = layer_is_drawn; 21633551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) } 21642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21658bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) std::vector<LayerType*> sorted_children; 21668bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) bool child_order_changed = false; 21678bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (layer_draw_properties.has_child_with_a_scroll_parent) 21688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child_order_changed = SortChildrenForRecursion(&sorted_children, *layer); 21698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (size_t i = 0; i < layer->children().size(); ++i) { 21718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // If one of layer's children has a scroll parent, then we may have to 21728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visit the children out of order. The new order is stored in 21738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // sorted_children. Otherwise, we'll grab the child directly from the 21748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // layer's list of children. 21752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* child = 21768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer_draw_properties.has_child_with_a_scroll_parent 21778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) ? sorted_children[i] 21785c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu : LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i); 21798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_descendants_addition = 21818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) descendants.size(); 21828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_render_surface_layer_list_addition = 21838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size(); 21848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21850de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) CalculateDrawPropertiesInternal<LayerType>( 21860de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) child, 21870de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) globals, 21880de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) data_for_children, 21890de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) render_surface_layer_list, 21900de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &descendants, 21910de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) accumulated_surface_state, 21920de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 2193424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (child->render_surface() && 21945c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu !child->render_surface()->layer_list().empty() && 2195424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) !child->render_surface()->content_rect().IsEmpty()) { 21960de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) // This child will contribute its render surface, which means 21970de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) // we need to mark just the mask layer (and replica mask layer) 21980de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) // with the id. 21990de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkMasksWithRenderSurfaceLayerListId( 22000de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) child, current_render_surface_layer_list_id); 2201424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) descendants.push_back(child); 22022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 22048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().num_descendants_added = 22058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) descendants.size() - 22068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_descendants_addition; 22078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().num_render_surfaces_added = 22088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size() - 22098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties() 22108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) .index_of_first_render_surface_layer_list_addition; 22118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 22128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 22138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Add the unsorted layer list contributions, if necessary. 22148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child_order_changed) { 22158bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) SortLayerListContributions( 22168bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer, 22175c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu GetLayerListForSorting(render_surface_layer_list), 22188bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list_child_sorting_start_index, 22198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &GetNewRenderSurfacesStartIndexAndCount<LayerType>); 22208bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 22218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) SortLayerListContributions( 22228bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer, 22238bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &descendants, 22248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer_list_child_sorting_start_index, 22258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &GetNewDescendantsStartIndexAndCount<LayerType>); 22262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2228424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Compute the total drawable_content_rect for this subtree (the rect is in 2229424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // target surface space). 2230424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect local_drawable_content_rect_of_subtree = 2231424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->back().drawable_content_rect; 2232424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) { 2233424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(accumulated_surface_state->back().render_target == layer); 2234424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->pop_back(); 2235424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2236424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 22372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->render_surface() && !IsRootLayer(layer) && 22382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->layer_list().empty()) { 22392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RemoveSurfaceForEarlyExit(layer, render_surface_layer_list); 22402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 22412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the layer's drawable content rect (the rect is in target surface 22442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space). 22452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.drawable_content_rect = rect_in_target_space; 2246a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch if (layer_or_ancestor_clips_descendants) { 2247f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer_draw_properties.drawable_content_rect.Intersect( 2248f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) clip_rect_in_target_space); 2249f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 2250f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->DrawsContent()) { 2251f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) local_drawable_content_rect_of_subtree.Union( 2252f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer_draw_properties.drawable_content_rect); 22532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2255a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // Compute the layer's visible content rect (the rect is in content space). 22562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.visible_content_rect = CalculateVisibleContentRect( 2257a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space); 22582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the remaining properties for the render surface, if the layer has 22602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // one. 22612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (IsRootLayer(layer)) { 22622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer's surface's content_rect is always the entire viewport. 22632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->render_surface()); 2264a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer->render_surface()->SetContentRect( 2265424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space); 22668bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } else if (layer->render_surface()) { 22678bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* render_surface = 22688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->render_surface(); 22692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree; 22702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Don't clip if the layer is reflected as the reflection shouldn't be 22722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clipped. If the layer is animating, then the surface's transform to 22732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // its target is not known on the main thread, and we should not use it 22742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to clip. 22752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->replica_layer() && TransformToParentIsKnown(layer)) { 22762385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // Note, it is correct to use data_from_ancestor.ancestor_clips_subtree 22772385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // here, because we are looking at this layer's render_surface, not the 22782385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // layer itself. 2279424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (render_surface->is_clipped() && !clipped_content_rect.IsEmpty()) { 22802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect surface_clip_rect = LayerTreeHostCommon::CalculateVisibleRect( 22812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->clip_rect(), 22822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect, 22832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->draw_transform()); 22842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.Intersect(surface_clip_rect); 22852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The RenderSurfaceImpl backing texture cannot exceed the maximum supported 22892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // texture size. 22902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.set_width( 22912385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch std::min(clipped_content_rect.width(), globals.max_texture_size)); 22922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.set_height( 22932385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch std::min(clipped_content_rect.height(), globals.max_texture_size)); 22942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (clipped_content_rect.IsEmpty()) { 22962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RemoveSurfaceForEarlyExit(layer, render_surface_layer_list); 22972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 22982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2300f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Layers having a non-default blend mode will blend with the content 2301f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // inside its parent's render target. This render target should be 2302f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // either root_for_isolated_group, or the root of the layer tree. 2303f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Otherwise, this layer will use an incomplete backdrop, limited to its 2304f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // render target and the blending result will be incorrect. 2305f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) DCHECK(layer->uses_default_blend_mode() || IsRootLayer(layer) || 2306f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) !layer->parent()->render_target() || 2307f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) IsRootLayer(layer->parent()->render_target()) || 2308f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->parent()->render_target()->is_root_for_isolated_group()); 2309f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 23102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetContentRect(clipped_content_rect); 23112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The owning layer's screen_space_transform has a scale from content to 23132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer space which we need to undo and replace with a scale from the 23142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surface's subtree into layer space. 23152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform screen_space_transform = layer->screen_space_transform(); 23162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) screen_space_transform.Scale( 23172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->contents_scale_x() / render_surface_sublayer_scale.x(), 23182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->contents_scale_y() / render_surface_sublayer_scale.y()); 23192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetScreenSpaceTransform(screen_space_transform); 23202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->replica_layer()) { 23222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform surface_origin_to_replica_origin_transform; 23232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Scale( 23242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_sublayer_scale.x(), render_surface_sublayer_scale.y()); 23252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Translate( 23262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->position().x() + 232746d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) layer->replica_layer()->transform_origin().x(), 23282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->position().y() + 232946d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) layer->replica_layer()->transform_origin().y()); 23302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.PreconcatTransform( 23312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->transform()); 23322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Translate( 233346d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) -layer->replica_layer()->transform_origin().x(), 233446d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) -layer->replica_layer()->transform_origin().y()); 23352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Scale( 23362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.0 / render_surface_sublayer_scale.x(), 23372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.0 / render_surface_sublayer_scale.y()); 23382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the replica's "originTransform" that maps from the replica's 23402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // origin space to the target surface origin space. 23412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform replica_origin_transform = 23422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->draw_transform() * 23432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform; 23442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetReplicaDrawTransform(replica_origin_transform); 23452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the replica's "screen_space_transform" that maps from the 23472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // replica's origin space to the screen's origin space. 23482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform replica_screen_space_transform = 23492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->screen_space_transform() * 23502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform; 23512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetReplicaScreenSpaceTransform( 23522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_screen_space_transform); 23532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2356eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SavePaintPropertiesLayer(layer); 23572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If neither this layer nor any of its children were added, early out. 235958537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) if (sorting_start_index == descendants.size()) { 236058537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) DCHECK(!layer->render_surface() || IsRootLayer(layer)); 23612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 236258537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) } 23632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If preserves-3d then sort all the descendants in 3D so that they can be 23652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // drawn from back to front. If the preserves-3d property is also set on the 23662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // parent then skip the sorting as the parent will sort all the descendants 23672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // anyway. 23686d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() && 23695d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) !LayerIsInExisting3DRenderingContext(layer)) { 23702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) SortLayers(descendants.begin() + sorting_start_index, 23712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) descendants.end(), 23722385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.layer_sorter); 23732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) UpdateAccumulatedSurfaceState<LayerType>( 2376424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer, local_drawable_content_rect_of_subtree, accumulated_surface_state); 23772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->HasContributingDelegatedRenderPasses()) { 23792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_target()->render_surface()-> 23802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) AddContributingDelegatedRenderPassLayer(layer); 23812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 23832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2384c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochtemplate <typename LayerType, typename RenderSurfaceLayerListType> 2385c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic void ProcessCalcDrawPropsInputs( 2386c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const LayerTreeHostCommon::CalcDrawPropsInputs<LayerType, 2387c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch RenderSurfaceLayerListType>& 2388c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs, 2389c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch SubtreeGlobals<LayerType>* globals, 2390c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DataForRecursion<LayerType>* data_for_recursion) { 2391c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(inputs.root_layer); 2392c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(IsRootLayer(inputs.root_layer)); 2393c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(inputs.render_surface_layer_list); 2394c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 23952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform identity_matrix; 23962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer's render_surface should receive the device viewport as the 23982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // initial clip rect. 2399c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Rect device_viewport_rect(inputs.device_viewport_size); 2400c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2401c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF device_transform_scale_components = 2402c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(inputs.device_transform, 1.f); 2403c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // Not handling the rare case of different x and y device scale. 2404c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float device_transform_scale = 2405c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(device_transform_scale_components.x(), 2406c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch device_transform_scale_components.y()); 2407c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2408c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Transform scaled_device_transform = inputs.device_transform; 2409c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch scaled_device_transform.Scale(inputs.device_scale_factor, 2410c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.device_scale_factor); 2411c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2412c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->layer_sorter = NULL; 2413c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->max_texture_size = inputs.max_texture_size; 2414c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->device_scale_factor = 2415c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.device_scale_factor * device_transform_scale; 2416c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->page_scale_factor = inputs.page_scale_factor; 2417c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->page_scale_application_layer = inputs.page_scale_application_layer; 2418c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->can_render_to_separate_surface = 2419c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.can_render_to_separate_surface; 2420c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->can_adjust_raster_scales = inputs.can_adjust_raster_scales; 2421c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2422c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->parent_matrix = scaled_device_transform; 2423c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->full_hierarchy_matrix = identity_matrix; 2424c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->scroll_compensation_matrix = identity_matrix; 2425c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->fixed_container = inputs.root_layer; 2426c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->clip_rect_in_target_space = device_viewport_rect; 2427c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->clip_rect_of_target_surface_in_target_space = 2428c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch device_viewport_rect; 2429c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->maximum_animation_contents_scale = 0.f; 2430c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->ancestor_is_animating_scale = false; 2431c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->ancestor_clips_subtree = true; 2432c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL; 2433c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->in_subtree_of_page_scale_application_layer = false; 2434c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text; 2435c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->subtree_is_visible_from_ancestor = true; 2436c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 24372385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 2438c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochvoid LayerTreeHostCommon::CalculateDrawProperties( 2439c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch CalcDrawPropsMainInputs* inputs) { 24405c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerList dummy_layer_list; 24412385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch SubtreeGlobals<Layer> globals; 24428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<Layer> data_for_recursion; 2443c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); 24442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24457dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData recursive_data; 2446558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch PreCalculateMetaInformation(inputs->root_layer, &recursive_data); 2447424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state; 24480de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) CalculateDrawPropertiesInternal<Layer>( 24490de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->root_layer, 24500de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) globals, 24510de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) data_for_recursion, 24520de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->render_surface_layer_list, 24530de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &dummy_layer_list, 24540de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &accumulated_surface_state, 24550de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->current_render_surface_layer_list_id); 24562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The dummy layer list should not have been used. 2458c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DCHECK_EQ(0u, dummy_layer_list.size()); 24592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A root layer render_surface should always exist after 24602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // CalculateDrawProperties. 2461558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DCHECK(inputs->root_layer->render_surface()); 24622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 24632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void LayerTreeHostCommon::CalculateDrawProperties( 2465558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch CalcDrawPropsImplInputs* inputs) { 2466c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImplList dummy_layer_list; 24672385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch SubtreeGlobals<LayerImpl> globals; 24688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<LayerImpl> data_for_recursion; 2469c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); 2470c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2471c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerSorter layer_sorter; 2472c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals.layer_sorter = &layer_sorter; 24732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24747dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData recursive_data; 2475558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch PreCalculateMetaInformation(inputs->root_layer, &recursive_data); 2476424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerImpl> > 2477424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state; 24780de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) CalculateDrawPropertiesInternal<LayerImpl>( 24790de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->root_layer, 24800de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) globals, 24810de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) data_for_recursion, 24820de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->render_surface_layer_list, 24830de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &dummy_layer_list, 24840de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &accumulated_surface_state, 24850de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->current_render_surface_layer_list_id); 24862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The dummy layer list should not have been used. 2488c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DCHECK_EQ(0u, dummy_layer_list.size()); 24892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A root layer render_surface should always exist after 24902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // CalculateDrawProperties. 2491558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DCHECK(inputs->root_layer->render_surface()); 24922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 24932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} // namespace cc 2495