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

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 225 matching lines @@
 gfx::Rect LayerTreeHostCommon::CalculateVisibleRect(
     const gfx::Rect& target_surface_rect,
     const gfx::Rect& layer_bound_rect,
     const gfx::Transform& transform) {
   gfx::Rect layer_in_surface_space =
       MathUtil::MapEnclosingClippedRect(transform, layer_bound_rect);
   return CalculateVisibleRectWithCachedLayerRect(
       target_surface_rect, layer_bound_rect, layer_in_surface_space, transform);
 }
 
-template <typename LayerType>
-static inline bool IsRootLayer(LayerType* layer) {
+static inline bool IsRootLayer(const Layer* layer) {
   return !layer->parent();
 }
 
+static inline bool IsRootLayer(const LayerImpl* layer) {
+  return layer->layer_tree_impl()->IsRootLayer(layer);
+}
+
 template <typename LayerType>
 static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
   return layer->Is3dSorted() && layer->parent() &&
          layer->parent()->Is3dSorted() &&
          (layer->parent()->sorting_context_id() == layer->sorting_context_id());
 }
 
 static bool IsRootLayerOfNewRenderingContext(LayerImpl* layer) {
   if (layer->parent())
     return !layer->parent()->Is3dSorted() && layer->Is3dSorted();
@@ skipping 53 matching lines @@
   // into this function, so it is safe to omit this check here.
 
   if (!layer_is_drawn)
     return true;
 
   if (!layer->DrawsContent() || layer->bounds().IsEmpty())
     return true;
 
   LayerImpl* backface_test_layer = layer;
   if (layer->use_parent_backface_visibility()) {
-    DCHECK(layer->parent());
+    DCHECK(!IsRootLayer(layer));
     DCHECK(!layer->parent()->use_parent_backface_visibility());
     backface_test_layer = layer->parent();
   }
 
   // The layer should not be drawn if (1) it is not double-sided and (2) the
   // back of the layer is known to be facing the screen.
   if (!backface_test_layer->double_sided() &&
       IsLayerBackFaceVisible(backface_test_layer, transform_tree))
     return true;
 
@@ skipping 368 matching lines @@
     layer->draw_properties().render_target = layer;
 
     if (layer->mask_layer())
       layer->mask_layer()->draw_properties().render_target = layer;
 
     if (layer->replica_layer() && layer->replica_layer()->mask_layer())
       layer->replica_layer()->mask_layer()->draw_properties().render_target =
           layer;
 
   } else {
-    DCHECK(layer->parent());
+    DCHECK(!IsRootLayer(layer));
     layer->draw_properties().render_target = layer->parent()->render_target();
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     CalculateRenderTarget(
         LayerTreeHostCommon::get_layer_as_raw_ptr(layer->children(), i),
         property_trees, layer_is_drawn, can_render_to_separate_surface);
   }
 }
 
@@ skipping 394 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc