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

cc/trees/occlusion_tracker.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/base/region.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
+#include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 OcclusionTracker::OcclusionTracker(const gfx::Rect& screen_space_clip_rect)
     : screen_space_clip_rect_(screen_space_clip_rect) {
 }
 
 OcclusionTracker::~OcclusionTracker() {
@@ skipping 108 matching lines @@
       new_occlusion_immune_ancestor &&
       new_occlusion_immune_ancestor != old_occlusion_immune_ancestor;
 
   gfx::Transform inverse_new_target_screen_space_transform(
       // Note carefully, not used if screen space transform is uninvertible.
       gfx::Transform::kSkipInitialization);
   bool have_transform_from_screen_to_new_target =
       new_target->render_surface()->screen_space_transform().GetInverse(
           &inverse_new_target_screen_space_transform);
 
-  bool entering_root_target = new_target->parent() == NULL;
+  bool entering_root_target =
+      new_target->layer_tree_impl()->IsRootLayer(new_target);
 
   bool copy_outside_occlusion_forward =
       stack_.size() > 1 &&
       !entering_unoccluded_subtree &&
       have_transform_from_screen_to_new_target &&
       !entering_root_target;
   if (!copy_outside_occlusion_forward)
     return;
 
   size_t last_index = stack_.size() - 1;
@@ skipping 131 matching lines @@
           old_surface->content_rect());
     }
   }
 
   if (surface_will_be_at_top_after_pop) {
     // Merge the top of the stack down.
     stack_[last_index - 1].occlusion_from_inside_target.Union(
         old_occlusion_from_inside_target_in_new_target);
     // TODO(danakj): Strictly this should subtract the inside target occlusion
     // before union.
-    if (new_target->parent()) {
+    if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
       stack_[last_index - 1].occlusion_from_outside_target.Union(
           old_occlusion_from_outside_target_in_new_target);
     }
     stack_.pop_back();
   } else {
     // Replace the top of the stack with the new pushed surface.
     stack_.back().target = new_target;
     stack_.back().occlusion_from_inside_target =
         old_occlusion_from_inside_target_in_new_target;
-    if (new_target->parent()) {
+    if (!new_target->layer_tree_impl()->IsRootLayer(new_target)) {
       stack_.back().occlusion_from_outside_target =
           old_occlusion_from_outside_target_in_new_target;
     } else {
       stack_.back().occlusion_from_outside_target.Clear();
     }
   }
 
   if (!old_target->background_filters().HasFilterThatMovesPixels())
     return;
 
@@ skipping 61 matching lines @@
             draw_transform, opaque_layer_region.GetRect(i));
     transformed_rect.Intersect(clip_rect_in_target);
     if (transformed_rect.width() < minimum_tracking_size_.width() &&
         transformed_rect.height() < minimum_tracking_size_.height())
       continue;
     stack_.back().occlusion_from_inside_target.Union(transformed_rect);
   }
 }
 
 Region OcclusionTracker::ComputeVisibleRegionInScreen() const {
-  DCHECK(!stack_.back().target->parent());
+  DCHECK(stack_.back().target->layer_tree_impl()->IsRootLayer(
+      stack_.back().target));
   const SimpleEnclosedRegion& occluded =
       stack_.back().occlusion_from_inside_target;
   Region visible_region(screen_space_clip_rect_);
   for (size_t i = 0; i < occluded.GetRegionComplexity(); ++i)
     visible_region.Subtract(occluded.GetRect(i));
   return visible_region;
 }
 
 }  // namespace cc