cc : Determine if a layer is root by using the value in LayerTreeImpl

cc/trees/draw_property_utils.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/property_tree_builder.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 namespace draw_property_utils {
 
 namespace {
 
+static bool IsRootLayer(const Layer* layer) {
+  return !layer->parent();
+}
+
+static bool IsRootLayer(const LayerImpl* layer) {
+  return layer->layer_tree_impl()->IsRootLayer(layer);
+}
+
 template <typename LayerType>
-static void ValidateRenderSurfaces(LayerType* layer) {
-  for (size_t i = 0; i < layer->children().size(); ++i) {
-    ValidateRenderSurfaces(layer->child_at(i));
-  }
-
+static void ValidateRenderSurfaceForLayer(LayerType* layer) {
   // This test verifies that there are no cases where a LayerImpl needs
   // a render surface, but doesn't have one.
   if (layer->has_render_surface())
     return;
 
   DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id();
   DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id();
-  DCHECK(layer->parent()) << "layer: " << layer->id();
+  DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id();
   if (layer->parent()->replica_layer() == layer)
     return;
   DCHECK(!layer->mask_layer()) << "layer: " << layer->id();
   DCHECK(!layer->replica_layer()) << "layer: " << layer->id();
   DCHECK(!layer->is_root_for_isolated_group()) << "layer: " << layer->id();
   DCHECK(!layer->HasCopyRequest()) << "layer: " << layer->id();
 }
 
+static void ValidateRenderSurfacesRecursive(Layer* layer) {
+  ValidateRenderSurfaceForLayer(layer);
+  for (size_t i = 0; i < layer->children().size(); ++i)
+    ValidateRenderSurfacesRecursive(layer->child_at(i));
+}
+
 template <typename LayerType>
 void CalculateVisibleRects(const std::vector<LayerType*>& visible_layer_list,
                            const ClipTree& clip_tree,
                            const TransformTree& transform_tree,
                            bool non_root_surfaces_enabled) {
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
     const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
     const bool is_unclipped = clip_node->data.resets_clip &&
                               !clip_node->data.applies_local_clip &&
@@ skipping 362 matching lines @@
 void FindLayersThatNeedUpdates(
     LayerType* layer,
     const TransformTree& transform_tree,
     const EffectTree& effect_tree,
     typename LayerType::LayerListType* update_layer_list,
     std::vector<LayerType*>* visible_layer_list) {
   DCHECK_GE(layer->effect_tree_index(), 0);
   bool layer_is_drawn =
       effect_tree.Node(layer->effect_tree_index())->data.is_drawn;
 
-  if (layer->parent() &&
+  if (!IsRootLayer(layer) &&
       SubtreeShouldBeSkipped(layer, layer_is_drawn, transform_tree))
     return;
 
   if (!LayerShouldBeSkipped(layer, layer_is_drawn, transform_tree)) {
     visible_layer_list->push_back(layer);
     update_layer_list->push_back(layer);
   }
 
   // Append mask layers to the update layer list.  They don't have valid visible
   // rects, so need to get added after the above calculation.  Replica layers
   // don't need to be updated.
   if (LayerType* mask_layer = layer->mask_layer())
     update_layer_list->push_back(mask_layer);
   if (LayerType* replica_layer = layer->replica_layer()) {
     if (LayerType* mask_layer = replica_layer->mask_layer())
       update_layer_list->push_back(mask_layer);
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     FindLayersThatNeedUpdates(layer->child_at(i), transform_tree, effect_tree,
                               update_layer_list, visible_layer_list);
   }
 }
 
 template <typename LayerType>
 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
                                  bool non_root_surfaces_enabled,
                                  LayerType* layer) {
   if (!non_root_surfaces_enabled) {
-    layer->SetHasRenderSurface(!layer->parent());
+    layer->SetHasRenderSurface(IsRootLayer(layer));
     return;
   }
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
 
   if (node->owner_id == layer->id() && node->data.has_render_surface)
     layer->SetHasRenderSurface(true);
   else
     layer->SetHasRenderSurface(false);
 }
 
@@ skipping 209 matching lines @@
     bool can_render_to_separate_surface,
     PropertyTrees* property_trees,
     LayerList* update_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
   UpdateRenderSurfacesForLayersRecursive(&property_trees->effect_tree,
                                          root_layer);
-  ValidateRenderSurfaces(root_layer);
+  ValidateRenderSurfacesRecursive(root_layer);
   ComputeVisibleRects(root_layer, property_trees,
                       can_render_to_separate_surface, update_layer_list);
 }
 
 void BuildPropertyTreesAndComputeVisibleRects(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const LayerImpl* overscroll_elasticity_layer,
@@ skipping 21 matching lines @@
   std::vector<Layer*> visible_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface, update_layer_list,
                               &visible_layer_list);
 }
 
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
-  for (auto* layer : *root_layer->layer_tree_impl())
+  for (auto* layer : *root_layer->layer_tree_impl()) {
     UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
                                 can_render_to_separate_surface, layer);
-  if (can_render_to_separate_surface)
-    ValidateRenderSurfaces(root_layer);
+    if (can_render_to_separate_surface)
+      ValidateRenderSurfaceForLayer(layer);
+  }
   LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
                               &update_layer_list, visible_layer_list);
 }
 
 template <typename LayerType>
 static gfx::Transform DrawTransformInternal(const LayerType* layer,
                                             const TransformNode* node) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
-      layer->parent() && layer->has_render_surface();
+      !IsRootLayer(layer) && layer->has_render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
     // your local offset.
     xform = node->data.to_target;
     if (layer->should_flatten_transform_from_property_tree())
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their sublayer scale.
@@ skipping 288 matching lines @@
   DCHECK(page_scale_layer);
   DCHECK_GE(page_scale_layer->transform_tree_index(), 0);
   TransformNode* node = property_trees->transform_tree.Node(
       page_scale_layer->transform_tree_index());
   // TODO(enne): property trees can't ask the layer these things, but
   // the page scale layer should *just* be the page scale.
   DCHECK_EQ(page_scale_layer->position().ToString(), gfx::PointF().ToString());
   DCHECK_EQ(page_scale_layer->transform_origin().ToString(),
             gfx::Point3F().ToString());
 
-  if (!page_scale_layer->parent()) {
+  if (IsRootLayer(page_scale_layer)) {
     // When the page scale layer is also the root layer, the node should also
     // store the combined scale factor and not just the page scale factor.
     float post_local_scale_factor = page_scale_factor * device_scale_factor;
     node->data.post_local_scale_factor = post_local_scale_factor;
     node->data.post_local = device_transform;
     node->data.post_local.Scale(post_local_scale_factor,
                                 post_local_scale_factor);
   } else {
     node->data.post_local_scale_factor = page_scale_factor;
     node->data.update_post_local_transform(gfx::PointF(), gfx::Point3F());
@@ skipping 52 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc