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) 241675a649fd7a8b3cb80ffddae2dc181f122353c5Ben MurdochScrollAndScaleSet::ScrollAndScaleSet() 251675a649fd7a8b3cb80ffddae2dc181f122353c5Ben Murdoch : page_scale_delta(1.f), top_controls_delta(0.f) { 261675a649fd7a8b3cb80ffddae2dc181f122353c5Ben Murdoch} 272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ScrollAndScaleSet::~ScrollAndScaleSet() {} 292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 30c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static void SortLayers(LayerList::iterator forst, 31c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerList::iterator end, 322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void* layer_sorter) { 332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) NOTREACHED(); 342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 36c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static void SortLayers(LayerImplList::iterator first, 37c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImplList::iterator end, 382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerSorter* layer_sorter) { 392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer_sorter); 402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers"); 412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_sorter->Sort(first, end); 422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 44424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 45424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) { 46424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF scroll_delta = layer->ScrollDelta(); 47424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The scroll parent's scroll delta is the amount we've scrolled on the 48424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // compositor thread since the commit for this layer tree's source frame. 49424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // we last reported to the main thread. I.e., it's the discrepancy between 50424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // a scroll parent's scroll delta and offset, so we must add it here. 51424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->scroll_parent()) 52424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta += layer->scroll_parent()->ScrollDelta(); 53424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return scroll_delta; 54424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 55424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 56424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 57424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF GetEffectiveTotalScrollOffset(LayerType* layer) { 58424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF offset = layer->TotalScrollOffset(); 59424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The scroll parent's total scroll offset (scroll offset + scroll delta) 60424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // can't be used because its scroll offset has already been applied to the 61424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // scroll children's positions by the main thread layer positioning code. 62424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->scroll_parent()) 63424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) offset += layer->scroll_parent()->ScrollDelta(); 64424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return offset; 65424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 66424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)inline gfx::Rect CalculateVisibleRectWithCachedLayerRect( 685d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& target_surface_rect, 695d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_bound_rect, 705d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_rect_in_target_space, 712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& transform) { 72868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (layer_rect_in_target_space.IsEmpty()) 73868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return gfx::Rect(); 74868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Is this layer fully contained within the target surface? 762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (target_surface_rect.Contains(layer_rect_in_target_space)) 772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_bound_rect; 782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer doesn't fill up the entire surface, then find the part of 802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the surface rect where the layer could be visible. This avoids trying to 812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // project surface rect points that are behind the projection point. 822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect minimal_surface_rect = target_surface_rect; 832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) minimal_surface_rect.Intersect(layer_rect_in_target_space); 842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 853551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (minimal_surface_rect.IsEmpty()) 86f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) return gfx::Rect(); 873551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Project the corners of the target surface rect into the layer space. 892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This bounding rectangle may be larger than it needs to be (being 902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // axis-aligned), but is a reasonable filter on the space to consider. 912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Non-invertible transforms will create an empty rect here. 922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform surface_to_layer(gfx::Transform::kSkipInitialization); 942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!transform.GetInverse(&surface_to_layer)) { 953551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Because we cannot use the surface bounds to determine what portion of 963551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // the layer is visible, we must conservatively assume the full layer is 973551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // visible. 983551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) return layer_bound_rect; 992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 100c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1015d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) gfx::Rect layer_rect = MathUtil::ProjectEnclosingClippedRect( 1025d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) surface_to_layer, minimal_surface_rect); 1032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_rect.Intersect(layer_bound_rect); 1042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_rect; 1052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Rect LayerTreeHostCommon::CalculateVisibleRect( 1085d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& target_surface_rect, 1095d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_bound_rect, 1102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& transform) { 1112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect layer_in_surface_space = 1125d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) MathUtil::MapEnclosingClippedRect(transform, layer_bound_rect); 1132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return CalculateVisibleRectWithCachedLayerRect( 1142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) target_surface_rect, layer_bound_rect, layer_in_surface_space, transform); 1152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 117424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 118424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static LayerType* NextTargetSurface(LayerType* layer) { 119424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return layer->parent() ? layer->parent()->render_target() : 0; 120424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 121424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 122424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Given two layers, this function finds their respective render targets and, 123424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// computes a change of basis translation. It does this by accumulating the 124424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// translation components of the draw transforms of each target between the 125424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// ancestor and descendant. These transforms must be 2D translations, and this 126424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// requirement is enforced at every step. 1278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 128424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF ComputeChangeOfBasisTranslation( 129424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& ancestor_layer, 130424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& descendant_layer) { 131424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(descendant_layer.HasAncestor(&ancestor_layer)); 132424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* descendant_target = descendant_layer.render_target(); 133424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(descendant_target); 134424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* ancestor_target = ancestor_layer.render_target(); 135424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(ancestor_target); 136424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 137424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF translation; 138424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) for (const LayerType* target = descendant_target; target != ancestor_target; 1391e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) target = NextTargetSurface(target)) { 1401e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& trans = target->render_surface()->draw_transform(); 1411e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // Ensure that this translation is truly 2d. 1421e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) DCHECK(trans.IsIdentityOrTranslation()); 1431e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) DCHECK_EQ(0.f, trans.matrix().get(2, 3)); 1441e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) translation += trans.To2dTranslation(); 1451e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) } 146424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 147424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return translation; 148424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 149424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 150424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)enum TranslateRectDirection { 151424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToAncestor, 152424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToDescendant 153424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)}; 154424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 156424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Rect TranslateRectToTargetSpace(const LayerType& ancestor_layer, 157424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& descendant_layer, 1585d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& rect, 159424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirection direction) { 1608bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) gfx::Vector2dF translation = ComputeChangeOfBasisTranslation<LayerType>( 1618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) ancestor_layer, descendant_layer); 162424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (direction == TranslateRectDirectionToDescendant) 163424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) translation.Scale(-1.f); 164424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return gfx::ToEnclosingRect( 165424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::RectF(rect.origin() + translation, rect.size())); 166424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 167424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 168424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Attempts to update the clip rects for the given layer. If the layer has a 169424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// clip_parent, it may not inherit its immediate ancestor's clip. 1708bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 171424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static void UpdateClipRectsForClipChild( 172424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* layer, 173424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect* clip_rect_in_parent_target_space, 174424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool* subtree_should_be_clipped) { 175424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer has no clip_parent, or the ancestor is the same as its actual 176424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parent, then we don't need special clip rects. Bail now and leave the out 177424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parameters untouched. 1788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType* clip_parent = layer->scroll_parent(); 1798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 1808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (!clip_parent) 1818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) clip_parent = layer->clip_parent(); 1828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 183424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!clip_parent || clip_parent == layer->parent()) 184424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return; 185424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 186424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The root layer is never a clip child. 187424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(layer->parent()); 188424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 189424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Grab the cached values. 190424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *clip_rect_in_parent_target_space = clip_parent->clip_rect(); 191424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *subtree_should_be_clipped = clip_parent->is_clipped(); 192424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 193424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We may have to project the clip rect into our parent's target space. Note, 194424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // it must be our parent's target space, not ours. For one, we haven't 195424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // computed our transforms, so we couldn't put it in our space yet even if we 196424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // wanted to. But more importantly, this matches the expectations of 197424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // CalculateDrawPropertiesInternal. If we, say, create a render surface, these 198424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // clip rects will want to be in its target space, not ours. 1998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (clip_parent == layer->clip_parent()) { 2008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>( 2018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_parent, 2028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer->parent(), 2038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space, 2048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectDirectionToDescendant); 2058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } else { 2068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // If we're being clipped by our scroll parent, we must translate through 2078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // our common ancestor. This happens to be our parent, so it is sufficent to 2088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // translate from our clip parent's space to the space of its ancestor (our 2098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // parent). 2108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space = 2118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectToTargetSpace<LayerType>(*layer->parent(), 2128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_parent, 2138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space, 2148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectDirectionToAncestor); 2158bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 216424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 217424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 218424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// We collect an accumulated drawable content rect per render surface. 219424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Typically, a layer will contribute to only one surface, the surface 220424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// associated with its render target. Clip children, however, may affect 221424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// several surfaces since there may be several surfaces between the clip child 222424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// and its parent. 223424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// 224424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// NB: we accumulate the layer's *clipped* drawable content rect. 225424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 226424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)struct AccumulatedSurfaceState { 227424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) explicit AccumulatedSurfaceState(LayerType* render_target) 228424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : render_target(render_target) {} 229424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 230424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The accumulated drawable content rect for the surface associated with the 231424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // given |render_target|. 232424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect drawable_content_rect; 233424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 234424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The target owning the surface. (We hang onto the target rather than the 235424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surface so that we can DCHECK that the surface's draw transform is simply 236424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // a translation when |render_target| reports that it has no unclipped 237424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // descendants). 238424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* render_target; 239424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)}; 240424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2418bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 242424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)void UpdateAccumulatedSurfaceState( 243424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* layer, 2445d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& drawable_content_rect, 245424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerType> >* 246424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state) { 247424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (IsRootLayer(layer)) 248424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return; 249424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 250424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We will apply our drawable content rect to the accumulated rects for all 251424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surfaces between us and |render_target| (inclusive). This is either our 252424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // clip parent's target if we are a clip child, or else simply our parent's 253424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // target. We use our parent's target because we're either the owner of a 254424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // render surface and we'll want to add our rect to our *surface's* target, or 255424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // we're not and our target is the same as our parent's. In both cases, the 256424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parent's target gives us what we want. 257424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* render_target = layer->clip_parent() 258424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ? layer->clip_parent()->render_target() 259424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : layer->parent()->render_target(); 260424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 261424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer owns a surface, then the content rect is in the wrong space. 262424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Instead, we will use the surface's DrawableContentRect which is in target 263424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // space as required. 264424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect target_rect = drawable_content_rect; 265424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) { 266424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect = 267424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::ToEnclosedRect(layer->render_surface()->DrawableContentRect()); 268424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 269424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 270424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (render_target->is_clipped()) { 271424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect clip_rect = render_target->clip_rect(); 272424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer has a clip parent, the clip rect may be in the wrong space, 273424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // so we'll need to transform it before it is applied. 274424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_parent()) { 2758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) clip_rect = TranslateRectToTargetSpace<LayerType>( 276424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *layer->clip_parent(), 277424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *layer, 278424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect, 279424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToDescendant); 280424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 281424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect.Intersect(clip_rect); 282424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 283424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 284424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We must have at least one entry in the vector for the root. 285424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK_LT(0ul, accumulated_surface_state->size()); 286424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 287424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) typedef typename std::vector<AccumulatedSurfaceState<LayerType> > 288424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateVector; 289424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) typedef typename AccumulatedSurfaceStateVector::reverse_iterator 290424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateIterator; 291424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateIterator current_state = 292424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->rbegin(); 293424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 294424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Add this rect to the accumulated content rect for all surfaces until we 295424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // reach the target surface. 296424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool found_render_target = false; 297424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) for (; current_state != accumulated_surface_state->rend(); ++current_state) { 298424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_state->drawable_content_rect.Union(target_rect); 299424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 300424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we've reached |render_target| our work is done and we can bail. 301424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (current_state->render_target == render_target) { 302424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) found_render_target = true; 303424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) break; 304424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 305424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 306424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Transform rect from the current target's space to the next. 307424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* current_target = current_state->render_target; 308424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(current_target->render_surface()); 309424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const gfx::Transform& current_draw_transform = 310424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_target->render_surface()->draw_transform(); 311424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 312424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we have unclipped descendants, the draw transform is a translation. 313424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(current_target->num_unclipped_descendants() == 0 || 314424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_draw_transform.IsIdentityOrTranslation()); 315424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 316424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect = gfx::ToEnclosingRect( 317424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) MathUtil::MapClippedRect(current_draw_transform, target_rect)); 318424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 319424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 320424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // It is an error to not reach |render_target|. If this happens, it means that 321424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // either the clip parent is not an ancestor of the clip child or the surface 322424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // state vector is empty, both of which should be impossible. 323424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(found_render_target); 324424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 325424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 3262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> static inline bool IsRootLayer(LayerType* layer) { 3272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->parent(); 3282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) { 3326d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) return layer->Is3dSorted() && layer->parent() && 3336d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) layer->parent()->Is3dSorted(); 3342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsRootLayerOfNewRenderingContext(LayerType* layer) { 3382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) 3396d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) return !layer->parent()->Is3dSorted() && layer->Is3dSorted(); 3402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3416d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) return layer->Is3dSorted(); 3422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsLayerBackFaceVisible(LayerType* layer) { 3462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The current W3C spec on CSS transforms says that backface visibility should 3472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // be determined differently depending on whether the layer is in a "3d 3482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // rendering context" or not. For Chromium code, we can determine whether we 3492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // are in a 3d rendering context by checking if the parent preserves 3d. 3502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer)) 3522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->draw_transform().IsBackFaceVisible(); 3532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // In this case, either the layer establishes a new 3d rendering context, or 3552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // is not in a 3d rendering context at all. 3562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->transform().IsBackFaceVisible(); 3572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsSurfaceBackFaceVisible(LayerType* layer, 3612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& draw_transform) { 3622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer)) 3632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return draw_transform.IsBackFaceVisible(); 3642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (IsRootLayerOfNewRenderingContext(layer)) 3662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->transform().IsBackFaceVisible(); 3672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the render_surface is not part of a new or existing rendering context, 3692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // then the layers that contribute to this surface will decide back-face 3702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // visibility for themselves. 3712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 3722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool LayerClipsSubtree(LayerType* layer) { 3762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->masks_to_bounds() || layer->mask_layer(); 3772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static gfx::Rect CalculateVisibleContentRect( 3812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 3825d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& clip_rect_of_target_surface_in_target_space, 3835d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_rect_in_target_space) { 3842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->render_target()); 3852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Nothing is visible if the layer bounds are empty. 3872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() || 3882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->drawable_content_rect().IsEmpty()) 3892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Rect(); 3902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute visible bounds in target surface space. 3922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect visible_rect_in_target_surface_space = 3932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->drawable_content_rect(); 3942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 395c85651751be2767cc35d98d6dc516a5d99c3038fHui Shu if (layer->render_target()->render_surface()->is_clipped()) { 396a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // The |layer| L has a target T which owns a surface Ts. The surface Ts 397a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // has a target TsT. 398a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // 399a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // In this case the target surface Ts does clip the layer L that contributes 400a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // to it. So, we have to convert the clip rect of Ts from the target space 401a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // of Ts (that is the space of TsT), to the current render target's space 402a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // (that is the space of T). This conversion is done outside this function 403a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // so that it can be cached instead of computing it redundantly for every 404a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // layer. 4052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) visible_rect_in_target_surface_space.Intersect( 406a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space); 4072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (visible_rect_in_target_surface_space.IsEmpty()) 4102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Rect(); 4112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return CalculateVisibleRectWithCachedLayerRect( 4132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) visible_rect_in_target_surface_space, 4142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()), 4152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_rect_in_target_space, 4162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_transform()); 4172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToParentIsKnown(LayerImpl* layer) { return true; } 4202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToParentIsKnown(Layer* layer) { 4222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->TransformIsAnimating(); 4232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToScreenIsKnown(LayerImpl* layer) { return true; } 4262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToScreenIsKnown(Layer* layer) { 4282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->screen_space_transform_is_animating(); 4292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 4325d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static bool LayerShouldBeSkipped(LayerType* layer, bool layer_is_drawn) { 4332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers can be skipped if any of these conditions are met. 4345d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // - is not drawn due to it or one of its ancestors being hidden (or having 4355d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // no copy requests). 436cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // - does not draw content. 437cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // - is transparent. 4382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - has empty bounds 4392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the layer is not double-sided, but its back face is visible. 4402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some additional conditions need to be computed at a later point after the 4422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // recursion is finished. 4432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the intersection of render_surface content and layer clip_rect is empty 4442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the visible_content_rect is empty 4452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note, if the layer should not have been drawn due to being fully 4472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transparent, we would have skipped the entire subtree and never made it 4482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // into this function, so it is safe to omit this check here. 4492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4505d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 4517dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return true; 4527dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 453cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) if (!layer->DrawsContent() || layer->bounds().IsEmpty()) 4542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 4552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* backface_test_layer = layer; 4572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->use_parent_backface_visibility()) { 4582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->parent()); 4592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(!layer->parent()->use_parent_backface_visibility()); 4602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) backface_test_layer = layer->parent(); 4612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The layer should not be drawn if (1) it is not double-sided and (2) the 4642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // back of the layer is known to be facing the screen. 4652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!backface_test_layer->double_sided() && 4662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TransformToScreenIsKnown(backface_test_layer) && 4672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) IsLayerBackFaceVisible(backface_test_layer)) 4682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 4692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 4712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4735c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liutemplate <typename LayerType> 4745c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic bool HasInvertibleOrAnimatedTransform(LayerType* layer) { 4755c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu return layer->transform_is_invertible() || layer->TransformIsAnimating(); 4765c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu} 4775c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu 4787dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstatic inline bool SubtreeShouldBeSkipped(LayerImpl* layer, 4795d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) bool layer_is_drawn) { 4800529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // If the layer transform is not invertible, it should not be drawn. 4810529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // TODO(ajuma): Correctly process subtrees with singular transform for the 4820529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // case where we may animate to a non-singular transform and wish to 4830529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // pre-raster. 4845c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu if (!HasInvertibleOrAnimatedTransform(layer)) 4850529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 4860529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 4877dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // When we need to do a readback/copy of a layer's output, we can not skip 4887dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // it or any of its ancestors. 4897dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->draw_properties().layer_or_descendant_has_copy_request) 4907dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return false; 4917dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 492f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // We cannot skip the the subtree if a descendant has a wheel or touch handler 493f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // or the hit testing code will break (it requires fresh transforms, etc). 494f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (layer->draw_properties().layer_or_descendant_has_input_handler) 495f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) return false; 496f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 4975d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer is not drawn, then skip it and its subtree. 4985d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 499eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return true; 500eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 501c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // If layer is on the pending tree and opacity is being animated then 502c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // this subtree can't be skipped as we need to create, prioritize and 503c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // include tiles for this layer when deciding if tree can be activated. 504c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating()) 505c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 506c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The opacity of a layer always applies to its children (either implicitly 5082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // via a render surface or explicitly if the parent preserves 3D), so the 5092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // entire subtree can be skipped if this layer is fully transparent. 5102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->opacity(); 5112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 5122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5135d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static inline bool SubtreeShouldBeSkipped(Layer* layer, bool layer_is_drawn) { 5140529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // If the layer transform is not invertible, it should not be drawn. 5150529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!layer->transform_is_invertible() && !layer->TransformIsAnimating()) 5160529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 5170529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 5187dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // When we need to do a readback/copy of a layer's output, we can not skip 5197dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // it or any of its ancestors. 5207dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->draw_properties().layer_or_descendant_has_copy_request) 5217dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return false; 5227dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 523f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // We cannot skip the the subtree if a descendant has a wheel or touch handler 524f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // or the hit testing code will break (it requires fresh transforms, etc). 525f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (layer->draw_properties().layer_or_descendant_has_input_handler) 526f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) return false; 527f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 5285d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer is not drawn, then skip it and its subtree. 5295d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 530eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return true; 531eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 5322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the opacity is being animated then the opacity on the main thread is 5332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // unreliable (since the impl thread may be using a different opacity), so it 5342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // should not be trusted. 5352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // In particular, it should not cause the subtree to be skipped. 5362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Similarly, for layers that might animate opacity using an impl-only 5372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // animation, their subtree should also not be skipped. 5382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->opacity() && !layer->OpacityIsAnimating() && 5392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !layer->OpacityCanAnimateOnImplThread(); 5402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 5412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 542c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static inline void SavePaintPropertiesLayer(LayerImpl* layer) {} 543c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 544c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static inline void SavePaintPropertiesLayer(Layer* layer) { 545c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->SavePaintProperties(); 546c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 547c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->mask_layer()) 548c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->mask_layer()->SavePaintProperties(); 549c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) 550c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->replica_layer()->mask_layer()->SavePaintProperties(); 551c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 552c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 5542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool SubtreeShouldRenderToSeparateSurface( 5552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 5562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool axis_aligned_with_respect_to_parent) { 5572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 5582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A layer and its descendants should render onto a new RenderSurfaceImpl if 5592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // any of these rules hold: 5602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 5612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 562b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // The root layer owns a render surface, but it never acts as a contributing 563b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // surface to another render target. Compositor features that are applied via 564b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // a contributing surface can not be applied to the root layer. In order to 565b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // use these effects, another child of the root would need to be introduced 566b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // in order to act as a contributing surface to the root layer's surface. 567b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool is_root = IsRootLayer(layer); 568c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer uses a mask. 570b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->mask_layer()) { 571b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 573b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer has a reflection. 576b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->replica_layer()) { 577b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 579b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer uses a CSS filter. 58268043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) { 583b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 585b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) int num_descendants_that_draw_content = 5886e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) layer->NumDescendantsThatDrawContent(); 5892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5905d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer flattens its subtree, but it is treated as a 3D object by its 5915d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // parent (i.e. parent participates in a 3D rendering context). 5925d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer) && 5935d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) layer->should_flatten_transform() && 5942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content > 0) { 5952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 5962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 597c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface flattening", 598c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 599b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 603f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // If the layer has blending. 604f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // TODO(rosca): this is temporary, until blending is implemented for other 605f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // types of quads than RenderPassDrawQuad. Layers having descendants that draw 606f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // content will still create a separate rendering surface. 607f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (!layer->uses_default_blend_mode()) { 608f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_INSTANT0( 609f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "cc", 610f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface blending", 611f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 612f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) DCHECK(!is_root); 613f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return true; 614f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 615f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 6162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer clips its descendants but it is not axis-aligned with respect 6172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to its parent. 6182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool layer_clips_external_content = 6192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerClipsSubtree(layer) || layer->HasDelegatedContent(); 6202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer_clips_external_content && !axis_aligned_with_respect_to_parent && 6214e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content > 0) { 6222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 6232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 624c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface clipping", 625c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 626b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 6302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer has some translucency and does not have a preserves-3d 6312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform style. This condition only needs a render surface if two or more 6322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers in the subtree overlap. But checking layer overlaps is unnecessarily 6332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // costly so instead we conservatively create a surface whenever at least two 6342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers draw content for this subtree. 6352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool at_least_two_layers_in_subtree_draw_content = 6362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content > 0 && 6372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer->DrawsContent() || num_descendants_that_draw_content > 1); 6382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 6395d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->opacity() != 1.f && layer->should_flatten_transform() && 6402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) at_least_two_layers_in_subtree_draw_content) { 6412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 6422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 643c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface opacity", 644c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 645b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 649b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // The root layer should always have a render_surface. 650b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (is_root) 651b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 652b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 653b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // 654b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // These are allowed on the root surface, as they don't require the surface to 655b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // be used as a contributing surface in order to apply correctly. 656b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // 657b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 658f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // If the layer has isolation. 659f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // TODO(rosca): to be optimized - create separate rendering surface only when 660f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // the blending descendants might have access to the content behind this layer 661f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // (layer has transparent background or descendants overflow). 662f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // https://code.google.com/p/chromium/issues/detail?id=301738 663f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->is_root_for_isolated_group()) { 664f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_INSTANT0( 665f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "cc", 666f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface isolation", 667f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 668f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return true; 669f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 670f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 671b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If we force it. 672b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->force_render_surface()) 673b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 674b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 675b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If we'll make a copy of the layer's contents. 67690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (layer->HasCopyRequest()) 677b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 678b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 6792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 6802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 6812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 682c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// This function returns a translation matrix that can be applied on a vector 683c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// that's in the layer's target surface coordinate, while the position offset is 684c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// specified in some ancestor layer's coordinate. 685c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)gfx::Transform ComputeSizeDeltaCompensation( 686c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* layer, 687c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* container, 6885d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& position_offset) { 689c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform result_transform; 690c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 691c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // To apply a translate in the container's layer space, 692c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the following steps need to be done: 693c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 1a. transform from target surface space to the container's target 694c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // surface space 695c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 1b. transform from container's target surface space to the 696c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // container's layer space 697c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 2. apply the compensation 698c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 3. transform back to target surface space 699c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 700c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform target_surface_space_to_container_layer_space; 701c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Calculate step 1a 702868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerImpl* container_target_surface = container->render_target(); 703c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (LayerImpl* current_target_surface = NextTargetSurface(layer); 704c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface && 705c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface != container_target_surface; 706c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface = NextTargetSurface(current_target_surface)) { 707c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note: Concat is used here to convert the result coordinate space from 708c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // current render surface to the next render surface. 709c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) target_surface_space_to_container_layer_space.ConcatTransform( 710c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface->render_surface()->draw_transform()); 711c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 712c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Calculate step 1b 713868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) gfx::Transform container_layer_space_to_container_target_surface_space = 714868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container->draw_transform(); 715868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container_layer_space_to_container_target_surface_space.Scale( 716868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container->contents_scale_x(), container->contents_scale_y()); 717868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 718868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) gfx::Transform container_target_surface_space_to_container_layer_space; 719868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (container_layer_space_to_container_target_surface_space.GetInverse( 720868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) &container_target_surface_space_to_container_layer_space)) { 721868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Note: Again, Concat is used to conver the result coordinate space from 722868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // the container render surface to the container layer. 723868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) target_surface_space_to_container_layer_space.ConcatTransform( 724868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container_target_surface_space_to_container_layer_space); 725c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 726c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 727c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 3 728c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform container_layer_space_to_target_surface_space; 729c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (target_surface_space_to_container_layer_space.GetInverse( 730c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) &container_layer_space_to_target_surface_space)) { 731c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.PreconcatTransform( 732c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) container_layer_space_to_target_surface_space); 733c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } else { 734eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // TODO(shawnsingh): A non-invertible matrix could still make meaningful 735eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // projection. For example ScaleZ(0) is non-invertible but the layer is 736eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // still visible. 737c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return gfx::Transform(); 738c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 739c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 740c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 2 741c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.Translate(position_offset.x(), position_offset.y()); 742c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 743c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 1 744c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.PreconcatTransform( 745c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) target_surface_space_to_container_layer_space); 746c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 747c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return result_transform; 748c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 749c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 750c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ApplyPositionAdjustment( 751c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) Layer* layer, 752c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) Layer* container, 753c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const gfx::Transform& scroll_compensation, 754c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform* combined_transform) {} 755c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ApplyPositionAdjustment( 756c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* layer, 757c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* container, 758c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const gfx::Transform& scroll_compensation, 759c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform* combined_transform) { 760c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (!layer->position_constraint().is_fixed_position()) 761c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return; 762c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 763c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Special case: this layer is a composited fixed-position layer; we need to 764c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // explicitly compensate for all ancestors' nonzero scroll_deltas to keep 765c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // this layer fixed correctly. 766c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note carefully: this is Concat, not Preconcat 767c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // (current_scroll_compensation * combined_transform). 768c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform->ConcatTransform(scroll_compensation); 769c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 770c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // For right-edge or bottom-edge anchored fixed position layers, 771c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the layer should relocate itself if the container changes its size. 772c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) bool fixed_to_right_edge = 773c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->position_constraint().is_fixed_to_right_edge(); 774c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) bool fixed_to_bottom_edge = 775c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->position_constraint().is_fixed_to_bottom_edge(); 776a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) gfx::Vector2dF position_offset = container->FixedContainerSizeDelta(); 777c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) position_offset.set_x(fixed_to_right_edge ? position_offset.x() : 0); 778c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) position_offset.set_y(fixed_to_bottom_edge ? position_offset.y() : 0); 779c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (position_offset.IsZero()) 780c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return; 781c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 782c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note: Again, this is Concat. The compensation matrix will be applied on 783c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the vector in target surface space. 784c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform->ConcatTransform( 785c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ComputeSizeDeltaCompensation(layer, container, position_offset)); 786c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 787c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 7882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationForThisLayer( 7892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* scrolling_layer, 7901e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& parent_matrix, 7915d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 7922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // For every layer that has non-zero scroll_delta, we have to compute a 7932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform that can undo the scroll_delta translation. In particular, we 7942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // want this matrix to premultiply a fixed-position layer's parent_matrix, so 7952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // we design this transform in three steps as follows. The steps described 7962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here apply from right-to-left, so Step 1 would be the right-most matrix: 7972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 7982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 1. transform from target surface space to the exact space where 7992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // scroll_delta is actually applied. 8009ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // -- this is inverse of parent_matrix 8012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 2. undo the scroll_delta 8022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // -- this is just a translation by scroll_delta. 8032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 3. transform back to target surface space. 8049ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // -- this transform is the parent_matrix 8052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // These steps create a matrix that both start and end in target surface 8072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. So this matrix can pre-multiply any fixed-position layer's 8082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw_transform to undo the scroll_deltas -- as long as that fixed position 8092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer is fixed onto the same render_target as this scrolling_layer. 8102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8129ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch gfx::Transform scroll_compensation_for_this_layer = parent_matrix; // Step 3 8132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer.Translate( 814424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.x(), 815424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.y()); // Step 2 8162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8179ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch gfx::Transform inverse_parent_matrix(gfx::Transform::kSkipInitialization); 8189ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch if (!parent_matrix.GetInverse(&inverse_parent_matrix)) { 8192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 8202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 8212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 8222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer.PreconcatTransform( 8239ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch inverse_parent_matrix); // Step 1 8242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return scroll_compensation_for_this_layer; 8252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationMatrixForChildren( 8282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Layer* current_layer, 8292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& current_parent_matrix, 8301e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& current_scroll_compensation, 8315d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 8322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The main thread (i.e. Layer) does not need to worry about scroll 8332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // compensation. So we can just return an identity matrix here. 8342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Transform(); 8352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationMatrixForChildren( 8382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer, 8392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& parent_matrix, 8401e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& current_scroll_compensation_matrix, 8415d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 8422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // "Total scroll compensation" is the transform needed to cancel out all 8432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // scroll_delta translations that occurred since the nearest container layer, 8442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // even if there are render_surfaces in-between. 8452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // There are some edge cases to be aware of, that are not explicit in the 8472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // code: 8482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that is both a fixed-position and container should not be its 8492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // own container, instead, that means it is fixed to an ancestor, and is a 8502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // container for any fixed-position descendants. 8512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that is a fixed-position container and has a render_surface 8522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // should behave the same as a container without a render_surface, the 8532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surface is irrelevant in that case. 8542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that does not have an explicit container is simply fixed to the 8552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // viewport. (i.e. the root render_surface.) 8562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - If the fixed-position layer has its own render_surface, then the 8572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surface is the one who gets fixed. 8582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This function needs to be called AFTER layers create their own 8602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surfaces. 8612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8634e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // Scroll compensation restarts from identity under two possible conditions: 8644e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - the current layer is a container for fixed-position descendants 8654e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - the current layer is fixed-position itself, so any fixed-position 8664e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // descendants are positioned with respect to this layer. Thus, any 8674e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // fixed position descendants only need to compensate for scrollDeltas 8684e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // that occur below this layer. 8694e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool current_layer_resets_scroll_compensation_for_descendants = 8704e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->IsContainerForFixedPositionLayers() || 8714e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->position_constraint().is_fixed_position(); 8724e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) 8732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Avoid the overheads (including stack allocation and matrix 8742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // initialization/copy) if we know that the scroll compensation doesn't need 8752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to be reset or adjusted. 8764e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!current_layer_resets_scroll_compensation_for_descendants && 877424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.IsZero() && !layer->render_surface()) 8782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return current_scroll_compensation_matrix; 8792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Start as identity matrix. 8812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform next_scroll_compensation_matrix; 8822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8834e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // If this layer does not reset scroll compensation, then it inherits the 8844e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // existing scroll compensations. 8854e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!current_layer_resets_scroll_compensation_for_descendants) 8862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix = current_scroll_compensation_matrix; 8872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the current layer has a non-zero scroll_delta, then we should compute 8892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // its local scroll compensation and accumulate it to the 8902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // next_scroll_compensation_matrix. 891424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!scroll_delta.IsZero()) { 8922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform scroll_compensation_for_this_layer = 893c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ComputeScrollCompensationForThisLayer( 8941e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) layer, parent_matrix, scroll_delta); 8952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix.PreconcatTransform( 8962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer); 8972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 8982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer created its own render_surface, we have to adjust 9002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // next_scroll_compensation_matrix. The adjustment allows us to continue 9012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // using the scroll compensation on the next surface. 9022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 1 (right-most in the math): transform from the new surface to the 9032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // original ancestor surface 9042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 2: apply the scroll compensation 9052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 3: transform back to the new surface. 9062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->render_surface() && 9072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !next_scroll_compensation_matrix.IsIdentity()) { 9082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_surface_draw_transform( 9092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 9102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->render_surface()->draw_transform().GetInverse( 9112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_surface_draw_transform)) { 9122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 9132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 9142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix = 9162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) inverse_surface_draw_transform * next_scroll_compensation_matrix * 9172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->draw_transform(); 9182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return next_scroll_compensation_matrix; 9212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 924f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)static inline void UpdateLayerScaleDrawProperties( 925c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerType* layer, 926f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float ideal_contents_scale, 927f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float maximum_animation_contents_scale, 928f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float page_scale_factor, 929f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) float device_scale_factor) { 930f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().ideal_contents_scale = ideal_contents_scale; 931f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().maximum_animation_contents_scale = 932f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) maximum_animation_contents_scale; 933f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().page_scale_factor = page_scale_factor; 934f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().device_scale_factor = device_scale_factor; 935f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)} 936f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 9376e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)static inline void CalculateContentsScale(LayerImpl* layer, 9386e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) float contents_scale) { 939f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // LayerImpl has all of its content scales and bounds pushed from the Main 940f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // thread during commit and just uses those values as-is. 941f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles)} 942f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 9436e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)static inline void CalculateContentsScale(Layer* layer, float contents_scale) { 9442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->CalculateContentsScale(contents_scale, 9452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().contents_scale_x, 9462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().contents_scale_y, 9472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().content_bounds); 9482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 949f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) Layer* mask_layer = layer->mask_layer(); 9502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (mask_layer) { 9512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer->CalculateContentsScale( 9522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) contents_scale, 9532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().contents_scale_x, 9542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().contents_scale_y, 9552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().content_bounds); 9562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 958f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) Layer* replica_mask_layer = 9592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL; 9602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (replica_mask_layer) { 9612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_layer->CalculateContentsScale( 9622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) contents_scale, 9632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().contents_scale_x, 9642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().contents_scale_y, 9652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().content_bounds); 9662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void UpdateLayerContentsScale( 9702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer, 971b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool can_adjust_raster_scale, 972c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale, 9732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float device_scale_factor, 9742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float page_scale_factor, 9752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen) { 9766e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) CalculateContentsScale(layer, ideal_contents_scale); 9772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void UpdateLayerContentsScale( 9802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Layer* layer, 981b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool can_adjust_raster_scale, 982c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale, 9832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float device_scale_factor, 9842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float page_scale_factor, 9852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen) { 986b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (can_adjust_raster_scale) { 987c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_raster_scale = 988c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale / (device_scale_factor * page_scale_factor); 9892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 990b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool need_to_set_raster_scale = layer->raster_scale_is_unknown(); 9912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If we've previously saved a raster_scale but the ideal changes, things 9932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // are unpredictable and we should just use 1. 994b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (!need_to_set_raster_scale && layer->raster_scale() != 1.f && 995b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ideal_raster_scale != layer->raster_scale()) { 9962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ideal_raster_scale = 1.f; 9972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) need_to_set_raster_scale = true; 9982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 10002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (need_to_set_raster_scale) { 10012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool use_and_save_ideal_scale = 10022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ideal_raster_scale >= 1.f && !animating_transform_to_screen; 1003b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (use_and_save_ideal_scale) 1004b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) layer->set_raster_scale(ideal_raster_scale); 10052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1008b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) float raster_scale = 1.f; 1009b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (!layer->raster_scale_is_unknown()) 1010b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) raster_scale = layer->raster_scale(); 1011b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 1012a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) gfx::Size old_content_bounds = layer->content_bounds(); 1013a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) float old_contents_scale_x = layer->contents_scale_x(); 1014a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) float old_contents_scale_y = layer->contents_scale_y(); 10152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1016c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float contents_scale = raster_scale * device_scale_factor * page_scale_factor; 10176e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles) CalculateContentsScale(layer, contents_scale); 1018a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) 1019a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) if (layer->content_bounds() != old_content_bounds || 1020a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->contents_scale_x() != old_contents_scale_x || 1021a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->contents_scale_y() != old_contents_scale_y) 1022a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->SetNeedsPushProperties(); 10232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 10242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1025c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateAnimationContentsScale( 1026c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch Layer* layer, 1027c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale, 1028c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float ancestor_maximum_animation_contents_scale, 1029c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& parent_transform, 1030c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& combined_transform, 1031c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool* combined_is_animating_scale, 1032c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float* combined_maximum_animation_contents_scale) { 1033c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = false; 1034c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1035c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 1036c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1037c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateAnimationContentsScale( 1038c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerImpl* layer, 1039c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale, 1040c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float ancestor_maximum_animation_contents_scale, 1041c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& ancestor_transform, 1042c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& combined_transform, 1043c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool* combined_is_animating_scale, 1044c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float* combined_maximum_animation_contents_scale) { 1045c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (ancestor_is_animating_scale && 1046c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ancestor_maximum_animation_contents_scale == 0.f) { 1047c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We've already failed to compute a maximum animated scale at an 1048c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // ancestor, so we'll continue to fail. 1049c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1050c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1051c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1052c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1053c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1054c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!combined_transform.IsScaleOrTranslation()) { 1055c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // Computing maximum animated scale in the presence of 1056c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // non-scale/translation transforms isn't supported. 1057c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1058c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1059c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1060c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1061c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1062c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We currently only support computing maximum scale for combinations of 1063c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // scales and translations. We treat all non-translations as potentially 1064c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // affecting scale. Animations that include non-translation/scale components 1065c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // will cause the computation of MaximumScale below to fail. 1066c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool layer_is_animating_scale = 1067c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch !layer->layer_animation_controller()->HasOnlyTranslationTransforms(); 1068c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1069c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer_is_animating_scale && !ancestor_is_animating_scale) { 1070c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1071c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = false; 1072c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1073c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1074c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1075c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We don't attempt to accumulate animation scale from multiple nodes, 1076c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // because of the risk of significant overestimation. For example, one node 1077c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // may be increasing scale from 1 to 10 at the same time as a descendant is 1078c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // decreasing scale from 10 to 1. Naively combining these scales would produce 1079c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // a scale of 100. 1080c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (layer_is_animating_scale && ancestor_is_animating_scale) { 1081c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1082c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1083c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1084c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1085c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1086c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // At this point, we know either the layer or an ancestor, but not both, 1087c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // is animating scale. 1088c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1089c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer_is_animating_scale) { 1090c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF layer_transform_scales = 1091c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(layer->transform(), 0.f); 1092c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 1093c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ancestor_maximum_animation_contents_scale * 1094c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(layer_transform_scales.x(), layer_transform_scales.y()); 1095c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1096c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1097c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1098c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float layer_maximum_animated_scale = 0.f; 10991675a649fd7a8b3cb80ffddae2dc181f122353c5Ben Murdoch if (!layer->layer_animation_controller()->MaximumTargetScale( 1100c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &layer_maximum_animated_scale)) { 1101c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1102c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1103c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1104c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF ancestor_transform_scales = 1105c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f); 1106c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 1107c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch layer_maximum_animated_scale * 1108c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y()); 1109c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 1110c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 11115c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liutemplate <typename LayerType> 11125c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic inline typename LayerType::RenderSurfaceType* CreateOrReuseRenderSurface( 11135c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerType* layer) { 1114ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch if (!layer->render_surface()) { 1115ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->CreateRenderSurface(); 1116ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1117ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch } 1118ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 1119ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->render_surface()->ClearLayerLists(); 1120ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1121ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch} 1122ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 11230de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)template <typename LayerTypePtr> 11240de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)static inline void MarkLayerWithRenderSurfaceLayerListId( 11250de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) LayerTypePtr layer, 11260de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 11270de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) layer->draw_properties().last_drawn_render_surface_layer_list_id = 11280de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id; 11290de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)} 11300de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11310de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)template <typename LayerTypePtr> 11320de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)static inline void MarkMasksWithRenderSurfaceLayerListId( 11330de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) LayerTypePtr layer, 11340de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 11350de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) if (layer->mask_layer()) { 11360de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer->mask_layer(), 11370de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11380de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 11390de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { 11400de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer->replica_layer()->mask_layer(), 11410de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11420de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 11430de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)} 11440de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11450de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)template <typename LayerListType> 11460de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)static inline void MarkLayerListWithRenderSurfaceLayerListId( 11470de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) LayerListType* layer_list, 11480de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 11490de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) for (typename LayerListType::iterator it = layer_list->begin(); 11500de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) it != layer_list->end(); 11510de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) ++it) { 11520de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(*it, 11530de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11540de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkMasksWithRenderSurfaceLayerListId(*it, 11550de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 11560de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 11570de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles)} 11580de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11598bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 11602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void RemoveSurfaceForEarlyExit( 11612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer_to_remove, 11628bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* render_surface_layer_list) { 11632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer_to_remove->render_surface()); 11642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Technically, we know that the layer we want to remove should be 11652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // at the back of the render_surface_layer_list. However, we have had 11662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // bugs before that added unnecessary layers here 11672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes 11682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // things to crash. So here we proactively remove any additional 11692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers from the end of the list. 11702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) while (render_surface_layer_list->back() != layer_to_remove) { 11710de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerListWithRenderSurfaceLayerListId( 11720de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &render_surface_layer_list->back()->render_surface()->layer_list(), 0); 11730de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(render_surface_layer_list->back(), 0); 11740de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) 11755c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu render_surface_layer_list->back()->ClearRenderSurfaceLayerList(); 11762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->pop_back(); 11772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 11782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove); 11790de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerListWithRenderSurfaceLayerListId( 11800de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &layer_to_remove->render_surface()->layer_list(), 0); 11810de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer_to_remove, 0); 11822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->pop_back(); 11835c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu layer_to_remove->ClearRenderSurfaceLayerList(); 11842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 11852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 11867dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstruct PreCalculateMetaInformationRecursiveData { 11877dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool layer_or_descendant_has_copy_request; 1188f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) bool layer_or_descendant_has_input_handler; 1189424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) int num_unclipped_descendants; 11907dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 11917dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData() 1192424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : layer_or_descendant_has_copy_request(false), 1193f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer_or_descendant_has_input_handler(false), 1194424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) num_unclipped_descendants(0) {} 11957dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 11967dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch void Merge(const PreCalculateMetaInformationRecursiveData& data) { 11977dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer_or_descendant_has_copy_request |= 11987dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch data.layer_or_descendant_has_copy_request; 1199f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer_or_descendant_has_input_handler |= 1200f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data.layer_or_descendant_has_input_handler; 1201424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) num_unclipped_descendants += 1202424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) data.num_unclipped_descendants; 12037dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch } 12047dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch}; 12057dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Recursively walks the layer tree to compute any information that is needed 12072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// before doing the main recursion. 12082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 12097dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstatic void PreCalculateMetaInformation( 12107dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch LayerType* layer, 12117dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData* recursive_data) { 12127dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 1213010d83a9304c5a91596085d917d248abff47903aTorne (Richard Coles) layer->draw_properties().sorted_for_recursion = false; 1214010d83a9304c5a91596085d917d248abff47903aTorne (Richard Coles) layer->draw_properties().has_child_with_a_scroll_parent = false; 1215010d83a9304c5a91596085d917d248abff47903aTorne (Richard Coles) 12165c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu if (!HasInvertibleOrAnimatedTransform(layer)) { 12170529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // Layers with singular transforms should not be drawn, the whole subtree 12180529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // can be skipped. 12190529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return; 12200529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch } 12210529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 1222424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_parent()) 1223424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants++; 1224424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 12252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (size_t i = 0; i < layer->children().size(); ++i) { 1226868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerType* child_layer = 12275c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i); 12282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12297dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData data_for_child; 12307dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformation(child_layer, &data_for_child); 12317dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child_layer->scroll_parent()) 12338bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->draw_properties().has_child_with_a_scroll_parent = true; 12347dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->Merge(data_for_child); 12352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 12362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1237424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_children()) { 1238424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) int num_clip_children = layer->clip_children()->size(); 1239424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children); 1240424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants -= num_clip_children; 1241424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1242424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 12437dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->HasCopyRequest()) 12447dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->layer_or_descendant_has_copy_request = true; 12457dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 1246f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (!layer->touch_event_handler_region().IsEmpty() || 1247f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->have_wheel_event_handlers()) 1248f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) recursive_data->layer_or_descendant_has_input_handler = true; 1249f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 1250424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer->draw_properties().num_unclipped_descendants = 1251424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants; 12527dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->draw_properties().layer_or_descendant_has_copy_request = 12537dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->layer_or_descendant_has_copy_request; 1254f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->draw_properties().layer_or_descendant_has_input_handler = 1255f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) recursive_data->layer_or_descendant_has_input_handler; 12562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 12572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static void RoundTranslationComponents(gfx::Transform* transform) { 125968043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) transform->matrix().set(0, 3, MathUtil::Round(transform->matrix().get(0, 3))); 126068043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) transform->matrix().set(1, 3, MathUtil::Round(transform->matrix().get(1, 3))); 12612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 12622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12632385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochtemplate <typename LayerType> 12642385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochstruct SubtreeGlobals { 12652385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch LayerSorter* layer_sorter; 12662385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch int max_texture_size; 12672385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float device_scale_factor; 12682385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float page_scale_factor; 12691e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const LayerType* page_scale_application_layer; 12702385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool can_adjust_raster_scales; 12714e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool can_render_to_separate_surface; 12722385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch}; 12732385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template<typename LayerType> 12752385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochstruct DataForRecursion { 12762385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The accumulated sequence of transforms a layer will use to determine its 12772385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // own draw transform. 12782385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform parent_matrix; 12792385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12802385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The accumulated sequence of transforms a layer will use to determine its 12812385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // own screen-space transform. 12822385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform full_hierarchy_matrix; 12832385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12842385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The transform that removes all scrolling that may have occurred between a 12852385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // fixed-position layer and its container, so that the layer actually does 12862385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // remain fixed. 12872385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform scroll_compensation_matrix; 12882385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12892385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The ancestor that would be the container for any fixed-position / sticky 12902385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // layers. 12912385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch LayerType* fixed_container; 12922385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12932385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // This is the normal clip rect that is propagated from parent to child. 12942385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Rect clip_rect_in_target_space; 12952385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12962385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // When the layer's children want to compute their visible content rect, they 12972385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // want to know what their target surface's clip rect will be. BUT - they 12982385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // want to know this clip rect represented in their own target space. This 12992385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // requires inverse-projecting the surface's clip rect from the surface's 13002385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // render target space down to the surface's own space. Instead of computing 13012385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // this value redundantly for each child layer, it is computed only once 13022385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // while dealing with the parent layer, and then this precomputed value is 13032385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // passed down the recursion to the children that actually use it. 13042385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Rect clip_rect_of_target_surface_in_target_space; 13052385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 1306c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // The maximum amount by which this layer will be scaled during the lifetime 1307c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // of currently running animations. 1308c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale; 1309c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1310c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale; 13112385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool ancestor_clips_subtree; 13128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* 1313f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface; 13142385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool in_subtree_of_page_scale_application_layer; 13152385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool subtree_can_use_lcd_text; 13162385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool subtree_is_visible_from_ancestor; 13172385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch}; 13182385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 13198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13208bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static LayerType* GetChildContainingLayer(const LayerType& parent, 13218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* layer) { 13228bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (LayerType* ancestor = layer; ancestor; ancestor = ancestor->parent()) { 13238bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (ancestor->parent() == &parent) 13248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return ancestor; 13258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) NOTREACHED(); 13278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return 0; 13288bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13298bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13308bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13318bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void AddScrollParentChain(std::vector<LayerType*>* out, 13328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent, 13338bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* layer) { 13348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // At a high level, this function walks up the chain of scroll parents 13358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // recursively, and once we reach the end of the chain, we add the child 13368bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // of |parent| containing each scroll ancestor as we unwind. The result is 13378bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // an ordering of parent's children that ensures that scroll parents are 13388bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visited before their descendants. 13398bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Take for example this layer tree: 13408bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13418bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + stacking_context 13428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_child (1) 13438bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_parent_graphics_layer (*) 13448bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // | + scroll_parent_scrolling_layer 13458bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // | + scroll_parent_scrolling_content_layer (2) 13468bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_graphics_layer (**) 13478bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_scrolling_layer 13488bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_scrolling_content_layer (3) 13498bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13508bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // The scroll child is (1), its scroll parent is (2) and its scroll 13518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // grandparent is (3). Note, this doesn't mean that (2)'s scroll parent is 13528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // (3), it means that (*)'s scroll parent is (3). We don't want our list to 13538bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // look like [ (3), (2), (1) ], even though that does have the ancestor chain 13548bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // in the right order. Instead, we want [ (**), (*), (1) ]. That is, only want 13558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // (1)'s siblings in the list, but we want them to appear in such an order 13568bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // that the scroll ancestors get visited in the correct order. 13578bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13588bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // So our first task at this step of the recursion is to determine the layer 13598bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // that we will potentionally add to the list. That is, the child of parent 13608bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // containing |layer|. 13618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* child = GetChildContainingLayer(parent, layer); 13628bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child->draw_properties().sorted_for_recursion) 13638bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return; 13648bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13658bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (LayerType* scroll_parent = child->scroll_parent()) 13668bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) AddScrollParentChain(out, parent, scroll_parent); 13678bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) out->push_back(child); 13698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().sorted_for_recursion = true; 13708bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static bool SortChildrenForRecursion(std::vector<LayerType*>* out, 13748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent) { 13758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) out->reserve(parent.children().size()); 13768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) bool order_changed = false; 13778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < parent.children().size(); ++i) { 13788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* current = 13795c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerTreeHostCommon::get_layer_as_raw_ptr(parent.children(), i); 13808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (current->draw_properties().sorted_for_recursion) { 13828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) order_changed = true; 13838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) continue; 13848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13868bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) AddScrollParentChain(out, parent, current); 13878bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13888bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13898bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DCHECK_EQ(parent.children().size(), out->size()); 13908bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return order_changed; 13918bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13928bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13948bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void GetNewDescendantsStartIndexAndCount(LayerType* layer, 13958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* start_index, 13968bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* count) { 13978bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *start_index = layer->draw_properties().index_of_first_descendants_addition; 13988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *count = layer->draw_properties().num_descendants_added; 13998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void GetNewRenderSurfacesStartIndexAndCount(LayerType* layer, 14038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* start_index, 14048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* count) { 14058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *start_index = layer->draw_properties() 14068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) .index_of_first_render_surface_layer_list_addition; 14078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *count = layer->draw_properties().num_render_surfaces_added; 14088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14105c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu// We need to extract a list from the the two flavors of RenderSurfaceListType 14115c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu// for use in the sorting function below. 14125c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic LayerList* GetLayerListForSorting(RenderSurfaceLayerList* rsll) { 14135c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu return &rsll->AsLayerList(); 14145c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu} 14155c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu 14165c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liustatic LayerImplList* GetLayerListForSorting(LayerImplList* layer_list) { 14175c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu return layer_list; 14185c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu} 14195c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu 14205c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liutemplate <typename LayerType, typename GetIndexAndCountType> 14218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void SortLayerListContributions( 14228bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent, 14235c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu typename LayerType::LayerListType* unsorted, 14248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t start_index_for_all_contributions, 14258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) GetIndexAndCountType get_index_and_count) { 14268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::LayerListType buffer; 14278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < parent.children().size(); ++i) { 14288bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* child = 14295c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerTreeHostCommon::get_layer_as_raw_ptr(parent.children(), i); 14308bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14318bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t start_index = 0; 14328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t count = 0; 14338bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) get_index_and_count(child, &start_index, &count); 14348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t j = start_index; j < start_index + count; ++j) 14358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) buffer.push_back(unsorted->at(j)); 14368bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 14378bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14388bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DCHECK_EQ(buffer.size(), 14398bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) unsorted->size() - start_index_for_all_contributions); 14408bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14418bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < buffer.size(); ++i) 14428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) (*unsorted)[i + start_index_for_all_contributions] = buffer[i]; 14438bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14448bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Recursively walks the layer tree starting at the given node and computes all 14462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// the necessary transformations, clip rects, render surfaces, etc. 14478bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static void CalculateDrawPropertiesInternal( 14492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 14502385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch const SubtreeGlobals<LayerType>& globals, 14518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const DataForRecursion<LayerType>& data_from_ancestor, 14528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* render_surface_layer_list, 14535c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu typename LayerType::LayerListType* layer_list, 14540de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerType> >* accumulated_surface_state, 14550de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) int current_render_surface_layer_list_id) { 14562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This function computes the new matrix transformations recursively for this 14572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer and all its descendants. It also computes the appropriate render 14582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surfaces. 14592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some important points to remember: 14602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 0. Here, transforms are notated in Matrix x Vector order, and in words we 14622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // describe what the transform does from left to right. 14632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 1. In our terminology, the "layer origin" refers to the top-left corner of 14652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // a layer, and the positive Y-axis points downwards. This interpretation is 14662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // valid because the orthographic projection applied at draw time flips the Y 14672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // axis appropriately. 14682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 2. The anchor point, when given as a PointF object, is specified in "unit 14702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer space", where the bounds of the layer map to [0, 1]. However, as a 14712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Transform object, the transform to the anchor point is specified in "layer 14722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space", where the bounds of the layer map to [bounds.width(), 14732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // bounds.height()]. 14742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 3. Definition of various transforms used: 14762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[parent] is the parent matrix, with respect to the nearest render 14772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surface, passed down recursively. 14782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[root] is the full hierarchy, with respect to the root, passed down 14802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // recursively. 14812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin] is the translation matrix from the parent's origin to 14832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this layer's origin. 14842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor] is the translation from the layer's origin to its 14862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // anchor point 14872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2center] is the translation from the layer's origin to its 14892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // center 14902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[layer] is the layer's matrix (applied at the anchor point) 14922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] is the ratio of a layer's content_bounds() to its 14942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Bounds(). 14952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some composite transforms can help in understanding the sequence of 14972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transforms: 14982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // composite_layer_transform = Tr[origin2anchor] * M[layer] * 14992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor].inverse() 15002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4. When a layer (or render surface) is drawn, it is drawn into a "target 15022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render surface". Therefore the draw transform does not necessarily 15032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform from screen space to local layer space. Instead, the draw 15042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform is the transform between the "target render surface space" and 15052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // local layer space. Note that render surfaces, except for the root, also 15062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw themselves into a different target render surface, and so their draw 15072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform and origin transforms are also described with respect to the 15082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // target. 15092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Using these definitions, then: 15112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The draw transform for the layer is: 15132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] = M[parent] * Tr[origin] * composite_layer_transform * 15142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] = M[parent] * Tr[layer->position() + anchor] * 15152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[layer] * Tr[anchor2origin] * S[layer2content] 15162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Interpreting the math left-to-right, this transforms from the 15182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's render surface to the origin of the layer in content space. 15192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The screen space transform is: 15212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[screenspace] = M[root] * Tr[origin] * composite_layer_transform * 15222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] 15232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // = M[root] * Tr[layer->position() + anchor] * M[layer] 15242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // * Tr[anchor2origin] * S[layer2content] 15252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Interpreting the math left-to-right, this transforms from the root 15272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render surface's content space to the origin of the layer in content 15282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. 15292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The transform hierarchy that is passed on to children (i.e. the child's 15312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // parent_matrix) is: 15322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[parent]_for_child = M[parent] * Tr[origin] * 15335d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // composite_layer_transform 15342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // = M[parent] * Tr[layer->position() + anchor] * 15355d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // M[layer] * Tr[anchor2origin] 15362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and a similar matrix for the full hierarchy with respect to the 15382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // root. 15392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Finally, note that the final matrix used by the shader for the layer is P * 15412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] * S . This final product is computed in drawTexturedQuad(), where: 15422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // P is the projection matrix 15432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S is the scale adjustment (to scale up a canonical quad to the 15442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's size) 15452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // When a render surface has a replica layer, that layer's transform is used 15472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to draw a second copy of the surface. gfx::Transforms named here are 15482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // relative to the surface, unless they specify they are relative to the 15492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // replica layer. 15502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // We will denote a scale by device scale S[deviceScale] 15522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The render surface draw transform to its target surface origin is: 15542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[surfaceDraw] = M[owningLayer->Draw] 15552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The render surface origin transform to its the root (screen space) origin 15572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // is: 15582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[surface2root] = M[owningLayer->screenspace] * 15592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[deviceScale].inverse() 15602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The replica draw transform to its target surface origin is: 15622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * 15632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[replica->position() + replica->anchor()] * Tr[replica] * 15642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor].inverse() * S[contents_scale].inverse() 15652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The replica draw transform to the root (screen space) origin is: 15672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[replica2root] = M[surface2root] * Tr[replica->position()] * 15682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[replica] * Tr[origin2anchor].inverse() 15692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1571c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // It makes no sense to have a non-unit page_scale_factor without specifying 1572c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // which layer roots the subtree the scale is applied to. 15732385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch DCHECK(globals.page_scale_application_layer || 15742385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch (globals.page_scale_factor == 1.f)); 1575c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 15768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<LayerType> data_for_children; 15778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* 1578f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface = 1579f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) data_from_ancestor.nearest_occlusion_immune_ancestor_surface; 15802385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.in_subtree_of_page_scale_application_layer = 15812385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.in_subtree_of_page_scale_application_layer; 15822385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.subtree_can_use_lcd_text = 15832385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_can_use_lcd_text; 15842385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 15855d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Layers that are marked as hidden will hide themselves and their subtree. 15865d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Exception: Layers with copy requests, whether hidden or not, must be drawn 15875d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // anyway. In this case, we will inform their subtree they are visible to get 15885d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // the right results. 15895d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const bool layer_is_visible = 15902385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_is_visible_from_ancestor && 15912385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch !layer->hide_layer_and_subtree(); 15925d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest(); 15937dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 15942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer cannot skip CalcDrawProperties. 15955d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) { 1596424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) 15975c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu layer->ClearRenderSurfaceLayerList(); 15982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 1599424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1600424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1601424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We need to circumvent the normal recursive flow of information for clip 1602424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // children (they don't inherit their direct ancestor's clip information). 1603424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // This is unfortunate, and would be unnecessary if we were to formally 1604424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // separate the clipping hierarchy from the layer hierarchy. 1605424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree; 1606424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect ancestor_clip_rect_in_target_space = 1607424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) data_from_ancestor.clip_rect_in_target_space; 1608424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1609424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Update our clipping state. If we have a clip parent we will need to pull 1610424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // from the clip state cache rather than using the clip state passed from our 1611424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // immediate ancestor. 16128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) UpdateClipRectsForClipChild<LayerType>( 1613424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer, &ancestor_clip_rect_in_target_space, &ancestor_clips_subtree); 16142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // As this function proceeds, these are the properties for the current 16162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer that actually get computed. To avoid unnecessary copies 16172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // (particularly for matrices), we do computations directly on these values 16182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // when possible. 16198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& layer_draw_properties = layer->draw_properties(); 16202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1621a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch gfx::Rect clip_rect_in_target_space; 1622a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch bool layer_or_ancestor_clips_descendants = false; 16232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This value is cached on the stack so that we don't have to inverse-project 16252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the surface's clip rect redundantly for every layer. This value is the 1626a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // same as the target surface's clip rect, except that instead of being 1627a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // described in the target surface's target's space, it is described in the 1628a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // current render target's space. 1629a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch gfx::Rect clip_rect_of_target_surface_in_target_space; 16302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float accumulated_draw_opacity = layer->opacity(); 16322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_opacity_to_target = layer->OpacityIsAnimating(); 16332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_opacity_to_screen = animating_opacity_to_target; 16342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) { 16352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) accumulated_draw_opacity *= layer->parent()->draw_opacity(); 16362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_target |= layer->parent()->draw_opacity_is_animating(); 16372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen |= 16382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->screen_space_opacity_is_animating(); 16392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_target = layer->TransformIsAnimating(); 16422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen = animating_transform_to_target; 16432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) { 16442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target |= 16452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->draw_transform_is_animating(); 16462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen |= 16472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->screen_space_transform_is_animating(); 16482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 164946d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) gfx::Point3F transform_origin = layer->transform_origin(); 1650424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF scroll_offset = GetEffectiveTotalScrollOffset(layer); 1651424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::PointF position = layer->position() - scroll_offset; 16522385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform combined_transform = data_from_ancestor.parent_matrix; 16532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->transform().IsIdentity()) { 165446d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2transformOrigin] 165546d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) combined_transform.Translate3d(position.x() + transform_origin.x(), 165646d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) position.y() + transform_origin.y(), 165746d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) transform_origin.z()); 165846d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2origin] * M[layer] 16592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.PreconcatTransform(layer->transform()); 166046d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2origin] * M[layer] * 166146d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) // Tr[transformOrigin2origin] 166246d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) combined_transform.Translate3d( 166346d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) -transform_origin.x(), -transform_origin.y(), -transform_origin.z()); 16642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 16652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.Translate(position.x(), position.y()); 16662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16681e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF effective_scroll_delta = GetEffectiveScrollDelta(layer); 16692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!animating_transform_to_target && layer->scrollable() && 16702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.IsScaleOrTranslation()) { 16712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Align the scrollable layer's position to screen space pixels to avoid 16722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // blurriness. To avoid side-effects, do this only if the transform is 16732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // simple. 16741e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF previous_translation = combined_transform.To2dTranslation(); 16752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RoundTranslationComponents(&combined_transform); 16761e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF current_translation = combined_transform.To2dTranslation(); 16771e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 16781e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // This rounding changes the scroll delta, and so must be included 1679e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // in the scroll compensation matrix. The scaling converts from physical 1680e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // coordinates to the scroll delta's CSS coordinates (using the parent 1681e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // matrix instead of combined transform since scrolling is applied before 1682e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // the layer's transform). For example, if we have a total scale factor of 1683e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // 3.0, then 1 physical pixel is only 1/3 of a CSS pixel. 1684e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch gfx::Vector2dF parent_scales = MathUtil::ComputeTransform2dScaleComponents( 1685e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch data_from_ancestor.parent_matrix, 1.f); 1686e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch effective_scroll_delta -= 1687e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch gfx::ScaleVector2d(current_translation - previous_translation, 1688e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch 1.f / parent_scales.x(), 1689e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch 1.f / parent_scales.y()); 16902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1692c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply adjustment from position constraints. 16932385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch ApplyPositionAdjustment(layer, data_from_ancestor.fixed_container, 16942385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.scroll_compensation_matrix, &combined_transform); 1695c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1696c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool combined_is_animating_scale = false; 1697c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float combined_maximum_animation_contents_scale = 0.f; 1698c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (globals.can_adjust_raster_scales) { 1699c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch CalculateAnimationContentsScale( 1700c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch layer, 1701c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.ancestor_is_animating_scale, 1702c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.maximum_animation_contents_scale, 1703c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.parent_matrix, 1704c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_transform, 1705c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &combined_is_animating_scale, 1706c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &combined_maximum_animation_contents_scale); 1707c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1708c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_children.ancestor_is_animating_scale = combined_is_animating_scale; 1709c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_children.maximum_animation_contents_scale = 1710c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_maximum_animation_contents_scale; 1711c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1712c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Compute the 2d scale components of the transform hierarchy up to the target 1713c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // surface. From there, we can decide on a contents scale for the layer. 17142385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float layer_scale_factors = globals.device_scale_factor; 17152385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch if (data_from_ancestor.in_subtree_of_page_scale_application_layer) 17162385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_scale_factors *= globals.page_scale_factor; 1717c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Vector2dF combined_transform_scales = 1718c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) MathUtil::ComputeTransform2dScaleComponents( 1719c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform, 1720b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) layer_scale_factors); 1721b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 1722c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale = 17232385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales 1724b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ? std::max(combined_transform_scales.x(), 1725b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) combined_transform_scales.y()) 1726b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) : layer_scale_factors; 1727c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) UpdateLayerContentsScale( 1728c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer, 17292385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales, 1730c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale, 17312385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.device_scale_factor, 1732c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.in_subtree_of_page_scale_application_layer 1733c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ? globals.page_scale_factor 1734c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch : 1.f, 1735c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) animating_transform_to_screen); 17362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1737f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) UpdateLayerScaleDrawProperties( 1738f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer, 1739f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ideal_contents_scale, 1740f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) combined_maximum_animation_contents_scale, 1741f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data_from_ancestor.in_subtree_of_page_scale_application_layer 1742f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ? globals.page_scale_factor 1743f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) : 1.f, 1744f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) globals.device_scale_factor); 1745f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 1746f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) LayerType* mask_layer = layer->mask_layer(); 1747f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (mask_layer) { 1748f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) UpdateLayerScaleDrawProperties( 1749f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) mask_layer, 1750f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ideal_contents_scale, 1751f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) combined_maximum_animation_contents_scale, 1752f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data_from_ancestor.in_subtree_of_page_scale_application_layer 1753f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ? globals.page_scale_factor 1754f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) : 1.f, 1755f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) globals.device_scale_factor); 1756f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) } 1757f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 1758f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) LayerType* replica_mask_layer = 1759f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL; 1760f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (replica_mask_layer) { 1761f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) UpdateLayerScaleDrawProperties( 1762f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) replica_mask_layer, 1763f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ideal_contents_scale, 1764f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) combined_maximum_animation_contents_scale, 1765f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) data_from_ancestor.in_subtree_of_page_scale_application_layer 1766f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) ? globals.page_scale_factor 1767f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) : 1.f, 1768f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) globals.device_scale_factor); 1769f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) } 1770f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) 17712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The draw_transform that gets computed below is effectively the layer's 17722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw_transform, unless the layer itself creates a render_surface. In that 17732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // case, the render_surface re-parents the transforms. 17742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform = combined_transform; 17752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] = M[parent] * LT * S[layer2content] 177658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) layer_draw_properties.target_space_transform.Scale( 177758537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) SK_MScalar1 / layer->contents_scale_x(), 177858537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) SK_MScalar1 / layer->contents_scale_y()); 17792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The layer's screen_space_transform represents the transform between root 17812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's "screen space" and local content space. 17822385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_draw_properties.screen_space_transform = 17832385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.full_hierarchy_matrix; 17845d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->should_flatten_transform()) 17852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform.FlattenTo2d(); 17862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform.PreconcatTransform 17872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer_draw_properties.target_space_transform); 17882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Adjusting text AA method during animation may cause repaints, which in-turn 17902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // causes jank. 17912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool adjust_text_aa = 17922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !animating_opacity_to_screen && !animating_transform_to_screen; 17932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // To avoid color fringing, LCD text should only be used on opaque layers with 17942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // just integral translation. 17952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool layer_can_use_lcd_text = 17962385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_can_use_lcd_text && 17972385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch accumulated_draw_opacity == 1.f && 17982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform. 17992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) IsIdentityOrIntegerTranslation(); 18002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1801f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) gfx::Rect content_rect(layer->content_bounds()); 18022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // full_hierarchy_matrix is the matrix that transforms objects between screen 18042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space (except projection matrix) and the most recent RenderSurfaceImpl's 18052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. next_hierarchy_matrix will only change if this layer uses a new 18062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // RenderSurfaceImpl, otherwise remains the same. 18072385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.full_hierarchy_matrix = 18082385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.full_hierarchy_matrix; 18092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1810b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If the subtree will scale layer contents by the transform hierarchy, then 1811b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // we should scale things into the render surface by the transform hierarchy 1812b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // to take advantage of that. 1813b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) gfx::Vector2dF render_surface_sublayer_scale = 18142385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales 1815b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ? combined_transform_scales 1816b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) : gfx::Vector2dF(layer_scale_factors, layer_scale_factors); 18172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18184e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool render_to_separate_surface; 18194e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (globals.can_render_to_separate_surface) { 18204e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) render_to_separate_surface = SubtreeShouldRenderToSeparateSurface( 18214e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer, combined_transform.Preserves2dAxisAlignment()); 18224e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } else { 18234e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) render_to_separate_surface = IsRootLayer(layer); 18244e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } 18254e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (render_to_separate_surface) { 18262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Check back-face visibility before continuing with this surface and its 18272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // subtree 18282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->double_sided() && TransformToParentIsKnown(layer) && 1829424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) IsSurfaceBackFaceVisible(layer, combined_transform)) { 18305c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu layer->ClearRenderSurfaceLayerList(); 18312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 1832424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 18332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* render_surface = 18358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) CreateOrReuseRenderSurface(layer); 18362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1837b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (IsRootLayer(layer)) { 1838868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The root layer's render surface size is predetermined and so the root 1839868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // layer can't directly support non-identity transforms. It should just 1840868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // forward top-level transforms to the rest of the tree. 18412385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix = combined_transform; 18427dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 18437dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // The root surface does not contribute to any other surface, it has no 18447dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // target. 18457dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->render_surface()->set_contributes_to_drawn_surface(false); 1846868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } else { 1847868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The owning layer's draw transform has a scale from content to layer 1848868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // space which we do not want; so here we use the combined_transform 1849868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // instead of the draw_transform. However, we do need to add a different 1850868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale factor that accounts for the surface's pixel dimensions. 1851868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) combined_transform.Scale(1.0 / render_surface_sublayer_scale.x(), 1852868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1.0 / render_surface_sublayer_scale.y()); 1853868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface->SetDrawTransform(combined_transform); 1854868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1855868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The owning layer's transform was re-parented by the surface, so the 1856868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // layer's new draw_transform only needs to scale the layer to surface 1857868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // space. 1858868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) layer_draw_properties.target_space_transform.MakeIdentity(); 1859868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) layer_draw_properties.target_space_transform. 1860868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) Scale(render_surface_sublayer_scale.x() / layer->contents_scale_x(), 1861868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface_sublayer_scale.y() / layer->contents_scale_y()); 1862868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1863868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Inside the surface's subtree, we scale everything to the owning layer's 1864868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale. The sublayer matrix transforms layer rects into target surface 1865868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // content space. Conceptually, all layers in the subtree inherit the 1866868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale at the point of the render surface in the transform hierarchy, 1867868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // but we apply it explicitly to the owning layer and the remainder of the 1868868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // subtree independently. 18692385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch DCHECK(data_for_children.parent_matrix.IsIdentity()); 18702385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix.Scale(render_surface_sublayer_scale.x(), 1871868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface_sublayer_scale.y()); 18727dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 18735d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Even if the |layer_is_drawn|, it only contributes to a drawn surface 18745d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // when the |layer_is_visible|. 18757dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->render_surface()->set_contributes_to_drawn_surface( 18762385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_is_visible); 1877b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 1878b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 18792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The opacity value is moved from the layer to its surface, so that the 18802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // entire subtree properly inherits opacity. 18812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetDrawOpacity(accumulated_draw_opacity); 18822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetDrawOpacityIsAnimating(animating_opacity_to_target); 18832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_target = false; 18842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity = 1.f; 18852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity_is_animating = animating_opacity_to_target; 18862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_opacity_is_animating = 18872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen; 18882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetTargetSurfaceTransformsAreAnimating( 18902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target); 18912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetScreenSpaceTransformsAreAnimating( 18922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen); 18932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target = false; 18942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform_is_animating = 18952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target; 18962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform_is_animating = 18972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen; 18982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Update the aggregate hierarchy matrix to include the transform of the 19002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // newly created RenderSurfaceImpl. 19012385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.full_hierarchy_matrix.PreconcatTransform( 19022385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch render_surface->draw_transform()); 19032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->mask_layer()) { 19058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& mask_layer_draw_properties = 19062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->mask_layer()->draw_properties(); 19072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer_draw_properties.render_target = layer; 19082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer_draw_properties.visible_content_rect = 19092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()); 19102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { 19138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& replica_mask_draw_properties = 19142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->mask_layer()->draw_properties(); 19152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_draw_properties.render_target = layer; 19162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_draw_properties.visible_content_rect = 19172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()); 19182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1920f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Ignore occlusion from outside the surface when surface contents need to 1921f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // be fully drawn. Layers with copy-request need to be complete. 1922f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // We could be smarter about layers with replica and exclude regions 1923f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // where both layer and the replica are occluded, but this seems like an 1924f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // overkill. The same is true for layers with filters that move pixels. 19252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(senorblanco): make this smarter for the SkImageFilter case (check 19262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // for pixel-moving filters) 1927f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->HasCopyRequest() || 1928f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->has_replica() || 1929f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->filters().HasReferenceFilter() || 1930f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->filters().HasFilterThatMovesPixels()) { 1931f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface = render_surface; 1932f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 1933f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) render_surface->SetNearestOcclusionImmuneAncestor( 1934f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface); 19352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1936424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = false; 1937424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool subtree_is_clipped_by_surface_bounds = false; 1938424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree) { 1939424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // It may be the layer or the surface doing the clipping of the subtree, 1940424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // but in either case, we'll be clipping to the projected clip rect of our 1941424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // ancestor. 19422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_surface_draw_transform( 19432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 19442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!render_surface->draw_transform().GetInverse( 19452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_surface_draw_transform)) { 19462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 19472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 19482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 1949424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 19501320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci gfx::Rect surface_clip_rect_in_target_space = gfx::IntersectRects( 19511320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci data_from_ancestor.clip_rect_of_target_surface_in_target_space, 19521320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ancestor_clip_rect_in_target_space); 19535d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) gfx::Rect projected_surface_rect = MathUtil::ProjectEnclosingClippedRect( 19541320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci inverse_surface_draw_transform, surface_clip_rect_in_target_space); 1955424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1956424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer_draw_properties.num_unclipped_descendants > 0) { 1957424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we have unclipped descendants, we cannot count on the render 1958424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surface's bounds clipping our subtree: the unclipped descendants 1959424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // could cause us to expand our bounds. In this case, we must rely on 1960424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // layer clipping for correctess. NB: since we can only encounter 1961424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // translations between a clip child and its clip parent, clipping is 1962424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // guaranteed to be exact in this case. 1963424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = true; 1964424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect_in_target_space = projected_surface_rect; 1965424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } else { 1966424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The new render_surface here will correctly clip the entire subtree. 1967424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // So, we do not need to continue propagating the clipping state further 1968424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // down the tree. This way, we can avoid transforming clip rects from 1969424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // ancestor target surface space to current target surface space that 1970424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // could cause more w < 0 headaches. The render surface clip rect is 1971424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // expressed in the space where this surface draws, i.e. the same space 1972424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // as clip_rect_from_ancestor_in_ancestor_target_space. 1973424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) render_surface->SetClipRect(ancestor_clip_rect_in_target_space); 1974424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect_of_target_surface_in_target_space = projected_surface_rect; 1975424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) subtree_is_clipped_by_surface_bounds = true; 1976424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1977424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1978424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1979424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(layer->render_surface()); 1980424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(!layer->parent() || layer->parent()->render_target() == 1981424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->back().render_target); 1982424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1983424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->push_back( 1984424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceState<LayerType>(layer)); 1985424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1986424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) render_surface->SetIsClipped(subtree_is_clipped_by_surface_bounds); 1987424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!subtree_is_clipped_by_surface_bounds) { 19882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetClipRect(gfx::Rect()); 1989a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space = 19902385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.clip_rect_of_target_surface_in_target_space; 19912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the new render surface is drawn translucent or with a non-integral 19942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // translation then the subtree that gets drawn on this render surface 19952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // cannot use LCD text. 19962385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.subtree_can_use_lcd_text = layer_can_use_lcd_text; 19972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->push_back(layer); 19992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 20002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->parent()); 20012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note: layer_draw_properties.target_space_transform is computed above, 20032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // before this if-else statement. 20042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform_is_animating = 20052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target; 20062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform_is_animating = 20072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen; 20082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity = accumulated_draw_opacity; 20092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity_is_animating = animating_opacity_to_target; 20102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_opacity_is_animating = 20112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen; 20122385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix = combined_transform; 20132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->ClearRenderSurface(); 20152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers without render_surfaces directly inherit the ancestor's clip 20172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // status. 2018424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = ancestor_clips_subtree; 2019424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree) { 2020a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = 2021424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space; 2022a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch } 20232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The surface's cached clip rect value propagates regardless of what 20252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clipping goes on between layers here. 2026a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space = 20272385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.clip_rect_of_target_surface_in_target_space; 20282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers that are not their own render_target will render into the target 20302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // of their nearest ancestor. 20312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.render_target = layer->parent()->render_target(); 20322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (adjust_text_aa) 20352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text; 20362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2037f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) gfx::Rect rect_in_target_space = 2038f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) MathUtil::MapEnclosingClippedRect(layer->draw_transform(), content_rect); 20392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerClipsSubtree(layer)) { 2041a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer_or_ancestor_clips_descendants = true; 2042424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree && !layer->render_surface()) { 2043a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // A layer without render surface shares the same target as its ancestor. 2044a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = 2045424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space; 2046a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space.Intersect(rect_in_target_space); 20472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 2048a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = rect_in_target_space; 20492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2052424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Tell the layer the rect that it's clipped by. In theory we could use a 2053424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // tighter clip rect here (drawable_content_rect), but that actually does not 2054424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // reduce how much would be drawn, and instead it would create unnecessary 2055424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // changes to scissor state affecting GPU performance. Our clip information 2056424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // is used in the recursion below, so we must set it beforehand. 2057424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants; 2058424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer_or_ancestor_clips_descendants) { 2059424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.clip_rect = clip_rect_in_target_space; 2060424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } else { 2061424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Initialize the clip rect to a safe value that will not clip the 2062424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // layer, just in case clipping is still accidentally used. 2063424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.clip_rect = rect_in_target_space; 2064424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2065424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 20665c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu typename LayerType::LayerListType& descendants = 20672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer->render_surface() ? layer->render_surface()->layer_list() 20682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) : *layer_list); 20692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Any layers that are appended after this point are in the layer's subtree 20712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and should be included in the sorting process. 20722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) size_t sorting_start_index = descendants.size(); 20732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20740de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) if (!LayerShouldBeSkipped(layer, layer_is_drawn)) { 20750de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkLayerWithRenderSurfaceLayerListId(layer, 20760de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 20772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) descendants.push_back(layer); 20780de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) } 20792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Any layers that are appended after this point may need to be sorted if we 20818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visit the children out of order. 20828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t render_surface_layer_list_child_sorting_start_index = 20838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size(); 20848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t layer_list_child_sorting_start_index = descendants.size(); 20858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20863551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (!layer->children().empty()) { 20873551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (layer == globals.page_scale_application_layer) { 20883551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.parent_matrix.Scale( 20893551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) globals.page_scale_factor, 20903551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) globals.page_scale_factor); 20913551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.in_subtree_of_page_scale_application_layer = true; 20923551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) } 20933551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 20943551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Flatten to 2D if the layer doesn't preserve 3D. 20955d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->should_flatten_transform()) 20963551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.parent_matrix.FlattenTo2d(); 20973551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 20983551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.scroll_compensation_matrix = 20993551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) ComputeScrollCompensationMatrixForChildren( 21003551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer, 21013551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_from_ancestor.parent_matrix, 21021e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) data_from_ancestor.scroll_compensation_matrix, 21031e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) effective_scroll_delta); 21043551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.fixed_container = 21053551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer->IsContainerForFixedPositionLayers() ? 21063551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer : data_from_ancestor.fixed_container; 21073551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 21083551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.clip_rect_in_target_space = clip_rect_in_target_space; 21093551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.clip_rect_of_target_surface_in_target_space = 21103551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) clip_rect_of_target_surface_in_target_space; 21113551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.ancestor_clips_subtree = 21123551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer_or_ancestor_clips_descendants; 2113f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) data_for_children.nearest_occlusion_immune_ancestor_surface = 2114f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface; 21155d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) data_for_children.subtree_is_visible_from_ancestor = layer_is_drawn; 21163551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) } 21172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21188bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) std::vector<LayerType*> sorted_children; 21198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) bool child_order_changed = false; 21208bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (layer_draw_properties.has_child_with_a_scroll_parent) 21218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child_order_changed = SortChildrenForRecursion(&sorted_children, *layer); 21228bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (size_t i = 0; i < layer->children().size(); ++i) { 21248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // If one of layer's children has a scroll parent, then we may have to 21258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visit the children out of order. The new order is stored in 21268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // sorted_children. Otherwise, we'll grab the child directly from the 21278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // layer's list of children. 21282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* child = 21298bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer_draw_properties.has_child_with_a_scroll_parent 21308bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) ? sorted_children[i] 21315c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu : LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i); 21328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21338bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_descendants_addition = 21348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) descendants.size(); 21358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_render_surface_layer_list_addition = 21368bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size(); 21378bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21380de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) CalculateDrawPropertiesInternal<LayerType>( 21390de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) child, 21400de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) globals, 21410de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) data_for_children, 21420de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) render_surface_layer_list, 21430de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &descendants, 21440de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) accumulated_surface_state, 21450de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) current_render_surface_layer_list_id); 2146424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (child->render_surface() && 21475c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu !child->render_surface()->layer_list().empty() && 2148424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) !child->render_surface()->content_rect().IsEmpty()) { 21490de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) // This child will contribute its render surface, which means 21500de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) // we need to mark just the mask layer (and replica mask layer) 21510de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) // with the id. 21520de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) MarkMasksWithRenderSurfaceLayerListId( 21530de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) child, current_render_surface_layer_list_id); 2154424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) descendants.push_back(child); 21552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21568bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21578bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().num_descendants_added = 21588bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) descendants.size() - 21598bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_descendants_addition; 21608bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().num_render_surfaces_added = 21618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size() - 21628bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties() 21638bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) .index_of_first_render_surface_layer_list_addition; 21648bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 21658bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21668bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Add the unsorted layer list contributions, if necessary. 21678bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child_order_changed) { 21688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) SortLayerListContributions( 21698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer, 21705c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu GetLayerListForSorting(render_surface_layer_list), 21718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list_child_sorting_start_index, 21728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &GetNewRenderSurfacesStartIndexAndCount<LayerType>); 21738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 21748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) SortLayerListContributions( 21758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer, 21768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &descendants, 21778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer_list_child_sorting_start_index, 21788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &GetNewDescendantsStartIndexAndCount<LayerType>); 21792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2181424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Compute the total drawable_content_rect for this subtree (the rect is in 2182424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // target surface space). 2183424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect local_drawable_content_rect_of_subtree = 2184424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->back().drawable_content_rect; 2185424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) { 2186424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(accumulated_surface_state->back().render_target == layer); 2187424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->pop_back(); 2188424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2189424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 21902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->render_surface() && !IsRootLayer(layer) && 21912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->layer_list().empty()) { 21922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RemoveSurfaceForEarlyExit(layer, render_surface_layer_list); 21932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 21942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the layer's drawable content rect (the rect is in target surface 21972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space). 21982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.drawable_content_rect = rect_in_target_space; 2199a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch if (layer_or_ancestor_clips_descendants) { 2200f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer_draw_properties.drawable_content_rect.Intersect( 2201f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) clip_rect_in_target_space); 2202f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 2203f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->DrawsContent()) { 2204f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) local_drawable_content_rect_of_subtree.Union( 2205f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer_draw_properties.drawable_content_rect); 22062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2208a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // Compute the layer's visible content rect (the rect is in content space). 22092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.visible_content_rect = CalculateVisibleContentRect( 2210a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space); 22112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the remaining properties for the render surface, if the layer has 22132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // one. 22142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (IsRootLayer(layer)) { 22152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer's surface's content_rect is always the entire viewport. 22162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->render_surface()); 2217a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer->render_surface()->SetContentRect( 2218424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space); 22198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } else if (layer->render_surface()) { 22208bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* render_surface = 22218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->render_surface(); 22222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree; 22232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Don't clip if the layer is reflected as the reflection shouldn't be 22252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clipped. If the layer is animating, then the surface's transform to 22262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // its target is not known on the main thread, and we should not use it 22272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to clip. 22282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->replica_layer() && TransformToParentIsKnown(layer)) { 22292385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // Note, it is correct to use data_from_ancestor.ancestor_clips_subtree 22302385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // here, because we are looking at this layer's render_surface, not the 22312385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // layer itself. 2232424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (render_surface->is_clipped() && !clipped_content_rect.IsEmpty()) { 22332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect surface_clip_rect = LayerTreeHostCommon::CalculateVisibleRect( 22342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->clip_rect(), 22352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect, 22362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->draw_transform()); 22372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.Intersect(surface_clip_rect); 22382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The RenderSurfaceImpl backing texture cannot exceed the maximum supported 22422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // texture size. 22432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.set_width( 22442385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch std::min(clipped_content_rect.width(), globals.max_texture_size)); 22452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.set_height( 22462385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch std::min(clipped_content_rect.height(), globals.max_texture_size)); 22472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (clipped_content_rect.IsEmpty()) { 22492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RemoveSurfaceForEarlyExit(layer, render_surface_layer_list); 22502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 22512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2253f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Layers having a non-default blend mode will blend with the content 2254f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // inside its parent's render target. This render target should be 2255f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // either root_for_isolated_group, or the root of the layer tree. 2256f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Otherwise, this layer will use an incomplete backdrop, limited to its 2257f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // render target and the blending result will be incorrect. 2258f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) DCHECK(layer->uses_default_blend_mode() || IsRootLayer(layer) || 2259f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) !layer->parent()->render_target() || 2260f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) IsRootLayer(layer->parent()->render_target()) || 2261f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->parent()->render_target()->is_root_for_isolated_group()); 2262f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 22632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetContentRect(clipped_content_rect); 22642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The owning layer's screen_space_transform has a scale from content to 22662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer space which we need to undo and replace with a scale from the 22672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surface's subtree into layer space. 22682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform screen_space_transform = layer->screen_space_transform(); 22692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) screen_space_transform.Scale( 22702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->contents_scale_x() / render_surface_sublayer_scale.x(), 22712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->contents_scale_y() / render_surface_sublayer_scale.y()); 22722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetScreenSpaceTransform(screen_space_transform); 22732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->replica_layer()) { 22752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform surface_origin_to_replica_origin_transform; 22762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Scale( 22772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_sublayer_scale.x(), render_surface_sublayer_scale.y()); 22782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Translate( 22792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->position().x() + 228046d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) layer->replica_layer()->transform_origin().x(), 22812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->position().y() + 228246d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) layer->replica_layer()->transform_origin().y()); 22832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.PreconcatTransform( 22842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->transform()); 22852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Translate( 228646d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) -layer->replica_layer()->transform_origin().x(), 228746d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) -layer->replica_layer()->transform_origin().y()); 22882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Scale( 22892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.0 / render_surface_sublayer_scale.x(), 22902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.0 / render_surface_sublayer_scale.y()); 22912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the replica's "originTransform" that maps from the replica's 22932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // origin space to the target surface origin space. 22942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform replica_origin_transform = 22952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->draw_transform() * 22962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform; 22972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetReplicaDrawTransform(replica_origin_transform); 22982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the replica's "screen_space_transform" that maps from the 23002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // replica's origin space to the screen's origin space. 23012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform replica_screen_space_transform = 23022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->screen_space_transform() * 23032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform; 23042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetReplicaScreenSpaceTransform( 23052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_screen_space_transform); 23062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2309eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SavePaintPropertiesLayer(layer); 23102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If neither this layer nor any of its children were added, early out. 231258537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) if (sorting_start_index == descendants.size()) { 231358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) DCHECK(!layer->render_surface() || IsRootLayer(layer)); 23142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 231558537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) } 23162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If preserves-3d then sort all the descendants in 3D so that they can be 23182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // drawn from back to front. If the preserves-3d property is also set on the 23192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // parent then skip the sorting as the parent will sort all the descendants 23202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // anyway. 23216d86b77056ed63eb6871182f42a9fd5f07550f90Torne (Richard Coles) if (globals.layer_sorter && descendants.size() && layer->Is3dSorted() && 23225d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) !LayerIsInExisting3DRenderingContext(layer)) { 23232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) SortLayers(descendants.begin() + sorting_start_index, 23242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) descendants.end(), 23252385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.layer_sorter); 23262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23288bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) UpdateAccumulatedSurfaceState<LayerType>( 2329424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer, local_drawable_content_rect_of_subtree, accumulated_surface_state); 23302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->HasContributingDelegatedRenderPasses()) { 23322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_target()->render_surface()-> 23332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) AddContributingDelegatedRenderPassLayer(layer); 23342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 23351320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} // NOLINT(readability/fn_size) 23362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2337c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochtemplate <typename LayerType, typename RenderSurfaceLayerListType> 2338c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic void ProcessCalcDrawPropsInputs( 2339c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const LayerTreeHostCommon::CalcDrawPropsInputs<LayerType, 2340c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch RenderSurfaceLayerListType>& 2341c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs, 2342c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch SubtreeGlobals<LayerType>* globals, 2343c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DataForRecursion<LayerType>* data_for_recursion) { 2344c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(inputs.root_layer); 2345c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(IsRootLayer(inputs.root_layer)); 2346c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(inputs.render_surface_layer_list); 2347c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 23482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform identity_matrix; 23492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer's render_surface should receive the device viewport as the 23512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // initial clip rect. 2352c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Rect device_viewport_rect(inputs.device_viewport_size); 2353c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2354c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF device_transform_scale_components = 2355c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(inputs.device_transform, 1.f); 2356c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // Not handling the rare case of different x and y device scale. 2357c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float device_transform_scale = 2358c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(device_transform_scale_components.x(), 2359c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch device_transform_scale_components.y()); 2360c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2361c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Transform scaled_device_transform = inputs.device_transform; 2362c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch scaled_device_transform.Scale(inputs.device_scale_factor, 2363c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.device_scale_factor); 2364c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2365c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->layer_sorter = NULL; 2366c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->max_texture_size = inputs.max_texture_size; 2367c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->device_scale_factor = 2368c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.device_scale_factor * device_transform_scale; 2369c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->page_scale_factor = inputs.page_scale_factor; 2370c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->page_scale_application_layer = inputs.page_scale_application_layer; 2371c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->can_render_to_separate_surface = 2372c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.can_render_to_separate_surface; 2373c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->can_adjust_raster_scales = inputs.can_adjust_raster_scales; 2374c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2375c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->parent_matrix = scaled_device_transform; 2376c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->full_hierarchy_matrix = identity_matrix; 2377c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->scroll_compensation_matrix = identity_matrix; 2378c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->fixed_container = inputs.root_layer; 2379c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->clip_rect_in_target_space = device_viewport_rect; 2380c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->clip_rect_of_target_surface_in_target_space = 2381c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch device_viewport_rect; 2382c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->maximum_animation_contents_scale = 0.f; 2383c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->ancestor_is_animating_scale = false; 2384c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->ancestor_clips_subtree = true; 2385c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL; 2386c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->in_subtree_of_page_scale_application_layer = false; 2387c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text; 2388c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->subtree_is_visible_from_ancestor = true; 2389c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 23902385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 2391c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochvoid LayerTreeHostCommon::CalculateDrawProperties( 2392c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch CalcDrawPropsMainInputs* inputs) { 23935c02ac1a9c1b504631c0a3d2b6e737b5d738bae1Bo Liu LayerList dummy_layer_list; 23942385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch SubtreeGlobals<Layer> globals; 23958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<Layer> data_for_recursion; 2396c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); 23972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23987dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData recursive_data; 2399558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch PreCalculateMetaInformation(inputs->root_layer, &recursive_data); 2400424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state; 24010de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) CalculateDrawPropertiesInternal<Layer>( 24020de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->root_layer, 24030de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) globals, 24040de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) data_for_recursion, 24050de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->render_surface_layer_list, 24060de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &dummy_layer_list, 24070de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &accumulated_surface_state, 24080de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->current_render_surface_layer_list_id); 24092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The dummy layer list should not have been used. 2411c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DCHECK_EQ(0u, dummy_layer_list.size()); 24122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A root layer render_surface should always exist after 24132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // CalculateDrawProperties. 2414558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DCHECK(inputs->root_layer->render_surface()); 24152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 24162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void LayerTreeHostCommon::CalculateDrawProperties( 2418558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch CalcDrawPropsImplInputs* inputs) { 2419c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImplList dummy_layer_list; 24202385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch SubtreeGlobals<LayerImpl> globals; 24218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<LayerImpl> data_for_recursion; 2422c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); 2423c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2424c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerSorter layer_sorter; 2425c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals.layer_sorter = &layer_sorter; 24262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24277dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData recursive_data; 2428558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch PreCalculateMetaInformation(inputs->root_layer, &recursive_data); 2429424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerImpl> > 2430424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state; 24310de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) CalculateDrawPropertiesInternal<LayerImpl>( 24320de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->root_layer, 24330de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) globals, 24340de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) data_for_recursion, 24350de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->render_surface_layer_list, 24360de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &dummy_layer_list, 24370de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) &accumulated_surface_state, 24380de6073388f4e2780db8536178b129cd8f6ab386Torne (Richard Coles) inputs->current_render_surface_layer_list_id); 24392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The dummy layer list should not have been used. 2441c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DCHECK_EQ(0u, dummy_layer_list.size()); 24422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A root layer render_surface should always exist after 24432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // CalculateDrawProperties. 2444558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DCHECK(inputs->root_layer->render_surface()); 24452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 24462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} // namespace cc 2448