layer_tree_host_common.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e
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/point_conversions.h" 202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "ui/gfx/rect_conversions.h" 212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "ui/gfx/transform.h" 222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)namespace cc { 242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ScrollAndScaleSet::ScrollAndScaleSet() {} 262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ScrollAndScaleSet::~ScrollAndScaleSet() {} 282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 29c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static void SortLayers(LayerList::iterator forst, 30c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerList::iterator end, 312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void* layer_sorter) { 322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) NOTREACHED(); 332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 35c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static void SortLayers(LayerImplList::iterator first, 36c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImplList::iterator end, 372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerSorter* layer_sorter) { 382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer_sorter); 392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers"); 402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_sorter->Sort(first, end); 412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 43424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 44424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF GetEffectiveScrollDelta(LayerType* layer) { 45424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF scroll_delta = layer->ScrollDelta(); 46424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The scroll parent's scroll delta is the amount we've scrolled on the 47424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // compositor thread since the commit for this layer tree's source frame. 48424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // we last reported to the main thread. I.e., it's the discrepancy between 49424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // a scroll parent's scroll delta and offset, so we must add it here. 50424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->scroll_parent()) 51424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta += layer->scroll_parent()->ScrollDelta(); 52424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return scroll_delta; 53424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 54424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 55424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 56424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF GetEffectiveTotalScrollOffset(LayerType* layer) { 57424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF offset = layer->TotalScrollOffset(); 58424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The scroll parent's total scroll offset (scroll offset + scroll delta) 59424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // can't be used because its scroll offset has already been applied to the 60424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // scroll children's positions by the main thread layer positioning code. 61424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->scroll_parent()) 62424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) offset += layer->scroll_parent()->ScrollDelta(); 63424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return offset; 64424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 65424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)inline gfx::Rect CalculateVisibleRectWithCachedLayerRect( 675d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& target_surface_rect, 685d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_bound_rect, 695d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_rect_in_target_space, 702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& transform) { 71868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (layer_rect_in_target_space.IsEmpty()) 72868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return gfx::Rect(); 73868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Is this layer fully contained within the target surface? 752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (target_surface_rect.Contains(layer_rect_in_target_space)) 762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_bound_rect; 772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer doesn't fill up the entire surface, then find the part of 792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the surface rect where the layer could be visible. This avoids trying to 802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // project surface rect points that are behind the projection point. 812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect minimal_surface_rect = target_surface_rect; 822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) minimal_surface_rect.Intersect(layer_rect_in_target_space); 832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 843551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (minimal_surface_rect.IsEmpty()) 853551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) return gfx::Rect(); 863551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Project the corners of the target surface rect into the layer space. 882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This bounding rectangle may be larger than it needs to be (being 892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // axis-aligned), but is a reasonable filter on the space to consider. 902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Non-invertible transforms will create an empty rect here. 912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform surface_to_layer(gfx::Transform::kSkipInitialization); 932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!transform.GetInverse(&surface_to_layer)) { 943551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Because we cannot use the surface bounds to determine what portion of 953551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // the layer is visible, we must conservatively assume the full layer is 963551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // visible. 973551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) return layer_bound_rect; 982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 99c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1005d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) gfx::Rect layer_rect = MathUtil::ProjectEnclosingClippedRect( 1015d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) surface_to_layer, minimal_surface_rect); 1022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_rect.Intersect(layer_bound_rect); 1032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_rect; 1042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Rect LayerTreeHostCommon::CalculateVisibleRect( 1075d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& target_surface_rect, 1085d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_bound_rect, 1092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& transform) { 1102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect layer_in_surface_space = 1115d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) MathUtil::MapEnclosingClippedRect(transform, layer_bound_rect); 1122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return CalculateVisibleRectWithCachedLayerRect( 1132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) target_surface_rect, layer_bound_rect, layer_in_surface_space, transform); 1142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 1152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 116424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 117424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static LayerType* NextTargetSurface(LayerType* layer) { 118424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return layer->parent() ? layer->parent()->render_target() : 0; 119424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 120424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 121424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Given two layers, this function finds their respective render targets and, 122424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// computes a change of basis translation. It does this by accumulating the 123424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// translation components of the draw transforms of each target between the 124424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// ancestor and descendant. These transforms must be 2D translations, and this 125424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// requirement is enforced at every step. 1268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 127424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Vector2dF ComputeChangeOfBasisTranslation( 128424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& ancestor_layer, 129424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& descendant_layer) { 130424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(descendant_layer.HasAncestor(&ancestor_layer)); 131424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* descendant_target = descendant_layer.render_target(); 132424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(descendant_target); 133424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* ancestor_target = ancestor_layer.render_target(); 134424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(ancestor_target); 135424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 136424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF translation; 137424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) for (const LayerType* target = descendant_target; target != ancestor_target; 1381e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) target = NextTargetSurface(target)) { 1391e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& trans = target->render_surface()->draw_transform(); 1401e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // Ensure that this translation is truly 2d. 1411e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) DCHECK(trans.IsIdentityOrTranslation()); 1421e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) DCHECK_EQ(0.f, trans.matrix().get(2, 3)); 1431e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) translation += trans.To2dTranslation(); 1441e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) } 145424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 146424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return translation; 147424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 148424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 149424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)enum TranslateRectDirection { 150424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToAncestor, 151424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToDescendant 152424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)}; 153424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1548bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 155424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static gfx::Rect TranslateRectToTargetSpace(const LayerType& ancestor_layer, 156424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType& descendant_layer, 1575d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& rect, 158424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirection direction) { 1598bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) gfx::Vector2dF translation = ComputeChangeOfBasisTranslation<LayerType>( 1608bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) ancestor_layer, descendant_layer); 161424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (direction == TranslateRectDirectionToDescendant) 162424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) translation.Scale(-1.f); 163424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return gfx::ToEnclosingRect( 164424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::RectF(rect.origin() + translation, rect.size())); 165424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 166424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 167424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Attempts to update the clip rects for the given layer. If the layer has a 168424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// clip_parent, it may not inherit its immediate ancestor's clip. 1698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 170424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)static void UpdateClipRectsForClipChild( 171424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const LayerType* layer, 172424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect* clip_rect_in_parent_target_space, 173424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool* subtree_should_be_clipped) { 174424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer has no clip_parent, or the ancestor is the same as its actual 175424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parent, then we don't need special clip rects. Bail now and leave the out 176424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parameters untouched. 1778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType* clip_parent = layer->scroll_parent(); 1788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 1798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (!clip_parent) 1808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) clip_parent = layer->clip_parent(); 1818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 182424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!clip_parent || clip_parent == layer->parent()) 183424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return; 184424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 185424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The root layer is never a clip child. 186424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(layer->parent()); 187424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 188424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Grab the cached values. 189424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *clip_rect_in_parent_target_space = clip_parent->clip_rect(); 190424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *subtree_should_be_clipped = clip_parent->is_clipped(); 191424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 192424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We may have to project the clip rect into our parent's target space. Note, 193424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // it must be our parent's target space, not ours. For one, we haven't 194424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // computed our transforms, so we couldn't put it in our space yet even if we 195424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // wanted to. But more importantly, this matches the expectations of 196424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // CalculateDrawPropertiesInternal. If we, say, create a render surface, these 197424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // clip rects will want to be in its target space, not ours. 1988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (clip_parent == layer->clip_parent()) { 1998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space = TranslateRectToTargetSpace<LayerType>( 2008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_parent, 2018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer->parent(), 2028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space, 2038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectDirectionToDescendant); 2048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } else { 2058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // If we're being clipped by our scroll parent, we must translate through 2068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // our common ancestor. This happens to be our parent, so it is sufficent to 2078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // translate from our clip parent's space to the space of its ancestor (our 2088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // parent). 2098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space = 2108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectToTargetSpace<LayerType>(*layer->parent(), 2118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_parent, 2128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *clip_rect_in_parent_target_space, 2138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) TranslateRectDirectionToAncestor); 2148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 215424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 216424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 217424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// We collect an accumulated drawable content rect per render surface. 218424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// Typically, a layer will contribute to only one surface, the surface 219424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// associated with its render target. Clip children, however, may affect 220424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// several surfaces since there may be several surfaces between the clip child 221424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// and its parent. 222424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// 223424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)// NB: we accumulate the layer's *clipped* drawable content rect. 224424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)template <typename LayerType> 225424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)struct AccumulatedSurfaceState { 226424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) explicit AccumulatedSurfaceState(LayerType* render_target) 227424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : render_target(render_target) {} 228424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 229424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The accumulated drawable content rect for the surface associated with the 230424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // given |render_target|. 231424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect drawable_content_rect; 232424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 233424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The target owning the surface. (We hang onto the target rather than the 234424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surface so that we can DCHECK that the surface's draw transform is simply 235424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // a translation when |render_target| reports that it has no unclipped 236424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // descendants). 237424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* render_target; 238424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)}; 239424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 2408bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 241424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)void UpdateAccumulatedSurfaceState( 242424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* layer, 2435d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& drawable_content_rect, 244424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerType> >* 245424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state) { 246424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (IsRootLayer(layer)) 247424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) return; 248424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 249424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We will apply our drawable content rect to the accumulated rects for all 250424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surfaces between us and |render_target| (inclusive). This is either our 251424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // clip parent's target if we are a clip child, or else simply our parent's 252424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // target. We use our parent's target because we're either the owner of a 253424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // render surface and we'll want to add our rect to our *surface's* target, or 254424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // we're not and our target is the same as our parent's. In both cases, the 255424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // parent's target gives us what we want. 256424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* render_target = layer->clip_parent() 257424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ? layer->clip_parent()->render_target() 258424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : layer->parent()->render_target(); 259424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 260424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer owns a surface, then the content rect is in the wrong space. 261424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Instead, we will use the surface's DrawableContentRect which is in target 262424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // space as required. 263424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect target_rect = drawable_content_rect; 264424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) { 265424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect = 266424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::ToEnclosedRect(layer->render_surface()->DrawableContentRect()); 267424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 268424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 269424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (render_target->is_clipped()) { 270424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect clip_rect = render_target->clip_rect(); 271424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If the layer has a clip parent, the clip rect may be in the wrong space, 272424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // so we'll need to transform it before it is applied. 273424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_parent()) { 2748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) clip_rect = TranslateRectToTargetSpace<LayerType>( 275424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *layer->clip_parent(), 276424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) *layer, 277424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect, 278424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) TranslateRectDirectionToDescendant); 279424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 280424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect.Intersect(clip_rect); 281424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 282424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 283424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We must have at least one entry in the vector for the root. 284424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK_LT(0ul, accumulated_surface_state->size()); 285424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 286424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) typedef typename std::vector<AccumulatedSurfaceState<LayerType> > 287424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateVector; 288424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) typedef typename AccumulatedSurfaceStateVector::reverse_iterator 289424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateIterator; 290424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceStateIterator current_state = 291424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->rbegin(); 292424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 293424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Add this rect to the accumulated content rect for all surfaces until we 294424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // reach the target surface. 295424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool found_render_target = false; 296424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) for (; current_state != accumulated_surface_state->rend(); ++current_state) { 297424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_state->drawable_content_rect.Union(target_rect); 298424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 299424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we've reached |render_target| our work is done and we can bail. 300424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (current_state->render_target == render_target) { 301424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) found_render_target = true; 302424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) break; 303424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 304424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 305424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Transform rect from the current target's space to the next. 306424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) LayerType* current_target = current_state->render_target; 307424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(current_target->render_surface()); 308424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) const gfx::Transform& current_draw_transform = 309424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_target->render_surface()->draw_transform(); 310424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 311424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we have unclipped descendants, the draw transform is a translation. 312424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(current_target->num_unclipped_descendants() == 0 || 313424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) current_draw_transform.IsIdentityOrTranslation()); 314424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 315424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) target_rect = gfx::ToEnclosingRect( 316424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) MathUtil::MapClippedRect(current_draw_transform, target_rect)); 317424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 318424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 319424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // It is an error to not reach |render_target|. If this happens, it means that 320424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // either the clip parent is not an ancestor of the clip child or the surface 321424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // state vector is empty, both of which should be impossible. 322424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(found_render_target); 323424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles)} 324424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 3252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> static inline bool IsRootLayer(LayerType* layer) { 3262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->parent(); 3272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) { 3315d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return layer->is_3d_sorted() && layer->parent() && 3325d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) layer->parent()->is_3d_sorted(); 3332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsRootLayerOfNewRenderingContext(LayerType* layer) { 3372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) 3385d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return !layer->parent()->is_3d_sorted() && layer->is_3d_sorted(); 3392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3405d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return layer->is_3d_sorted(); 3412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsLayerBackFaceVisible(LayerType* layer) { 3452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The current W3C spec on CSS transforms says that backface visibility should 3462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // be determined differently depending on whether the layer is in a "3d 3472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // rendering context" or not. For Chromium code, we can determine whether we 3482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // are in a 3d rendering context by checking if the parent preserves 3d. 3492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer)) 3512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->draw_transform().IsBackFaceVisible(); 3522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // In this case, either the layer establishes a new 3d rendering context, or 3542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // is not in a 3d rendering context at all. 3552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->transform().IsBackFaceVisible(); 3562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool IsSurfaceBackFaceVisible(LayerType* layer, 3602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& draw_transform) { 3612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer)) 3622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return draw_transform.IsBackFaceVisible(); 3632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (IsRootLayerOfNewRenderingContext(layer)) 3652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->transform().IsBackFaceVisible(); 3662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the render_surface is not part of a new or existing rendering context, 3682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // then the layers that contribute to this surface will decide back-face 3692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // visibility for themselves. 3702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 3712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool LayerClipsSubtree(LayerType* layer) { 3752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer->masks_to_bounds() || layer->mask_layer(); 3762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 3772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 3792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static gfx::Rect CalculateVisibleContentRect( 3802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 3815d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& clip_rect_of_target_surface_in_target_space, 3825d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Rect& layer_rect_in_target_space) { 3832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->render_target()); 3842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Nothing is visible if the layer bounds are empty. 3862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() || 3872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->drawable_content_rect().IsEmpty()) 3882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Rect(); 3892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute visible bounds in target surface space. 3912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect visible_rect_in_target_surface_space = 3922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->drawable_content_rect(); 3932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->render_target()->render_surface()->clip_rect().IsEmpty()) { 395a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // The |layer| L has a target T which owns a surface Ts. The surface Ts 396a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // has a target TsT. 397a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // 398a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // In this case the target surface Ts does clip the layer L that contributes 399a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // to it. So, we have to convert the clip rect of Ts from the target space 400a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // of Ts (that is the space of TsT), to the current render target's space 401a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // (that is the space of T). This conversion is done outside this function 402a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // so that it can be cached instead of computing it redundantly for every 403a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // layer. 4042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) visible_rect_in_target_surface_space.Intersect( 405a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space); 4062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (visible_rect_in_target_surface_space.IsEmpty()) 4092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Rect(); 4102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return CalculateVisibleRectWithCachedLayerRect( 4122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) visible_rect_in_target_surface_space, 4132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()), 4142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_rect_in_target_space, 4152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_transform()); 4162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToParentIsKnown(LayerImpl* layer) { return true; } 4192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToParentIsKnown(Layer* layer) { 4212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->TransformIsAnimating(); 4222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToScreenIsKnown(LayerImpl* layer) { return true; } 4252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline bool TransformToScreenIsKnown(Layer* layer) { 4272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->screen_space_transform_is_animating(); 4282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 4315d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static bool LayerShouldBeSkipped(LayerType* layer, bool layer_is_drawn) { 4322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers can be skipped if any of these conditions are met. 4335d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // - is not drawn due to it or one of its ancestors being hidden (or having 4345d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // no copy requests). 4352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - has empty bounds 4362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the layer is not double-sided, but its back face is visible. 4374e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - is transparent 4384e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - does not draw content and does not participate in hit testing. 4392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some additional conditions need to be computed at a later point after the 4412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // recursion is finished. 4422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the intersection of render_surface content and layer clip_rect is empty 4432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - the visible_content_rect is empty 4442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note, if the layer should not have been drawn due to being fully 4462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transparent, we would have skipped the entire subtree and never made it 4472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // into this function, so it is safe to omit this check here. 4482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4495d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 4507dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return true; 4517dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 4524e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (layer->bounds().IsEmpty()) 4532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 4542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* backface_test_layer = layer; 4562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->use_parent_backface_visibility()) { 4572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->parent()); 4582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(!layer->parent()->use_parent_backface_visibility()); 4592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) backface_test_layer = layer->parent(); 4602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The layer should not be drawn if (1) it is not double-sided and (2) the 4632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // back of the layer is known to be facing the screen. 4642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!backface_test_layer->double_sided() && 4652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TransformToScreenIsKnown(backface_test_layer) && 4662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) IsLayerBackFaceVisible(backface_test_layer)) 4672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 4682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4694e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // The layer is visible to events. If it's subject to hit testing, then 4704e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // we can't skip it. 4714e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool can_accept_input = !layer->touch_event_handler_region().IsEmpty() || 4724e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->have_wheel_event_handlers(); 4734e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!layer->DrawsContent() && !can_accept_input) 4744e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) return true; 4754e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) 4762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 4772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 4782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4797dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstatic inline bool SubtreeShouldBeSkipped(LayerImpl* layer, 4805d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) bool layer_is_drawn) { 4810529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // If the layer transform is not invertible, it should not be drawn. 4820529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // TODO(ajuma): Correctly process subtrees with singular transform for the 4830529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // case where we may animate to a non-singular transform and wish to 4840529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // pre-raster. 4850529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!layer->transform_is_invertible() && !layer->TransformIsAnimating()) 4860529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 4870529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 4887dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // When we need to do a readback/copy of a layer's output, we can not skip 4897dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // it or any of its ancestors. 4907dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->draw_properties().layer_or_descendant_has_copy_request) 4917dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return false; 4927dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 4935d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer is not drawn, then skip it and its subtree. 4945d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 495eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return true; 496eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 497c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // If layer is on the pending tree and opacity is being animated then 498c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // this subtree can't be skipped as we need to create, prioritize and 499c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // include tiles for this layer when deciding if tree can be activated. 500c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating()) 501c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return false; 502c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The opacity of a layer always applies to its children (either implicitly 5042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // via a render surface or explicitly if the parent preserves 3D), so the 5052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // entire subtree can be skipped if this layer is fully transparent. 5064e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // TODO(sad): Don't skip layers used for hit testing crbug.com/295295. 5072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->opacity(); 5082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 5092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5105d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static inline bool SubtreeShouldBeSkipped(Layer* layer, bool layer_is_drawn) { 5110529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // If the layer transform is not invertible, it should not be drawn. 5120529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!layer->transform_is_invertible() && !layer->TransformIsAnimating()) 5130529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 5140529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 5157dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // When we need to do a readback/copy of a layer's output, we can not skip 5167dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // it or any of its ancestors. 5177dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->draw_properties().layer_or_descendant_has_copy_request) 5187dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return false; 5197dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 5205d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer is not drawn, then skip it and its subtree. 5215d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!layer_is_drawn) 522eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch return true; 523eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 5242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the opacity is being animated then the opacity on the main thread is 5252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // unreliable (since the impl thread may be using a different opacity), so it 5262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // should not be trusted. 5272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // In particular, it should not cause the subtree to be skipped. 5282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Similarly, for layers that might animate opacity using an impl-only 5292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // animation, their subtree should also not be skipped. 5304e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // TODO(sad): Don't skip layers used for hit testing crbug.com/295295. 5312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return !layer->opacity() && !layer->OpacityIsAnimating() && 5322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !layer->OpacityCanAnimateOnImplThread(); 5332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 5342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 535c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static inline void SavePaintPropertiesLayer(LayerImpl* layer) {} 536c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 537c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)static inline void SavePaintPropertiesLayer(Layer* layer) { 538c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->SavePaintProperties(); 539c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 540c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->mask_layer()) 541c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->mask_layer()->SavePaintProperties(); 542c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) 543c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->replica_layer()->mask_layer()->SavePaintProperties(); 544c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 545c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 5472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool SubtreeShouldRenderToSeparateSurface( 5482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 5492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool axis_aligned_with_respect_to_parent) { 5502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 5512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A layer and its descendants should render onto a new RenderSurfaceImpl if 5522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // any of these rules hold: 5532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 5542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 555b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // The root layer owns a render surface, but it never acts as a contributing 556b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // surface to another render target. Compositor features that are applied via 557b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // a contributing surface can not be applied to the root layer. In order to 558b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // use these effects, another child of the root would need to be introduced 559b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // in order to act as a contributing surface to the root layer's surface. 560b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool is_root = IsRootLayer(layer); 561c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 5622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer uses a mask. 563b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->mask_layer()) { 564b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 566b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer has a reflection. 569b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->replica_layer()) { 570b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 572b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer uses a CSS filter. 57568043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) { 576b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 578b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 5792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) int num_descendants_that_draw_content = 5812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_properties().num_descendants_that_draw_content; 5822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5835d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // If the layer flattens its subtree, but it is treated as a 3D object by its 5845d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // parent (i.e. parent participates in a 3D rendering context). 5855d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (LayerIsInExisting3DRenderingContext(layer) && 5865d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) layer->should_flatten_transform() && 5872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content > 0) { 5882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 5892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 590c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface flattening", 591c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 592b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 5932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 5942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 5952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 596f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // If the layer has blending. 597f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // TODO(rosca): this is temporary, until blending is implemented for other 598f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // types of quads than RenderPassDrawQuad. Layers having descendants that draw 599f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // content will still create a separate rendering surface. 600f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (!layer->uses_default_blend_mode()) { 601f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_INSTANT0( 602f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "cc", 603f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface blending", 604f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 605f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) DCHECK(!is_root); 606f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return true; 607f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 608f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 6092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer clips its descendants but it is not axis-aligned with respect 6102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to its parent. 6112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool layer_clips_external_content = 6122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerClipsSubtree(layer) || layer->HasDelegatedContent(); 6132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer_clips_external_content && !axis_aligned_with_respect_to_parent && 6144e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content > 0) { 6152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 6162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 617c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface clipping", 618c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 619b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 6232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer has some translucency and does not have a preserves-3d 6242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform style. This condition only needs a render surface if two or more 6252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers in the subtree overlap. But checking layer overlaps is unnecessarily 6262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // costly so instead we conservatively create a surface whenever at least two 6272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers draw content for this subtree. 6282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool at_least_two_layers_in_subtree_draw_content = 6292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content > 0 && 6302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer->DrawsContent() || num_descendants_that_draw_content > 1); 6312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 6325d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->opacity() != 1.f && layer->should_flatten_transform() && 6332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) at_least_two_layers_in_subtree_draw_content) { 6342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) TRACE_EVENT_INSTANT0( 6352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "cc", 636c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface opacity", 637c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 638b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) DCHECK(!is_root); 6392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 6402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 6412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 642b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // The root layer should always have a render_surface. 643b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (is_root) 644b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 645b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 646b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // 647b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // These are allowed on the root surface, as they don't require the surface to 648b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // be used as a contributing surface in order to apply correctly. 649b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // 650b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 651f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // If the layer has isolation. 652f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // TODO(rosca): to be optimized - create separate rendering surface only when 653f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // the blending descendants might have access to the content behind this layer 654f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // (layer has transparent background or descendants overflow). 655f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // https://code.google.com/p/chromium/issues/detail?id=301738 656f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->is_root_for_isolated_group()) { 657f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_INSTANT0( 658f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "cc", 659f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface isolation", 660f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) TRACE_EVENT_SCOPE_THREAD); 661f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) return true; 662f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 663f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 664b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If we force it. 665b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (layer->force_render_surface()) 666b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 667b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 668b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If we'll make a copy of the layer's contents. 66990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (layer->HasCopyRequest()) 670b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) return true; 671b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 6722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 6732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 6742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 675c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// This function returns a translation matrix that can be applied on a vector 676c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// that's in the layer's target surface coordinate, while the position offset is 677c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)// specified in some ancestor layer's coordinate. 678c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)gfx::Transform ComputeSizeDeltaCompensation( 679c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* layer, 680c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* container, 6815d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& position_offset) { 682c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform result_transform; 683c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 684c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // To apply a translate in the container's layer space, 685c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the following steps need to be done: 686c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 1a. transform from target surface space to the container's target 687c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // surface space 688c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 1b. transform from container's target surface space to the 689c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // container's layer space 690c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 2. apply the compensation 691c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Step 3. transform back to target surface space 692c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 693c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform target_surface_space_to_container_layer_space; 694c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Calculate step 1a 695868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerImpl* container_target_surface = container->render_target(); 696c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) for (LayerImpl* current_target_surface = NextTargetSurface(layer); 697c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface && 698c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface != container_target_surface; 699c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface = NextTargetSurface(current_target_surface)) { 700c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note: Concat is used here to convert the result coordinate space from 701c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // current render surface to the next render surface. 702c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) target_surface_space_to_container_layer_space.ConcatTransform( 703c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) current_target_surface->render_surface()->draw_transform()); 704c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 705c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Calculate step 1b 706868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) gfx::Transform container_layer_space_to_container_target_surface_space = 707868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container->draw_transform(); 708868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container_layer_space_to_container_target_surface_space.Scale( 709868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container->contents_scale_x(), container->contents_scale_y()); 710868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 711868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) gfx::Transform container_target_surface_space_to_container_layer_space; 712868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) if (container_layer_space_to_container_target_surface_space.GetInverse( 713868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) &container_target_surface_space_to_container_layer_space)) { 714868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Note: Again, Concat is used to conver the result coordinate space from 715868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // the container render surface to the container layer. 716868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) target_surface_space_to_container_layer_space.ConcatTransform( 717868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) container_target_surface_space_to_container_layer_space); 718c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 719c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 720c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 3 721c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform container_layer_space_to_target_surface_space; 722c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (target_surface_space_to_container_layer_space.GetInverse( 723c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) &container_layer_space_to_target_surface_space)) { 724c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.PreconcatTransform( 725c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) container_layer_space_to_target_surface_space); 726c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } else { 727eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // TODO(shawnsingh): A non-invertible matrix could still make meaningful 728eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // projection. For example ScaleZ(0) is non-invertible but the layer is 729eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // still visible. 730c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return gfx::Transform(); 731c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) } 732c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 733c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 2 734c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.Translate(position_offset.x(), position_offset.y()); 735c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 736c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply step 1 737c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) result_transform.PreconcatTransform( 738c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) target_surface_space_to_container_layer_space); 739c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 740c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return result_transform; 741c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 742c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 743c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ApplyPositionAdjustment( 744c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) Layer* layer, 745c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) Layer* container, 746c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const gfx::Transform& scroll_compensation, 747c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform* combined_transform) {} 748c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)void ApplyPositionAdjustment( 749c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* layer, 750c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImpl* container, 751c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const gfx::Transform& scroll_compensation, 752c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Transform* combined_transform) { 753c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (!layer->position_constraint().is_fixed_position()) 754c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return; 755c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 756c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Special case: this layer is a composited fixed-position layer; we need to 757c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // explicitly compensate for all ancestors' nonzero scroll_deltas to keep 758c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // this layer fixed correctly. 759c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note carefully: this is Concat, not Preconcat 760c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // (current_scroll_compensation * combined_transform). 761c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform->ConcatTransform(scroll_compensation); 762c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 763c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // For right-edge or bottom-edge anchored fixed position layers, 764c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the layer should relocate itself if the container changes its size. 765c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) bool fixed_to_right_edge = 766c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->position_constraint().is_fixed_to_right_edge(); 767c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) bool fixed_to_bottom_edge = 768c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer->position_constraint().is_fixed_to_bottom_edge(); 769a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) gfx::Vector2dF position_offset = container->FixedContainerSizeDelta(); 770c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) position_offset.set_x(fixed_to_right_edge ? position_offset.x() : 0); 771c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) position_offset.set_y(fixed_to_bottom_edge ? position_offset.y() : 0); 772c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) if (position_offset.IsZero()) 773c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) return; 774c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 775c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Note: Again, this is Concat. The compensation matrix will be applied on 776c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // the vector in target surface space. 777c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform->ConcatTransform( 778c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ComputeSizeDeltaCompensation(layer, container, position_offset)); 779c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles)} 780c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 7812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationForThisLayer( 7822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* scrolling_layer, 7831e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& parent_matrix, 7845d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 7852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // For every layer that has non-zero scroll_delta, we have to compute a 7862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform that can undo the scroll_delta translation. In particular, we 7872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // want this matrix to premultiply a fixed-position layer's parent_matrix, so 7882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // we design this transform in three steps as follows. The steps described 7892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here apply from right-to-left, so Step 1 would be the right-most matrix: 7902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 7912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 1. transform from target surface space to the exact space where 7922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // scroll_delta is actually applied. 7939ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // -- this is inverse of parent_matrix 7942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 2. undo the scroll_delta 7952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // -- this is just a translation by scroll_delta. 7962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 3. transform back to target surface space. 7979ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // -- this transform is the parent_matrix 7982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 7992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // These steps create a matrix that both start and end in target surface 8002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. So this matrix can pre-multiply any fixed-position layer's 8012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw_transform to undo the scroll_deltas -- as long as that fixed position 8022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer is fixed onto the same render_target as this scrolling_layer. 8032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8059ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch gfx::Transform scroll_compensation_for_this_layer = parent_matrix; // Step 3 8062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer.Translate( 807424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.x(), 808424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.y()); // Step 2 8092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8109ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch gfx::Transform inverse_parent_matrix(gfx::Transform::kSkipInitialization); 8119ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch if (!parent_matrix.GetInverse(&inverse_parent_matrix)) { 8122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 8132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 8142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 8152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer.PreconcatTransform( 8169ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch inverse_parent_matrix); // Step 1 8172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return scroll_compensation_for_this_layer; 8182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationMatrixForChildren( 8212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Layer* current_layer, 8222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& current_parent_matrix, 8231e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& current_scroll_compensation, 8245d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 8252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The main thread (i.e. Layer) does not need to worry about scroll 8262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // compensation. So we can just return an identity matrix here. 8272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return gfx::Transform(); 8282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)gfx::Transform ComputeScrollCompensationMatrixForChildren( 8312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer, 8322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& parent_matrix, 8331e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const gfx::Transform& current_scroll_compensation_matrix, 8345d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::Vector2dF& scroll_delta) { 8352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // "Total scroll compensation" is the transform needed to cancel out all 8362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // scroll_delta translations that occurred since the nearest container layer, 8372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // even if there are render_surfaces in-between. 8382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // There are some edge cases to be aware of, that are not explicit in the 8402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // code: 8412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that is both a fixed-position and container should not be its 8422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // own container, instead, that means it is fixed to an ancestor, and is a 8432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // container for any fixed-position descendants. 8442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that is a fixed-position container and has a render_surface 8452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // should behave the same as a container without a render_surface, the 8462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surface is irrelevant in that case. 8472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - A layer that does not have an explicit container is simply fixed to the 8482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // viewport. (i.e. the root render_surface.) 8492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // - If the fixed-position layer has its own render_surface, then the 8502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surface is the one who gets fixed. 8512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This function needs to be called AFTER layers create their own 8532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render_surfaces. 8542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 8552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8564e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // Scroll compensation restarts from identity under two possible conditions: 8574e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - the current layer is a container for fixed-position descendants 8584e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // - the current layer is fixed-position itself, so any fixed-position 8594e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // descendants are positioned with respect to this layer. Thus, any 8604e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // fixed position descendants only need to compensate for scrollDeltas 8614e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // that occur below this layer. 8624e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool current_layer_resets_scroll_compensation_for_descendants = 8634e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->IsContainerForFixedPositionLayers() || 8644e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer->position_constraint().is_fixed_position(); 8654e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) 8662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Avoid the overheads (including stack allocation and matrix 8672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // initialization/copy) if we know that the scroll compensation doesn't need 8682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to be reset or adjusted. 8694e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!current_layer_resets_scroll_compensation_for_descendants && 870424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) scroll_delta.IsZero() && !layer->render_surface()) 8712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return current_scroll_compensation_matrix; 8722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Start as identity matrix. 8742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform next_scroll_compensation_matrix; 8752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8764e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // If this layer does not reset scroll compensation, then it inherits the 8774e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // existing scroll compensations. 8784e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (!current_layer_resets_scroll_compensation_for_descendants) 8792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix = current_scroll_compensation_matrix; 8802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the current layer has a non-zero scroll_delta, then we should compute 8822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // its local scroll compensation and accumulate it to the 8832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // next_scroll_compensation_matrix. 884424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!scroll_delta.IsZero()) { 8852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform scroll_compensation_for_this_layer = 886c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ComputeScrollCompensationForThisLayer( 8871e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) layer, parent_matrix, scroll_delta); 8882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix.PreconcatTransform( 8892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) scroll_compensation_for_this_layer); 8902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 8912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the layer created its own render_surface, we have to adjust 8932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // next_scroll_compensation_matrix. The adjustment allows us to continue 8942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // using the scroll compensation on the next surface. 8952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 1 (right-most in the math): transform from the new surface to the 8962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // original ancestor surface 8972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 2: apply the scroll compensation 8982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Step 3: transform back to the new surface. 8992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->render_surface() && 9002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !next_scroll_compensation_matrix.IsIdentity()) { 9012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_surface_draw_transform( 9022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 9032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->render_surface()->draw_transform().GetInverse( 9042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_surface_draw_transform)) { 9052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 9062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 9072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) next_scroll_compensation_matrix = 9092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) inverse_surface_draw_transform * next_scroll_compensation_matrix * 9102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->draw_transform(); 9112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return next_scroll_compensation_matrix; 9142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 917c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateContentsScale( 918c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerType* layer, 919c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float contents_scale, 920c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float device_scale_factor, 921c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float page_scale_factor, 922c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale, 923c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool animating_transform_to_screen) { 9242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->CalculateContentsScale(contents_scale, 925b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 926b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 927c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 9282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen, 9292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().contents_scale_x, 9302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().contents_scale_y, 9312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &layer->draw_properties().content_bounds); 9322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* mask_layer = layer->mask_layer(); 9342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (mask_layer) { 9352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer->CalculateContentsScale( 9362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) contents_scale, 937b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 938b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 939c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 9402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen, 9412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().contents_scale_x, 9422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().contents_scale_y, 9432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &mask_layer->draw_properties().content_bounds); 9442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* replica_mask_layer = 9472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL; 9482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (replica_mask_layer) { 9492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_layer->CalculateContentsScale( 9502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) contents_scale, 951b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 952b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 953c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 9542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen, 9552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().contents_scale_x, 9562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().contents_scale_y, 9572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &replica_mask_layer->draw_properties().content_bounds); 9582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void UpdateLayerContentsScale( 9622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer, 963b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool can_adjust_raster_scale, 964c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale, 9652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float device_scale_factor, 9662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float page_scale_factor, 967c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale, 9682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen) { 969c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) CalculateContentsScale(layer, 970c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale, 971b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 972b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 973c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 974c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) animating_transform_to_screen); 9752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 9762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void UpdateLayerContentsScale( 9782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Layer* layer, 979b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool can_adjust_raster_scale, 980c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale, 9812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float device_scale_factor, 9822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float page_scale_factor, 983c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale, 9842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen) { 985b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (can_adjust_raster_scale) { 986c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_raster_scale = 987c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale / (device_scale_factor * page_scale_factor); 9882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 989b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) bool need_to_set_raster_scale = layer->raster_scale_is_unknown(); 9902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If we've previously saved a raster_scale but the ideal changes, things 9922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // are unpredictable and we should just use 1. 993b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (!need_to_set_raster_scale && layer->raster_scale() != 1.f && 994b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ideal_raster_scale != layer->raster_scale()) { 9952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ideal_raster_scale = 1.f; 9962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) need_to_set_raster_scale = true; 9972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 9982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (need_to_set_raster_scale) { 10002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool use_and_save_ideal_scale = 10012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ideal_raster_scale >= 1.f && !animating_transform_to_screen; 1002b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (use_and_save_ideal_scale) 1003b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) layer->set_raster_scale(ideal_raster_scale); 10042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 10062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1007b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) float raster_scale = 1.f; 1008b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (!layer->raster_scale_is_unknown()) 1009b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) raster_scale = layer->raster_scale(); 1010b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 1011a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) gfx::Size old_content_bounds = layer->content_bounds(); 1012a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) float old_contents_scale_x = layer->contents_scale_x(); 1013a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) float old_contents_scale_y = layer->contents_scale_y(); 10142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1015c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float contents_scale = raster_scale * device_scale_factor * page_scale_factor; 1016b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) CalculateContentsScale(layer, 1017b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) contents_scale, 1018b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) device_scale_factor, 1019b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) page_scale_factor, 1020c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch maximum_animation_contents_scale, 1021b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) animating_transform_to_screen); 1022a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) 1023a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) if (layer->content_bounds() != old_content_bounds || 1024a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->contents_scale_x() != old_contents_scale_x || 1025a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->contents_scale_y() != old_contents_scale_y) 1026a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) layer->SetNeedsPushProperties(); 10272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 10282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1029c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateAnimationContentsScale( 1030c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch Layer* layer, 1031c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale, 1032c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float ancestor_maximum_animation_contents_scale, 1033c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& parent_transform, 1034c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& combined_transform, 1035c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool* combined_is_animating_scale, 1036c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float* combined_maximum_animation_contents_scale) { 1037c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = false; 1038c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1039c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 1040c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1041c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic inline void CalculateAnimationContentsScale( 1042c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerImpl* layer, 1043c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale, 1044c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float ancestor_maximum_animation_contents_scale, 1045c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& ancestor_transform, 1046c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const gfx::Transform& combined_transform, 1047c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool* combined_is_animating_scale, 1048c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float* combined_maximum_animation_contents_scale) { 1049c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (ancestor_is_animating_scale && 1050c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ancestor_maximum_animation_contents_scale == 0.f) { 1051c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We've already failed to compute a maximum animated scale at an 1052c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // ancestor, so we'll continue to fail. 1053c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1054c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1055c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1056c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1057c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1058c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!combined_transform.IsScaleOrTranslation()) { 1059c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // Computing maximum animated scale in the presence of 1060c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // non-scale/translation transforms isn't supported. 1061c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1062c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1063c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1064c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1065c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1066c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We currently only support computing maximum scale for combinations of 1067c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // scales and translations. We treat all non-translations as potentially 1068c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // affecting scale. Animations that include non-translation/scale components 1069c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // will cause the computation of MaximumScale below to fail. 1070c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool layer_is_animating_scale = 1071c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch !layer->layer_animation_controller()->HasOnlyTranslationTransforms(); 1072c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1073c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer_is_animating_scale && !ancestor_is_animating_scale) { 1074c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1075c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = false; 1076c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1077c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1078c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1079c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // We don't attempt to accumulate animation scale from multiple nodes, 1080c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // because of the risk of significant overestimation. For example, one node 1081c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // may be increasing scale from 1 to 10 at the same time as a descendant is 1082c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // decreasing scale from 10 to 1. Naively combining these scales would produce 1083c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // a scale of 100. 1084c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (layer_is_animating_scale && ancestor_is_animating_scale) { 1085c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1086c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1087c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1088c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1089c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1090c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // At this point, we know either the layer or an ancestor, but not both, 1091c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // is animating scale. 1092c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_is_animating_scale = true; 1093c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer_is_animating_scale) { 1094c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF layer_transform_scales = 1095c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(layer->transform(), 0.f); 1096c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 1097c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ancestor_maximum_animation_contents_scale * 1098c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(layer_transform_scales.x(), layer_transform_scales.y()); 1099c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1100c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1101c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1102c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float layer_maximum_animated_scale = 0.f; 1103c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (!layer->layer_animation_controller()->MaximumScale( 1104c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &layer_maximum_animated_scale)) { 1105c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 0.f; 1106c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch return; 1107c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1108c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF ancestor_transform_scales = 1109c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(ancestor_transform, 0.f); 1110c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch *combined_maximum_animation_contents_scale = 1111c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch layer_maximum_animated_scale * 1112c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(ancestor_transform_scales.x(), ancestor_transform_scales.y()); 1113c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 1114c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1115ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdochstatic inline RenderSurface* CreateOrReuseRenderSurface(Layer* layer) { 1116ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // The render surface should always be new on the main thread, as the 1117ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // RenderSurfaceLayerList should be a new empty list when given to 1118ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // CalculateDrawProperties. 1119ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch DCHECK(!layer->render_surface()); 1120ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->CreateRenderSurface(); 1121ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1122ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch} 1123ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 1124ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdochstatic inline RenderSurfaceImpl* CreateOrReuseRenderSurface(LayerImpl* layer) { 1125ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch if (!layer->render_surface()) { 1126ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->CreateRenderSurface(); 1127ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1128ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch } 1129ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 1130ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch layer->render_surface()->ClearLayerLists(); 1131ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch return layer->render_surface(); 1132ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch} 1133ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 11348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 11352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static inline void RemoveSurfaceForEarlyExit( 11362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer_to_remove, 11378bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* render_surface_layer_list) { 11382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer_to_remove->render_surface()); 11392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Technically, we know that the layer we want to remove should be 11402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // at the back of the render_surface_layer_list. However, we have had 11412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // bugs before that added unnecessary layers here 11422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes 11432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // things to crash. So here we proactively remove any additional 11442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layers from the end of the list. 11452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) while (render_surface_layer_list->back() != layer_to_remove) { 11462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->back()->ClearRenderSurface(); 11472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->pop_back(); 11482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 11492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove); 11502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->pop_back(); 11512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_to_remove->ClearRenderSurface(); 11522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 11532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 11547dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstruct PreCalculateMetaInformationRecursiveData { 11557dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool layer_or_descendant_has_copy_request; 1156424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) int num_unclipped_descendants; 11577dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 11587dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData() 1159424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) : layer_or_descendant_has_copy_request(false), 1160424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) num_unclipped_descendants(0) {} 11617dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 11627dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch void Merge(const PreCalculateMetaInformationRecursiveData& data) { 11637dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer_or_descendant_has_copy_request |= 11647dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch data.layer_or_descendant_has_copy_request; 1165424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) num_unclipped_descendants += 1166424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) data.num_unclipped_descendants; 11677dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch } 11687dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch}; 11697dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 11702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Recursively walks the layer tree to compute any information that is needed 11712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// before doing the main recursion. 11722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)template <typename LayerType> 11737dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdochstatic void PreCalculateMetaInformation( 11747dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch LayerType* layer, 11757dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData* recursive_data) { 11767dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool has_delegated_content = layer->HasDelegatedContent(); 11772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) int num_descendants_that_draw_content = 0; 11787dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 11790529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!layer->transform_is_invertible()) { 11800529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // Layers with singular transforms should not be drawn, the whole subtree 11810529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // can be skipped. 11820529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return; 11830529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch } 11840529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 11857dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (has_delegated_content) { 11867dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // Layers with delegated content need to be treated as if they have as 11877dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // many children as the number of layers they own delegated quads for. 11887dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // Since we don't know this number right now, we choose one that acts like 11897dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // infinity for our purposes. 11907dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch num_descendants_that_draw_content = 1000; 11917dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch } 11922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 11938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->draw_properties().sorted_for_recursion = false; 11948bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->draw_properties().has_child_with_a_scroll_parent = false; 11958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 1196424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_parent()) 1197424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants++; 1198424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 11992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (size_t i = 0; i < layer->children().size(); ++i) { 1200868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerType* child_layer = 1201868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) LayerTreeHostCommon::get_child_as_raw_ptr(layer->children(), i); 12022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12037dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData data_for_child; 12047dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformation(child_layer, &data_for_child); 12057dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12064e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content += child_layer->DrawsContent() ? 1 : 0; 12074e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) num_descendants_that_draw_content += 12084e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) child_layer->draw_properties().num_descendants_that_draw_content; 12097dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child_layer->scroll_parent()) 12118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->draw_properties().has_child_with_a_scroll_parent = true; 12127dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->Merge(data_for_child); 12132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 12142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1215424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->clip_children()) { 1216424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) int num_clip_children = layer->clip_children()->size(); 1217424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children); 1218424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants -= num_clip_children; 1219424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1220424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 12217dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch if (layer->HasCopyRequest()) 12227dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->layer_or_descendant_has_copy_request = true; 12237dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 12242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->draw_properties().num_descendants_that_draw_content = 12252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) num_descendants_that_draw_content; 1226424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer->draw_properties().num_unclipped_descendants = 1227424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) recursive_data->num_unclipped_descendants; 12287dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->draw_properties().layer_or_descendant_has_copy_request = 12297dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch recursive_data->layer_or_descendant_has_copy_request; 12302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 12312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static void RoundTranslationComponents(gfx::Transform* transform) { 123368043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) transform->matrix().set(0, 3, MathUtil::Round(transform->matrix().get(0, 3))); 123468043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) transform->matrix().set(1, 3, MathUtil::Round(transform->matrix().get(1, 3))); 12352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 12362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 12372385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochtemplate <typename LayerType> 12382385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochstruct SubtreeGlobals { 12392385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch LayerSorter* layer_sorter; 12402385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch int max_texture_size; 12412385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float device_scale_factor; 12422385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float page_scale_factor; 12431e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const LayerType* page_scale_application_layer; 12442385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool can_adjust_raster_scales; 12454e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool can_render_to_separate_surface; 12462385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch}; 12472385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12488bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template<typename LayerType> 12492385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdochstruct DataForRecursion { 12502385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The accumulated sequence of transforms a layer will use to determine its 12512385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // own draw transform. 12522385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform parent_matrix; 12532385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12542385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The accumulated sequence of transforms a layer will use to determine its 12552385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // own screen-space transform. 12562385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform full_hierarchy_matrix; 12572385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12582385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The transform that removes all scrolling that may have occurred between a 12592385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // fixed-position layer and its container, so that the layer actually does 12602385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // remain fixed. 12612385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform scroll_compensation_matrix; 12622385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12632385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // The ancestor that would be the container for any fixed-position / sticky 12642385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // layers. 12652385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch LayerType* fixed_container; 12662385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12672385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // This is the normal clip rect that is propagated from parent to child. 12682385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Rect clip_rect_in_target_space; 12692385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12702385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // When the layer's children want to compute their visible content rect, they 12712385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // want to know what their target surface's clip rect will be. BUT - they 12722385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // want to know this clip rect represented in their own target space. This 12732385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // requires inverse-projecting the surface's clip rect from the surface's 12742385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // render target space down to the surface's own space. Instead of computing 12752385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // this value redundantly for each child layer, it is computed only once 12762385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // while dealing with the parent layer, and then this precomputed value is 12772385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // passed down the recursion to the children that actually use it. 12782385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Rect clip_rect_of_target_surface_in_target_space; 12792385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 1280c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // The maximum amount by which this layer will be scaled during the lifetime 1281c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // of currently running animations. 1282c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float maximum_animation_contents_scale; 1283c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1284c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool ancestor_is_animating_scale; 12852385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool ancestor_clips_subtree; 12868bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* 1287f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface; 12882385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool in_subtree_of_page_scale_application_layer; 12892385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool subtree_can_use_lcd_text; 12902385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch bool subtree_is_visible_from_ancestor; 12912385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch}; 12922385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 12938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 12948bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static LayerType* GetChildContainingLayer(const LayerType& parent, 12958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* layer) { 12968bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (LayerType* ancestor = layer; ancestor; ancestor = ancestor->parent()) { 12978bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (ancestor->parent() == &parent) 12988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return ancestor; 12998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) NOTREACHED(); 13018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return 0; 13028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void AddScrollParentChain(std::vector<LayerType*>* out, 13068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent, 13078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* layer) { 13088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // At a high level, this function walks up the chain of scroll parents 13098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // recursively, and once we reach the end of the chain, we add the child 13108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // of |parent| containing each scroll ancestor as we unwind. The result is 13118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // an ordering of parent's children that ensures that scroll parents are 13128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visited before their descendants. 13138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Take for example this layer tree: 13148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13158bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + stacking_context 13168bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_child (1) 13178bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_parent_graphics_layer (*) 13188bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // | + scroll_parent_scrolling_layer 13198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // | + scroll_parent_scrolling_content_layer (2) 13208bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_graphics_layer (**) 13218bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_scrolling_layer 13228bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // + scroll_grandparent_scrolling_content_layer (3) 13238bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // The scroll child is (1), its scroll parent is (2) and its scroll 13258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // grandparent is (3). Note, this doesn't mean that (2)'s scroll parent is 13268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // (3), it means that (*)'s scroll parent is (3). We don't want our list to 13278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // look like [ (3), (2), (1) ], even though that does have the ancestor chain 13288bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // in the right order. Instead, we want [ (**), (*), (1) ]. That is, only want 13298bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // (1)'s siblings in the list, but we want them to appear in such an order 13308bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // that the scroll ancestors get visited in the correct order. 13318bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // 13328bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // So our first task at this step of the recursion is to determine the layer 13338bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // that we will potentionally add to the list. That is, the child of parent 13348bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // containing |layer|. 13358bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* child = GetChildContainingLayer(parent, layer); 13368bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child->draw_properties().sorted_for_recursion) 13378bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return; 13388bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13398bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (LayerType* scroll_parent = child->scroll_parent()) 13408bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) AddScrollParentChain(out, parent, scroll_parent); 13418bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) out->push_back(child); 13438bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().sorted_for_recursion = true; 13448bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13458bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13468bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13478bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static bool SortChildrenForRecursion(std::vector<LayerType*>* out, 13488bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent) { 13498bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) out->reserve(parent.children().size()); 13508bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) bool order_changed = false; 13518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < parent.children().size(); ++i) { 13528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* current = 13538bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerTreeHostCommon::get_child_as_raw_ptr(parent.children(), i); 13548bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (current->draw_properties().sorted_for_recursion) { 13568bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) order_changed = true; 13578bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) continue; 13588bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13598bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13608bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) AddScrollParentChain(out, parent, current); 13618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 13628bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13638bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DCHECK_EQ(parent.children().size(), out->size()); 13648bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) return order_changed; 13658bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13668bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13678bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void GetNewDescendantsStartIndexAndCount(LayerType* layer, 13698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* start_index, 13708bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* count) { 13718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *start_index = layer->draw_properties().index_of_first_descendants_addition; 13728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *count = layer->draw_properties().num_descendants_added; 13738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13758bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 13768bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void GetNewRenderSurfacesStartIndexAndCount(LayerType* layer, 13778bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* start_index, 13788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t* count) { 13798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *start_index = layer->draw_properties() 13808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) .index_of_first_render_surface_layer_list_addition; 13818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *count = layer->draw_properties().num_render_surfaces_added; 13828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 13838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType, 13858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename GetIndexAndCountType> 13868bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)static void SortLayerListContributions( 13878bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const LayerType& parent, 13888bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* unsorted, 13898bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t start_index_for_all_contributions, 13908bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) GetIndexAndCountType get_index_and_count) { 13918bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13928bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::LayerListType buffer; 13938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < parent.children().size(); ++i) { 13948bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerType* child = 13958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) LayerTreeHostCommon::get_child_as_raw_ptr(parent.children(), i); 13968bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 13978bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t start_index = 0; 13988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t count = 0; 13998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) get_index_and_count(child, &start_index, &count); 14008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t j = start_index; j < start_index + count; ++j) 14018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) buffer.push_back(unsorted->at(j)); 14028bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 14038bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14048bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DCHECK_EQ(buffer.size(), 14058bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) unsorted->size() - start_index_for_all_contributions); 14068bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14078bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) for (size_t i = 0; i < buffer.size(); ++i) 14088bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) (*unsorted)[i + start_index_for_all_contributions] = buffer[i]; 14098bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)} 14108bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 14112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// Recursively walks the layer tree starting at the given node and computes all 14122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)// the necessary transformations, clip rects, render surfaces, etc. 14138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles)template <typename LayerType> 14142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static void CalculateDrawPropertiesInternal( 14152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* layer, 14162385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch const SubtreeGlobals<LayerType>& globals, 14178bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) const DataForRecursion<LayerType>& data_from_ancestor, 14188bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* render_surface_layer_list, 14198bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType* layer_list, 1420424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerType> >* 1421424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state) { 14222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This function computes the new matrix transformations recursively for this 14232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer and all its descendants. It also computes the appropriate render 14242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surfaces. 14252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some important points to remember: 14262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 0. Here, transforms are notated in Matrix x Vector order, and in words we 14282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // describe what the transform does from left to right. 14292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 1. In our terminology, the "layer origin" refers to the top-left corner of 14312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // a layer, and the positive Y-axis points downwards. This interpretation is 14322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // valid because the orthographic projection applied at draw time flips the Y 14332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // axis appropriately. 14342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 2. The anchor point, when given as a PointF object, is specified in "unit 14362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer space", where the bounds of the layer map to [0, 1]. However, as a 14372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Transform object, the transform to the anchor point is specified in "layer 14382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space", where the bounds of the layer map to [bounds.width(), 14392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // bounds.height()]. 14402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 3. Definition of various transforms used: 14422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[parent] is the parent matrix, with respect to the nearest render 14432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surface, passed down recursively. 14442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[root] is the full hierarchy, with respect to the root, passed down 14462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // recursively. 14472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin] is the translation matrix from the parent's origin to 14492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this layer's origin. 14502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor] is the translation from the layer's origin to its 14522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // anchor point 14532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2center] is the translation from the layer's origin to its 14552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // center 14562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[layer] is the layer's matrix (applied at the anchor point) 14582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] is the ratio of a layer's content_bounds() to its 14602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Bounds(). 14612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Some composite transforms can help in understanding the sequence of 14632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transforms: 14642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // composite_layer_transform = Tr[origin2anchor] * M[layer] * 14652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor].inverse() 14662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 4. When a layer (or render surface) is drawn, it is drawn into a "target 14682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render surface". Therefore the draw transform does not necessarily 14692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform from screen space to local layer space. Instead, the draw 14702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform is the transform between the "target render surface space" and 14712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // local layer space. Note that render surfaces, except for the root, also 14722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw themselves into a different target render surface, and so their draw 14732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // transform and origin transforms are also described with respect to the 14742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // target. 14752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Using these definitions, then: 14772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The draw transform for the layer is: 14792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] = M[parent] * Tr[origin] * composite_layer_transform * 14802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] = M[parent] * Tr[layer->position() + anchor] * 14812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[layer] * Tr[anchor2origin] * S[layer2content] 14822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Interpreting the math left-to-right, this transforms from the 14842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's render surface to the origin of the layer in content space. 14852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The screen space transform is: 14872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[screenspace] = M[root] * Tr[origin] * composite_layer_transform * 14882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[layer2content] 14892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // = M[root] * Tr[layer->position() + anchor] * M[layer] 14902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // * Tr[anchor2origin] * S[layer2content] 14912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Interpreting the math left-to-right, this transforms from the root 14932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // render surface's content space to the origin of the layer in content 14942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. 14952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 14962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The transform hierarchy that is passed on to children (i.e. the child's 14972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // parent_matrix) is: 14982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[parent]_for_child = M[parent] * Tr[origin] * 14995d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // composite_layer_transform 15002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // = M[parent] * Tr[layer->position() + anchor] * 15015d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // M[layer] * Tr[anchor2origin] 15022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and a similar matrix for the full hierarchy with respect to the 15042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // root. 15052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Finally, note that the final matrix used by the shader for the layer is P * 15072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] * S . This final product is computed in drawTexturedQuad(), where: 15082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // P is the projection matrix 15092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S is the scale adjustment (to scale up a canonical quad to the 15102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's size) 15112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // When a render surface has a replica layer, that layer's transform is used 15132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to draw a second copy of the surface. gfx::Transforms named here are 15142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // relative to the surface, unless they specify they are relative to the 15152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // replica layer. 15162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // We will denote a scale by device scale S[deviceScale] 15182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The render surface draw transform to its target surface origin is: 15202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[surfaceDraw] = M[owningLayer->Draw] 15212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The render surface origin transform to its the root (screen space) origin 15232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // is: 15242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[surface2root] = M[owningLayer->screenspace] * 15252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // S[deviceScale].inverse() 15262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The replica draw transform to its target surface origin is: 15282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * 15292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[replica->position() + replica->anchor()] * Tr[replica] * 15302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[origin2anchor].inverse() * S[contents_scale].inverse() 15312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The replica draw transform to the root (screen space) origin is: 15332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[replica2root] = M[surface2root] * Tr[replica->position()] * 15342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Tr[replica] * Tr[origin2anchor].inverse() 15352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 15362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1537c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // It makes no sense to have a non-unit page_scale_factor without specifying 1538c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // which layer roots the subtree the scale is applied to. 15392385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch DCHECK(globals.page_scale_application_layer || 15402385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch (globals.page_scale_factor == 1.f)); 1541c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 15428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<LayerType> data_for_children; 15438bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* 1544f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface = 1545f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) data_from_ancestor.nearest_occlusion_immune_ancestor_surface; 15462385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.in_subtree_of_page_scale_application_layer = 15472385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.in_subtree_of_page_scale_application_layer; 15482385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.subtree_can_use_lcd_text = 15492385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_can_use_lcd_text; 15502385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 15515d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Layers that are marked as hidden will hide themselves and their subtree. 15525d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Exception: Layers with copy requests, whether hidden or not, must be drawn 15535d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // anyway. In this case, we will inform their subtree they are visible to get 15545d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // the right results. 15555d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const bool layer_is_visible = 15562385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_is_visible_from_ancestor && 15572385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch !layer->hide_layer_and_subtree(); 15585d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const bool layer_is_drawn = layer_is_visible || layer->HasCopyRequest(); 15597dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 15602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer cannot skip CalcDrawProperties. 15615d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_drawn)) { 1562424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) 1563424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer->ClearRenderSurface(); 15642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 1565424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1566424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1567424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // We need to circumvent the normal recursive flow of information for clip 1568424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // children (they don't inherit their direct ancestor's clip information). 1569424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // This is unfortunate, and would be unnecessary if we were to formally 1570424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // separate the clipping hierarchy from the layer hierarchy. 1571424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree; 1572424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect ancestor_clip_rect_in_target_space = 1573424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) data_from_ancestor.clip_rect_in_target_space; 1574424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1575424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Update our clipping state. If we have a clip parent we will need to pull 1576424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // from the clip state cache rather than using the clip state passed from our 1577424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // immediate ancestor. 15788bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) UpdateClipRectsForClipChild<LayerType>( 1579424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer, &ancestor_clip_rect_in_target_space, &ancestor_clips_subtree); 15802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 15812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // As this function proceeds, these are the properties for the current 15822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer that actually get computed. To avoid unnecessary copies 15832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // (particularly for matrices), we do computations directly on these values 15842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // when possible. 15858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& layer_draw_properties = layer->draw_properties(); 15862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1587a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch gfx::Rect clip_rect_in_target_space; 1588a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch bool layer_or_ancestor_clips_descendants = false; 15892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 15902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This value is cached on the stack so that we don't have to inverse-project 15912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the surface's clip rect redundantly for every layer. This value is the 1592a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // same as the target surface's clip rect, except that instead of being 1593a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // described in the target surface's target's space, it is described in the 1594a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // current render target's space. 1595a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch gfx::Rect clip_rect_of_target_surface_in_target_space; 15962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 15972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float accumulated_draw_opacity = layer->opacity(); 15982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_opacity_to_target = layer->OpacityIsAnimating(); 15992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_opacity_to_screen = animating_opacity_to_target; 16002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) { 16012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) accumulated_draw_opacity *= layer->parent()->draw_opacity(); 16022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_target |= layer->parent()->draw_opacity_is_animating(); 16032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen |= 16042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->screen_space_opacity_is_animating(); 16052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_target = layer->TransformIsAnimating(); 16082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool animating_transform_to_screen = animating_transform_to_target; 16092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->parent()) { 16102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target |= 16112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->draw_transform_is_animating(); 16122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen |= 16132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->parent()->screen_space_transform_is_animating(); 16142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Size bounds = layer->bounds(); 16172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::PointF anchor_point = layer->anchor_point(); 1618424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Vector2dF scroll_offset = GetEffectiveTotalScrollOffset(layer); 1619424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::PointF position = layer->position() - scroll_offset; 16202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16212385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch gfx::Transform combined_transform = data_from_ancestor.parent_matrix; 16222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->transform().IsIdentity()) { 16232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2anchor] 16242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.Translate3d( 16252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) position.x() + anchor_point.x() * bounds.width(), 16262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) position.y() + anchor_point.y() * bounds.height(), 16272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->anchor_point_z()); 16282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2anchor] * M[layer] 16292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.PreconcatTransform(layer->transform()); 16302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin] 16312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.Translate3d(-anchor_point.x() * bounds.width(), 16322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) -anchor_point.y() * bounds.height(), 16332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) -layer->anchor_point_z()); 16342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 16352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.Translate(position.x(), position.y()); 16362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 16381e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF effective_scroll_delta = GetEffectiveScrollDelta(layer); 16392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!animating_transform_to_target && layer->scrollable() && 16402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) combined_transform.IsScaleOrTranslation()) { 16412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Align the scrollable layer's position to screen space pixels to avoid 16422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // blurriness. To avoid side-effects, do this only if the transform is 16432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // simple. 16441e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF previous_translation = combined_transform.To2dTranslation(); 16452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RoundTranslationComponents(&combined_transform); 16461e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) gfx::Vector2dF current_translation = combined_transform.To2dTranslation(); 16471e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 16481e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // This rounding changes the scroll delta, and so must be included 1649e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // in the scroll compensation matrix. The scaling converts from physical 1650e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // coordinates to the scroll delta's CSS coordinates (using the parent 1651e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // matrix instead of combined transform since scrolling is applied before 1652e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // the layer's transform). For example, if we have a total scale factor of 1653e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // 3.0, then 1 physical pixel is only 1/3 of a CSS pixel. 1654e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch gfx::Vector2dF parent_scales = MathUtil::ComputeTransform2dScaleComponents( 1655e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch data_from_ancestor.parent_matrix, 1.f); 1656e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch effective_scroll_delta -= 1657e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch gfx::ScaleVector2d(current_translation - previous_translation, 1658e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch 1.f / parent_scales.x(), 1659e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch 1.f / parent_scales.y()); 16602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 16612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1662c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Apply adjustment from position constraints. 16632385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch ApplyPositionAdjustment(layer, data_from_ancestor.fixed_container, 16642385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.scroll_compensation_matrix, &combined_transform); 1665c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) 1666c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch bool combined_is_animating_scale = false; 1667c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float combined_maximum_animation_contents_scale = 0.f; 1668c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch if (globals.can_adjust_raster_scales) { 1669c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch CalculateAnimationContentsScale( 1670c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch layer, 1671c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.ancestor_is_animating_scale, 1672c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.maximum_animation_contents_scale, 1673c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.parent_matrix, 1674c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_transform, 1675c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &combined_is_animating_scale, 1676c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch &combined_maximum_animation_contents_scale); 1677c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch } 1678c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_children.ancestor_is_animating_scale = combined_is_animating_scale; 1679c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_children.maximum_animation_contents_scale = 1680c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_maximum_animation_contents_scale; 1681c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 1682c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // Compute the 2d scale components of the transform hierarchy up to the target 1683c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) // surface. From there, we can decide on a contents scale for the layer. 16842385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch float layer_scale_factors = globals.device_scale_factor; 16852385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch if (data_from_ancestor.in_subtree_of_page_scale_application_layer) 16862385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_scale_factors *= globals.page_scale_factor; 1687c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) gfx::Vector2dF combined_transform_scales = 1688c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) MathUtil::ComputeTransform2dScaleComponents( 1689c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) combined_transform, 1690b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) layer_scale_factors); 1691b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 1692c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) float ideal_contents_scale = 16932385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales 1694b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ? std::max(combined_transform_scales.x(), 1695b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) combined_transform_scales.y()) 1696b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) : layer_scale_factors; 1697c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) UpdateLayerContentsScale( 1698c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) layer, 16992385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales, 1700c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) ideal_contents_scale, 17012385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.device_scale_factor, 1702c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_from_ancestor.in_subtree_of_page_scale_application_layer 1703c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ? globals.page_scale_factor 1704c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch : 1.f, 1705c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch combined_maximum_animation_contents_scale, 1706c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) animating_transform_to_screen); 17072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The draw_transform that gets computed below is effectively the layer's 17092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // draw_transform, unless the layer itself creates a render_surface. In that 17102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // case, the render_surface re-parents the transforms. 17112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform = combined_transform; 17122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // M[draw] = M[parent] * LT * S[layer2content] 171358537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) layer_draw_properties.target_space_transform.Scale( 171458537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) SK_MScalar1 / layer->contents_scale_x(), 171558537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) SK_MScalar1 / layer->contents_scale_y()); 17162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The layer's screen_space_transform represents the transform between root 17182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer's "screen space" and local content space. 17192385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_draw_properties.screen_space_transform = 17202385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.full_hierarchy_matrix; 17215d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->should_flatten_transform()) 17222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform.FlattenTo2d(); 17232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform.PreconcatTransform 17242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer_draw_properties.target_space_transform); 17252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Adjusting text AA method during animation may cause repaints, which in-turn 17272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // causes jank. 17282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool adjust_text_aa = 17292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !animating_opacity_to_screen && !animating_transform_to_screen; 17302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // To avoid color fringing, LCD text should only be used on opaque layers with 17312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // just integral translation. 17322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool layer_can_use_lcd_text = 17332385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.subtree_can_use_lcd_text && 17342385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch accumulated_draw_opacity == 1.f && 17352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform. 17362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) IsIdentityOrIntegerTranslation(); 17372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::RectF content_rect(layer->content_bounds()); 17392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // full_hierarchy_matrix is the matrix that transforms objects between screen 17412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space (except projection matrix) and the most recent RenderSurfaceImpl's 17422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space. next_hierarchy_matrix will only change if this layer uses a new 17432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // RenderSurfaceImpl, otherwise remains the same. 17442385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.full_hierarchy_matrix = 17452385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.full_hierarchy_matrix; 17462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1747b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // If the subtree will scale layer contents by the transform hierarchy, then 1748b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // we should scale things into the render surface by the transform hierarchy 1749b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) // to take advantage of that. 1750b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) gfx::Vector2dF render_surface_sublayer_scale = 17512385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.can_adjust_raster_scales 1752b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) ? combined_transform_scales 1753b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) : gfx::Vector2dF(layer_scale_factors, layer_scale_factors); 17542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17554e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) bool render_to_separate_surface; 17564e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (globals.can_render_to_separate_surface) { 17574e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) render_to_separate_surface = SubtreeShouldRenderToSeparateSurface( 17584e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) layer, combined_transform.Preserves2dAxisAlignment()); 17594e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } else { 17604e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) render_to_separate_surface = IsRootLayer(layer); 17614e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) } 17624e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) if (render_to_separate_surface) { 17632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Check back-face visibility before continuing with this surface and its 17642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // subtree 17652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->double_sided() && TransformToParentIsKnown(layer) && 1766424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) IsSurfaceBackFaceVisible(layer, combined_transform)) { 1767424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer->ClearRenderSurface(); 17682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 1769424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 17702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 17718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* render_surface = 17728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) CreateOrReuseRenderSurface(layer); 17732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1774b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) if (IsRootLayer(layer)) { 1775868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The root layer's render surface size is predetermined and so the root 1776868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // layer can't directly support non-identity transforms. It should just 1777868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // forward top-level transforms to the rest of the tree. 17782385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix = combined_transform; 17797dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 17807dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // The root surface does not contribute to any other surface, it has no 17817dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // target. 17827dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->render_surface()->set_contributes_to_drawn_surface(false); 1783868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) } else { 1784868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The owning layer's draw transform has a scale from content to layer 1785868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // space which we do not want; so here we use the combined_transform 1786868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // instead of the draw_transform. However, we do need to add a different 1787868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale factor that accounts for the surface's pixel dimensions. 1788868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) combined_transform.Scale(1.0 / render_surface_sublayer_scale.x(), 1789868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1.0 / render_surface_sublayer_scale.y()); 1790868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface->SetDrawTransform(combined_transform); 1791868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1792868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // The owning layer's transform was re-parented by the surface, so the 1793868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // layer's new draw_transform only needs to scale the layer to surface 1794868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // space. 1795868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) layer_draw_properties.target_space_transform.MakeIdentity(); 1796868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) layer_draw_properties.target_space_transform. 1797868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) Scale(render_surface_sublayer_scale.x() / layer->contents_scale_x(), 1798868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface_sublayer_scale.y() / layer->contents_scale_y()); 1799868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 1800868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // Inside the surface's subtree, we scale everything to the owning layer's 1801868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale. The sublayer matrix transforms layer rects into target surface 1802868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // content space. Conceptually, all layers in the subtree inherit the 1803868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // scale at the point of the render surface in the transform hierarchy, 1804868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // but we apply it explicitly to the owning layer and the remainder of the 1805868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) // subtree independently. 18062385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch DCHECK(data_for_children.parent_matrix.IsIdentity()); 18072385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix.Scale(render_surface_sublayer_scale.x(), 1808868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) render_surface_sublayer_scale.y()); 18097dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch 18105d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Even if the |layer_is_drawn|, it only contributes to a drawn surface 18115d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // when the |layer_is_visible|. 18127dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch layer->render_surface()->set_contributes_to_drawn_surface( 18132385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch layer_is_visible); 1814b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) } 1815b2df76ea8fec9e32f6f3718986dba0d95315b29cTorne (Richard Coles) 18162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The opacity value is moved from the layer to its surface, so that the 18172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // entire subtree properly inherits opacity. 18182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetDrawOpacity(accumulated_draw_opacity); 18192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetDrawOpacityIsAnimating(animating_opacity_to_target); 18202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_target = false; 18212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity = 1.f; 18222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity_is_animating = animating_opacity_to_target; 18232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_opacity_is_animating = 18242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen; 18252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetTargetSurfaceTransformsAreAnimating( 18272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target); 18282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetScreenSpaceTransformsAreAnimating( 18292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen); 18302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target = false; 18312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform_is_animating = 18322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target; 18332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform_is_animating = 18342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen; 18352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Update the aggregate hierarchy matrix to include the transform of the 18372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // newly created RenderSurfaceImpl. 18382385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.full_hierarchy_matrix.PreconcatTransform( 18392385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch render_surface->draw_transform()); 18402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->mask_layer()) { 18428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& mask_layer_draw_properties = 18432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->mask_layer()->draw_properties(); 18442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer_draw_properties.render_target = layer; 18452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) mask_layer_draw_properties.visible_content_rect = 18462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()); 18472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 18482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 18492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { 18508bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DrawProperties<LayerType>& replica_mask_draw_properties = 18512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->mask_layer()->draw_properties(); 18522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_draw_properties.render_target = layer; 18532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_mask_draw_properties.visible_content_rect = 18542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect(layer->content_bounds()); 18552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 18562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1857f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Ignore occlusion from outside the surface when surface contents need to 1858f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // be fully drawn. Layers with copy-request need to be complete. 1859f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // We could be smarter about layers with replica and exclude regions 1860f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // where both layer and the replica are occluded, but this seems like an 1861f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // overkill. The same is true for layers with filters that move pixels. 18622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(senorblanco): make this smarter for the SkImageFilter case (check 18632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // for pixel-moving filters) 1864f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->HasCopyRequest() || 1865f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->has_replica() || 1866f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->filters().HasReferenceFilter() || 1867f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->filters().HasFilterThatMovesPixels()) { 1868f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface = render_surface; 1869f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 1870f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) render_surface->SetNearestOcclusionImmuneAncestor( 1871f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface); 18722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1873424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = false; 1874424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) bool subtree_is_clipped_by_surface_bounds = false; 1875424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree) { 1876424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // It may be the layer or the surface doing the clipping of the subtree, 1877424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // but in either case, we'll be clipping to the projected clip rect of our 1878424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // ancestor. 18792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_surface_draw_transform( 18802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 18812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!render_surface->draw_transform().GetInverse( 18822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_surface_draw_transform)) { 18832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shawnsingh): Either we need to handle uninvertible transforms 18842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // here, or DCHECK that the transform is invertible. 18852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 1886424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 18875d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) gfx::Rect projected_surface_rect = MathUtil::ProjectEnclosingClippedRect( 18885d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) inverse_surface_draw_transform, ancestor_clip_rect_in_target_space); 1889424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1890424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer_draw_properties.num_unclipped_descendants > 0) { 1891424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // If we have unclipped descendants, we cannot count on the render 1892424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // surface's bounds clipping our subtree: the unclipped descendants 1893424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // could cause us to expand our bounds. In this case, we must rely on 1894424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // layer clipping for correctess. NB: since we can only encounter 1895424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // translations between a clip child and its clip parent, clipping is 1896424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // guaranteed to be exact in this case. 1897424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = true; 1898424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect_in_target_space = projected_surface_rect; 1899424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } else { 1900424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // The new render_surface here will correctly clip the entire subtree. 1901424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // So, we do not need to continue propagating the clipping state further 1902424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // down the tree. This way, we can avoid transforming clip rects from 1903424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // ancestor target surface space to current target surface space that 1904424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // could cause more w < 0 headaches. The render surface clip rect is 1905424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // expressed in the space where this surface draws, i.e. the same space 1906424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // as clip_rect_from_ancestor_in_ancestor_target_space. 1907424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) render_surface->SetClipRect(ancestor_clip_rect_in_target_space); 1908424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) clip_rect_of_target_surface_in_target_space = projected_surface_rect; 1909424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) subtree_is_clipped_by_surface_bounds = true; 1910424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1911424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1912424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1913424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(layer->render_surface()); 1914424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(!layer->parent() || layer->parent()->render_target() == 1915424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->back().render_target); 1916424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1917424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->push_back( 1918424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) AccumulatedSurfaceState<LayerType>(layer)); 1919424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 1920424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) render_surface->SetIsClipped(subtree_is_clipped_by_surface_bounds); 1921424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (!subtree_is_clipped_by_surface_bounds) { 19222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetClipRect(gfx::Rect()); 1923a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space = 19242385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.clip_rect_of_target_surface_in_target_space; 19252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the new render surface is drawn translucent or with a non-integral 19282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // translation then the subtree that gets drawn on this render surface 19292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // cannot use LCD text. 19302385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.subtree_can_use_lcd_text = layer_can_use_lcd_text; 19312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_layer_list->push_back(layer); 19332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 19342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->parent()); 19352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note: layer_draw_properties.target_space_transform is computed above, 19372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // before this if-else statement. 19382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.target_space_transform_is_animating = 19392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_target; 19402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_transform_is_animating = 19412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_transform_to_screen; 19422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity = accumulated_draw_opacity; 19432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.opacity_is_animating = animating_opacity_to_target; 19442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.screen_space_opacity_is_animating = 19452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) animating_opacity_to_screen; 19462385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_for_children.parent_matrix = combined_transform; 19472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->ClearRenderSurface(); 19492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers without render_surfaces directly inherit the ancestor's clip 19512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // status. 1952424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_or_ancestor_clips_descendants = ancestor_clips_subtree; 1953424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree) { 1954a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = 1955424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space; 1956a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch } 19572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The surface's cached clip rect value propagates regardless of what 19592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clipping goes on between layers here. 1960a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_of_target_surface_in_target_space = 19612385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch data_from_ancestor.clip_rect_of_target_surface_in_target_space; 19622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Layers that are not their own render_target will render into the target 19642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // of their nearest ancestor. 19652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.render_target = layer->parent()->render_target(); 19662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (adjust_text_aa) 19692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text; 19702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect rect_in_target_space = ToEnclosingRect( 19722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) MathUtil::MapClippedRect(layer->draw_transform(), content_rect)); 19732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 19742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerClipsSubtree(layer)) { 1975a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer_or_ancestor_clips_descendants = true; 1976424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (ancestor_clips_subtree && !layer->render_surface()) { 1977a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // A layer without render surface shares the same target as its ancestor. 1978a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = 1979424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space; 1980a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space.Intersect(rect_in_target_space); 19812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 1982a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch clip_rect_in_target_space = rect_in_target_space; 19832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 19852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1986424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Tell the layer the rect that it's clipped by. In theory we could use a 1987424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // tighter clip rect here (drawable_content_rect), but that actually does not 1988424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // reduce how much would be drawn, and instead it would create unnecessary 1989424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // changes to scissor state affecting GPU performance. Our clip information 1990424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // is used in the recursion below, so we must set it beforehand. 1991424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.is_clipped = layer_or_ancestor_clips_descendants; 1992424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer_or_ancestor_clips_descendants) { 1993424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.clip_rect = clip_rect_in_target_space; 1994424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } else { 1995424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Initialize the clip rect to a safe value that will not clip the 1996424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // layer, just in case clipping is still accidentally used. 1997424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer_draw_properties.clip_rect = rect_in_target_space; 1998424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 1999424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 20008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceListType& descendants = 20012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) (layer->render_surface() ? layer->render_surface()->layer_list() 20022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) : *layer_list); 20032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Any layers that are appended after this point are in the layer's subtree 20052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and should be included in the sorting process. 20062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) size_t sorting_start_index = descendants.size(); 20072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20085d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (!LayerShouldBeSkipped(layer, layer_is_drawn)) 20092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) descendants.push_back(layer); 20102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20118bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Any layers that are appended after this point may need to be sorted if we 20128bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visit the children out of order. 20138bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t render_surface_layer_list_child_sorting_start_index = 20148bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size(); 20158bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) size_t layer_list_child_sorting_start_index = descendants.size(); 20168bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20173551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (!layer->children().empty()) { 20183551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) if (layer == globals.page_scale_application_layer) { 20193551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.parent_matrix.Scale( 20203551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) globals.page_scale_factor, 20213551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) globals.page_scale_factor); 20223551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.in_subtree_of_page_scale_application_layer = true; 20233551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) } 20243551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 20253551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Flatten to 2D if the layer doesn't preserve 3D. 20265d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (layer->should_flatten_transform()) 20273551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.parent_matrix.FlattenTo2d(); 20283551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 20293551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.scroll_compensation_matrix = 20303551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) ComputeScrollCompensationMatrixForChildren( 20313551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer, 20323551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_from_ancestor.parent_matrix, 20331e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) data_from_ancestor.scroll_compensation_matrix, 20341e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) effective_scroll_delta); 20353551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.fixed_container = 20363551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer->IsContainerForFixedPositionLayers() ? 20373551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer : data_from_ancestor.fixed_container; 20383551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 20393551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.clip_rect_in_target_space = clip_rect_in_target_space; 20403551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.clip_rect_of_target_surface_in_target_space = 20413551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) clip_rect_of_target_surface_in_target_space; 20423551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) data_for_children.ancestor_clips_subtree = 20433551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) layer_or_ancestor_clips_descendants; 2044f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) data_for_children.nearest_occlusion_immune_ancestor_surface = 2045f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) nearest_occlusion_immune_ancestor_surface; 20465d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) data_for_children.subtree_is_visible_from_ancestor = layer_is_drawn; 20473551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) } 20482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 20498bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) std::vector<LayerType*> sorted_children; 20508bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) bool child_order_changed = false; 20518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (layer_draw_properties.has_child_with_a_scroll_parent) 20528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child_order_changed = SortChildrenForRecursion(&sorted_children, *layer); 20538bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (size_t i = 0; i < layer->children().size(); ++i) { 20558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // If one of layer's children has a scroll parent, then we may have to 20568bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // visit the children out of order. The new order is stored in 20578bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // sorted_children. Otherwise, we'll grab the child directly from the 20588bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // layer's list of children. 20592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerType* child = 20608bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer_draw_properties.has_child_with_a_scroll_parent 20618bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) ? sorted_children[i] 20628bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) : LayerTreeHostCommon::get_child_as_raw_ptr(layer->children(), i); 20638bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20648bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_descendants_addition = 20658bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) descendants.size(); 20668bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_render_surface_layer_list_addition = 20678bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size(); 20688bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20698bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) CalculateDrawPropertiesInternal<LayerType>(child, 20708bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) globals, 20718bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) data_for_children, 20728bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list, 20738bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &descendants, 20748bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) accumulated_surface_state); 2075424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (child->render_surface() && 2076424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) !child->render_surface()->content_rect().IsEmpty()) { 2077424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) descendants.push_back(child); 20782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 20798bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20808bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().num_descendants_added = 20818bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) descendants.size() - 20828bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().index_of_first_descendants_addition; 20838bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties().num_render_surfaces_added = 20848bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list->size() - 20858bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) child->draw_properties() 20868bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) .index_of_first_render_surface_layer_list_addition; 20878bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } 20888bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20898bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) // Add the unsorted layer list contributions, if necessary. 20908bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) if (child_order_changed) { 20918bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) SortLayerListContributions( 20928bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer, 20938bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list, 20948bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) render_surface_layer_list_child_sorting_start_index, 20958bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &GetNewRenderSurfacesStartIndexAndCount<LayerType>); 20968bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) 20978bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) SortLayerListContributions( 20988bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) *layer, 20998bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &descendants, 21008bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer_list_child_sorting_start_index, 21018bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &GetNewDescendantsStartIndexAndCount<LayerType>); 21022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2104424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // Compute the total drawable_content_rect for this subtree (the rect is in 2105424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) // target surface space). 2106424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) gfx::Rect local_drawable_content_rect_of_subtree = 2107424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->back().drawable_content_rect; 2108424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (layer->render_surface()) { 2109424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) DCHECK(accumulated_surface_state->back().render_target == layer); 2110424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state->pop_back(); 2111424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) } 2112424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) 21132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->render_surface() && !IsRootLayer(layer) && 21142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->layer_list().empty()) { 21152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RemoveSurfaceForEarlyExit(layer, render_surface_layer_list); 21162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 21172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the layer's drawable content rect (the rect is in target surface 21202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // space). 21212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.drawable_content_rect = rect_in_target_space; 2122a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch if (layer_or_ancestor_clips_descendants) { 2123f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer_draw_properties.drawable_content_rect.Intersect( 2124f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) clip_rect_in_target_space); 2125f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) } 2126f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) if (layer->DrawsContent()) { 2127f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) local_drawable_content_rect_of_subtree.Union( 2128f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer_draw_properties.drawable_content_rect); 21292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2131a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch // Compute the layer's visible content rect (the rect is in content space). 21322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_draw_properties.visible_content_rect = CalculateVisibleContentRect( 2133a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space); 21342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the remaining properties for the render surface, if the layer has 21362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // one. 21372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (IsRootLayer(layer)) { 21382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer's surface's content_rect is always the entire viewport. 21392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) DCHECK(layer->render_surface()); 2140a3f7b4e666c476898878fa745f637129375cd889Ben Murdoch layer->render_surface()->SetContentRect( 2141424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) ancestor_clip_rect_in_target_space); 21428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) } else if (layer->render_surface()) { 21438bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) typename LayerType::RenderSurfaceType* render_surface = 21448bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) layer->render_surface(); 21452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect clipped_content_rect = local_drawable_content_rect_of_subtree; 21462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Don't clip if the layer is reflected as the reflection shouldn't be 21482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clipped. If the layer is animating, then the surface's transform to 21492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // its target is not known on the main thread, and we should not use it 21502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to clip. 21512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!layer->replica_layer() && TransformToParentIsKnown(layer)) { 21522385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // Note, it is correct to use data_from_ancestor.ancestor_clips_subtree 21532385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // here, because we are looking at this layer's render_surface, not the 21542385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch // layer itself. 2155424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) if (render_surface->is_clipped() && !clipped_content_rect.IsEmpty()) { 21562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Rect surface_clip_rect = LayerTreeHostCommon::CalculateVisibleRect( 21572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->clip_rect(), 21582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect, 21592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->draw_transform()); 21602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.Intersect(surface_clip_rect); 21612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The RenderSurfaceImpl backing texture cannot exceed the maximum supported 21652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // texture size. 21662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.set_width( 21672385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch std::min(clipped_content_rect.width(), globals.max_texture_size)); 21682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) clipped_content_rect.set_height( 21692385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch std::min(clipped_content_rect.height(), globals.max_texture_size)); 21702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (clipped_content_rect.IsEmpty()) { 21722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RemoveSurfaceForEarlyExit(layer, render_surface_layer_list); 21732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 21742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 21752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2176f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Layers having a non-default blend mode will blend with the content 2177f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // inside its parent's render target. This render target should be 2178f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // either root_for_isolated_group, or the root of the layer tree. 2179f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // Otherwise, this layer will use an incomplete backdrop, limited to its 2180f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) // render target and the blending result will be incorrect. 2181f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) DCHECK(layer->uses_default_blend_mode() || IsRootLayer(layer) || 2182f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) !layer->parent()->render_target() || 2183f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) IsRootLayer(layer->parent()->render_target()) || 2184f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) layer->parent()->render_target()->is_root_for_isolated_group()); 2185f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles) 21862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetContentRect(clipped_content_rect); 21872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The owning layer's screen_space_transform has a scale from content to 21892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // layer space which we need to undo and replace with a scale from the 21902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // surface's subtree into layer space. 21912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform screen_space_transform = layer->screen_space_transform(); 21922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) screen_space_transform.Scale( 21932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->contents_scale_x() / render_surface_sublayer_scale.x(), 21942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->contents_scale_y() / render_surface_sublayer_scale.y()); 21952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetScreenSpaceTransform(screen_space_transform); 21962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 21972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->replica_layer()) { 21982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform surface_origin_to_replica_origin_transform; 21992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Scale( 22002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface_sublayer_scale.x(), render_surface_sublayer_scale.y()); 22012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Translate( 22022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->position().x() + 22032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->anchor_point().x() * bounds.width(), 22042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->position().y() + 22052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->anchor_point().y() * bounds.height()); 22062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.PreconcatTransform( 22072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->replica_layer()->transform()); 22082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Translate( 22092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) -layer->replica_layer()->anchor_point().x() * bounds.width(), 22102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) -layer->replica_layer()->anchor_point().y() * bounds.height()); 22112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform.Scale( 22122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.0 / render_surface_sublayer_scale.x(), 22132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.0 / render_surface_sublayer_scale.y()); 22142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the replica's "originTransform" that maps from the replica's 22162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // origin space to the target surface origin space. 22172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform replica_origin_transform = 22182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->draw_transform() * 22192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform; 22202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetReplicaDrawTransform(replica_origin_transform); 22212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Compute the replica's "screen_space_transform" that maps from the 22232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // replica's origin space to the screen's origin space. 22242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform replica_screen_space_transform = 22252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_surface()->screen_space_transform() * 22262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) surface_origin_to_replica_origin_transform; 22272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_surface->SetReplicaScreenSpaceTransform( 22282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) replica_screen_space_transform); 22292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2232eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch SavePaintPropertiesLayer(layer); 22332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If neither this layer nor any of its children were added, early out. 223558537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) if (sorting_start_index == descendants.size()) { 223658537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) DCHECK(!layer->render_surface() || IsRootLayer(layer)); 22372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return; 223858537e28ecd584eab876aee8be7156509866d23aTorne (Richard Coles) } 22392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If preserves-3d then sort all the descendants in 3D so that they can be 22412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // drawn from back to front. If the preserves-3d property is also set on the 22422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // parent then skip the sorting as the parent will sort all the descendants 22432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // anyway. 22445d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) if (globals.layer_sorter && descendants.size() && layer->is_3d_sorted() && 22455d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) !LayerIsInExisting3DRenderingContext(layer)) { 22462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) SortLayers(descendants.begin() + sorting_start_index, 22472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) descendants.end(), 22482385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch globals.layer_sorter); 22492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22518bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) UpdateAccumulatedSurfaceState<LayerType>( 2252424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) layer, local_drawable_content_rect_of_subtree, accumulated_surface_state); 22532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer->HasContributingDelegatedRenderPasses()) { 22552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer->render_target()->render_surface()-> 22562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) AddContributingDelegatedRenderPassLayer(layer); 22572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 22582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 22592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2260c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochtemplate <typename LayerType, typename RenderSurfaceLayerListType> 2261c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochstatic void ProcessCalcDrawPropsInputs( 2262c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch const LayerTreeHostCommon::CalcDrawPropsInputs<LayerType, 2263c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch RenderSurfaceLayerListType>& 2264c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs, 2265c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch SubtreeGlobals<LayerType>* globals, 2266c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DataForRecursion<LayerType>* data_for_recursion) { 2267c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(inputs.root_layer); 2268c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(IsRootLayer(inputs.root_layer)); 2269c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch DCHECK(inputs.render_surface_layer_list); 2270c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 22712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform identity_matrix; 22722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 22732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The root layer's render_surface should receive the device viewport as the 22742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // initial clip rect. 2275c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Rect device_viewport_rect(inputs.device_viewport_size); 2276c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2277c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Vector2dF device_transform_scale_components = 2278c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch MathUtil::ComputeTransform2dScaleComponents(inputs.device_transform, 1.f); 2279c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch // Not handling the rare case of different x and y device scale. 2280c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch float device_transform_scale = 2281c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch std::max(device_transform_scale_components.x(), 2282c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch device_transform_scale_components.y()); 2283c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2284c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch gfx::Transform scaled_device_transform = inputs.device_transform; 2285c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch scaled_device_transform.Scale(inputs.device_scale_factor, 2286c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.device_scale_factor); 2287c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2288c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->layer_sorter = NULL; 2289c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->max_texture_size = inputs.max_texture_size; 2290c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->device_scale_factor = 2291c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.device_scale_factor * device_transform_scale; 2292c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->page_scale_factor = inputs.page_scale_factor; 2293c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->page_scale_application_layer = inputs.page_scale_application_layer; 2294c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->can_render_to_separate_surface = 2295c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch inputs.can_render_to_separate_surface; 2296c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals->can_adjust_raster_scales = inputs.can_adjust_raster_scales; 2297c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2298c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->parent_matrix = scaled_device_transform; 2299c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->full_hierarchy_matrix = identity_matrix; 2300c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->scroll_compensation_matrix = identity_matrix; 2301c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->fixed_container = inputs.root_layer; 2302c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->clip_rect_in_target_space = device_viewport_rect; 2303c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->clip_rect_of_target_surface_in_target_space = 2304c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch device_viewport_rect; 2305c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->maximum_animation_contents_scale = 0.f; 2306c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->ancestor_is_animating_scale = false; 2307c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->ancestor_clips_subtree = true; 2308c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->nearest_occlusion_immune_ancestor_surface = NULL; 2309c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->in_subtree_of_page_scale_application_layer = false; 2310c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->subtree_can_use_lcd_text = inputs.can_use_lcd_text; 2311c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch data_for_recursion->subtree_is_visible_from_ancestor = true; 2312c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch} 23132385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch 2314c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdochvoid LayerTreeHostCommon::CalculateDrawProperties( 2315c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch CalcDrawPropsMainInputs* inputs) { 2316c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch RenderSurfaceLayerList dummy_layer_list; 23172385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch SubtreeGlobals<Layer> globals; 23188bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<Layer> data_for_recursion; 2319c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); 23202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23217dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData recursive_data; 2322558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch PreCalculateMetaInformation(inputs->root_layer, &recursive_data); 2323424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state; 23248bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) CalculateDrawPropertiesInternal<Layer>(inputs->root_layer, 23258bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) globals, 23268bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) data_for_recursion, 23278bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) inputs->render_surface_layer_list, 23288bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &dummy_layer_list, 23298bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &accumulated_surface_state); 23302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The dummy layer list should not have been used. 2332c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DCHECK_EQ(0u, dummy_layer_list.size()); 23332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A root layer render_surface should always exist after 23342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // CalculateDrawProperties. 2335558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DCHECK(inputs->root_layer->render_surface()); 23362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 23372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void LayerTreeHostCommon::CalculateDrawProperties( 2339558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch CalcDrawPropsImplInputs* inputs) { 2340c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) LayerImplList dummy_layer_list; 23412385ea399aae016c0806a4f9ef3c9cfe3d2a39dfBen Murdoch SubtreeGlobals<LayerImpl> globals; 23428bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) DataForRecursion<LayerImpl> data_for_recursion; 2343c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch ProcessCalcDrawPropsInputs(*inputs, &globals, &data_for_recursion); 2344c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch 2345c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch LayerSorter layer_sorter; 2346c5cede9ae108bb15f6b7a8aea21c7e1fefa2834cBen Murdoch globals.layer_sorter = &layer_sorter; 23472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23487dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch PreCalculateMetaInformationRecursiveData recursive_data; 2349558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch PreCalculateMetaInformation(inputs->root_layer, &recursive_data); 2350424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) std::vector<AccumulatedSurfaceState<LayerImpl> > 2351424c4d7b64af9d0d8fd9624f381f469654d5e3d2Torne (Richard Coles) accumulated_surface_state; 23528bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) CalculateDrawPropertiesInternal<LayerImpl>(inputs->root_layer, 23538bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) globals, 23548bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) data_for_recursion, 23558bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) inputs->render_surface_layer_list, 23568bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &dummy_layer_list, 23578bcbed890bc3ce4d7a057a8f32cab53fa534672eTorne (Richard Coles) &accumulated_surface_state); 23582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // The dummy layer list should not have been used. 2360c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) DCHECK_EQ(0u, dummy_layer_list.size()); 23612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // A root layer render_surface should always exist after 23622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // CalculateDrawProperties. 2363558790d6acca3451cf3a6b497803a5f07d0bec58Ben Murdoch DCHECK(inputs->root_layer->render_surface()); 23642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 23652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)static bool PointHitsRect( 23675d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::PointF& screen_space_point, 23682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& local_space_to_screen_space_transform, 23695d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::RectF& local_space_rect) { 23702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the transform is not invertible, then assume that this point doesn't hit 23712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this rect. 23722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_local_space_to_screen_space( 23732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 23742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!local_space_to_screen_space_transform.GetInverse( 23752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &inverse_local_space_to_screen_space)) 23762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 23772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Transform the hit test point from screen space to the local space of the 23792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // given rect. 23802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool clipped = false; 23812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::PointF hit_test_point_in_local_space = MathUtil::ProjectPoint( 23822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) inverse_local_space_to_screen_space, screen_space_point, &clipped); 23832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If ProjectPoint could not project to a valid value, then we assume that 23852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this point doesn't hit this rect. 23862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (clipped) 23872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 23882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return local_space_rect.Contains(hit_test_point_in_local_space); 23902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 23912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 23925d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static bool PointHitsRegion(const gfx::PointF& screen_space_point, 23932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const gfx::Transform& screen_space_transform, 23942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) const Region& layer_space_region, 23952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float layer_content_scale_x, 23962a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) float layer_content_scale_y) { 23972a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the transform is not invertible, then assume that this point doesn't hit 23982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this region. 23992a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform inverse_screen_space_transform( 24002a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::Transform::kSkipInitialization); 24012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!screen_space_transform.GetInverse(&inverse_screen_space_transform)) 24022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 24032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Transform the hit test point from screen space to the local space of the 24052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // given region. 24062a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool clipped = false; 24072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::PointF hit_test_point_in_content_space = MathUtil::ProjectPoint( 24082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) inverse_screen_space_transform, screen_space_point, &clipped); 24092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::PointF hit_test_point_in_layer_space = 24102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::ScalePoint(hit_test_point_in_content_space, 24112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.f / layer_content_scale_x, 24122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1.f / layer_content_scale_y); 24132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If ProjectPoint could not project to a valid value, then we assume that 24152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // this point doesn't hit this region. 24162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (clipped) 24172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 24182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return layer_space_region.Contains( 24202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) gfx::ToRoundedPoint(hit_test_point_in_layer_space)); 24212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 24222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24235d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)static bool PointIsClippedBySurfaceOrClipRect( 24245d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::PointF& screen_space_point, 24255d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) LayerImpl* layer) { 24262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* current_layer = layer; 24272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Walk up the layer tree and hit-test any render_surfaces and any layer 24292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // clip rects that are active. 24302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) while (current_layer) { 24312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (current_layer->render_surface() && 24322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !PointHitsRect( 24332a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) screen_space_point, 24342a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) current_layer->render_surface()->screen_space_transform(), 24352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) current_layer->render_surface()->content_rect())) 24362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 24372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Note that drawable content rects are actually in target surface space, so 24392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the transform we have to provide is the target surface's 24402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // screen_space_transform. 24412a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* render_target = current_layer->render_target(); 24422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (LayerClipsSubtree(current_layer) && 24432a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) !PointHitsRect( 24442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) screen_space_point, 24452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) render_target->render_surface()->screen_space_transform(), 24462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) current_layer->drawable_content_rect())) 24472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 24482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) current_layer = current_layer->parent(); 24502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 24512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24522a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If we have finished walking all ancestors without having already exited, 24532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // then the point is not clipped by any ancestors. 24542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 24552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 24562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 24570529e5d033099cbfc42635f6f6183833b09dff6eBen Murdochstatic bool PointHitsLayer(LayerImpl* layer, 24580529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch const gfx::PointF& screen_space_point) { 24590529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch gfx::RectF content_rect(layer->content_bounds()); 24600529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!PointHitsRect( 24610529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch screen_space_point, layer->screen_space_transform(), content_rect)) 24620529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return false; 24630529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24640529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // At this point, we think the point does hit the layer, but we need to walk 24650529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // up the parents to ensure that the layer was not clipped in such a way 24660529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // that the hit point actually should not hit the layer. 24670529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer)) 24680529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return false; 24690529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24700529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // Skip the HUD layer. 24710529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (layer == layer->layer_tree_impl()->hud_layer()) 24720529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return false; 24730529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24740529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return true; 24750529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch} 24760529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24770529e5d033099cbfc42635f6f6183833b09dff6eBen MurdochLayerImpl* LayerTreeHostCommon::FindFirstScrollingLayerThatIsHitByPoint( 24780529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch const gfx::PointF& screen_space_point, 24790529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch const LayerImplList& render_surface_layer_list) { 24800529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch typedef LayerIterator<LayerImpl> LayerIteratorType; 24810529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list); 24820529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch for (LayerIteratorType it = 24830529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch LayerIteratorType::Begin(&render_surface_layer_list); 24840529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch it != end; 24850529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch ++it) { 24860529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // We don't want to consider render_surfaces for hit testing. 24870529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!it.represents_itself()) 24880529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch continue; 24890529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24900529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch LayerImpl* current_layer = (*it); 24910529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!PointHitsLayer(current_layer, screen_space_point)) 24920529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch continue; 24930529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24940529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (current_layer->scrollable()) 24950529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return current_layer; 24960529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch } 24970529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 24980529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return NULL; 24990529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch} 25000529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 25012a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPoint( 25025d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::PointF& screen_space_point, 2503c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const LayerImplList& render_surface_layer_list) { 25042a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* found_layer = NULL; 25052a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25065d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) typedef LayerIterator<LayerImpl> LayerIteratorType; 25072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list); 25082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) for (LayerIteratorType 25092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) it = LayerIteratorType::Begin(&render_surface_layer_list); 25102a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) it != end; 25112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ++it) { 25122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // We don't want to consider render_surfaces for hit testing. 25132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!it.represents_itself()) 25142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) continue; 25152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* current_layer = (*it); 25170529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!PointHitsLayer(current_layer, screen_space_point)) 25182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) continue; 25192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) found_layer = current_layer; 25212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) break; 25222a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 25232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25242a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // This can potentially return NULL, which means the screen_space_point did 25252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // not successfully hit test any layers, not even the root layer. 25262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return found_layer; 25272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 25282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25290529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch// This may be generalized in the future, but we know at the very least that 25300529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch// hits cannot pass through scrolling nor opaque layers. 25310529e5d033099cbfc42635f6f6183833b09dff6eBen Murdochstatic bool OpaqueToHitTesting(const LayerImpl* layer) { 25320529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return layer->scrollable() || layer->contents_opaque(); 25330529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch} 25340529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 25352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion( 25365d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::PointF& screen_space_point, 2537c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) const LayerImplList& render_surface_layer_list) { 25380529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch typedef LayerIterator<LayerImpl> LayerIteratorType; 25390529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list); 25400529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch for (LayerIteratorType it = 25410529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch LayerIteratorType::Begin(&render_surface_layer_list); 25420529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch it != end; 25430529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch ++it) { 25440529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch // We don't want to consider render_surfaces for hit testing. 25450529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!it.represents_itself()) 25460529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch continue; 25470529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 25480529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch LayerImpl* current_layer = (*it); 25490529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (!PointHitsLayer(current_layer, screen_space_point)) 25500529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch continue; 25510529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 25521e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) if (LayerTreeHostCommon::LayerHasTouchEventHandlersAt(screen_space_point, 25530529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch current_layer)) 25540529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return current_layer; 25550529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 25560529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (OpaqueToHitTesting(current_layer)) 25571e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) break; 25582a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 25590529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return NULL; 25602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 25612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)bool LayerTreeHostCommon::LayerHasTouchEventHandlersAt( 25635d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const gfx::PointF& screen_space_point, 25642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) LayerImpl* layer_impl) { 25652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (layer_impl->touch_event_handler_region().IsEmpty()) 25662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 25672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!PointHitsRegion(screen_space_point, 25692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_impl->screen_space_transform(), 25702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_impl->touch_event_handler_region(), 25712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_impl->contents_scale_x(), 25722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) layer_impl->contents_scale_y())) 25732a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 25742a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25752a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // At this point, we think the point does hit the touch event handler region 25762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // on the layer, but we need to walk up the parents to ensure that the layer 25772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // was not clipped in such a way that the hit point actually should not hit 25782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the layer. 25792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl)) 25802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return false; 25812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 25822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return true; 25832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 25842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} // namespace cc 2585