cc : Move LayerImpl::parent to test properties

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 242 matching lines @@
 
 template <typename LayerType>
 static int GetScrollParentId(const DataForRecursion<LayerType>& data,
                              LayerType* layer) {
   const bool inherits_scroll = !ScrollParent(layer);
   const int id = inherits_scroll ? data.scroll_tree_parent
                                  : ScrollParent(layer)->scroll_tree_index();
   return id;
 }
 
+static Layer* Parent(Layer* layer) {
+  return layer->parent();
+}
+
+static LayerImpl* Parent(LayerImpl* layer) {
+  return layer->test_properties()->parent;
+}
+
 template <typename LayerType>
 void AddClipNodeIfNeeded(const DataForRecursion<LayerType>& data_from_ancestor,
                          LayerType* layer,
                          bool created_render_surface,
                          bool created_transform_node,
                          DataForRecursion<LayerType>* data_for_children) {
   ClipNode* parent = GetClipParent(data_from_ancestor, layer);
   int parent_id = parent->id;
 
-  bool is_root = !layer->parent();
+  bool is_root = !Parent(layer);
 
   // Whether we have an ancestor clip that we might need to apply.
   bool ancestor_clips_subtree = is_root || parent->data.layers_are_clipped;
 
   bool layers_are_clipped = false;
   bool has_unclipped_surface = false;
 
   if (created_render_surface) {
     // Clips can usually be applied to a surface's descendants simply by
     // clipping the surface (or applied implicitly by the surface's bounds).
@@ skipping 83 matching lines @@
   }
 
   layer->SetClipTreeIndex(data_for_children->clip_tree_parent);
   // TODO(awoloszyn): Right now when we hit a node with a replica, we reset the
   // clip for all children since we may need to draw. We need to figure out a
   // better way, since we will need both the clipped and unclipped versions.
 }
 
 template <typename LayerType>
 static inline bool IsAtBoundaryOf3dRenderingContext(LayerType* layer) {
-  return layer->parent()
-             ? layer->parent()->sorting_context_id() !=
+  return Parent(layer)
+             ? Parent(layer)->sorting_context_id() !=
                    layer->sorting_context_id()
              : layer->Is3dSorted();
 }
 
 static inline gfx::Point3F TransformOrigin(Layer* layer) {
   return layer->transform_origin();
 }
 
 static inline gfx::Point3F TransformOrigin(LayerImpl* layer) {
   return layer->test_properties()->transform_origin;
@@ skipping 14 matching lines @@
 static inline bool ShouldFlattenTransform(LayerImpl* layer) {
   return layer->test_properties()->should_flatten_transform;
 }
 
 template <typename LayerType>
 bool AddTransformNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     bool created_render_surface,
     DataForRecursion<LayerType>* data_for_children) {
-  const bool is_root = !layer->parent();
+  const bool is_root = !Parent(layer);
   const bool is_page_scale_layer = layer == data_from_ancestor.page_scale_layer;
   const bool is_overscroll_elasticity_layer =
       layer == data_from_ancestor.overscroll_elasticity_layer;
   const bool is_scrollable = layer->scrollable();
   const bool is_fixed = PositionConstraint(layer).is_fixed_position();
 
   const bool has_significant_transform =
       !layer->transform().IsIdentityOr2DTranslation();
 
   const bool has_potentially_animated_transform =
       layer->HasPotentiallyRunningTransformAnimation();
 
   // A transform node is needed even for a finished animation, since differences
   // in the timing of animation state updates can mean that an animation that's
   // in the Finished state at tree-building time on the main thread is still in
   // the Running state right after commit on the compositor thread.
   const bool has_any_transform_animation =
       layer->HasAnyAnimationTargetingProperty(TargetProperty::TRANSFORM);
 
   const bool has_surface = created_render_surface;
 
   // A transform node is needed to change the render target for subtree when
   // a scroll child's render target is different from the scroll parent's render
   // target.
   const bool scroll_child_has_different_target =
       ScrollParent(layer) &&
-      layer->parent()->effect_tree_index() !=
+      Parent(layer)->effect_tree_index() !=
           ScrollParent(layer)->effect_tree_index();
 
   const bool is_at_boundary_of_3d_rendering_context =
       IsAtBoundaryOf3dRenderingContext(layer);
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_any_transform_animation || has_surface || is_fixed ||
                        is_page_scale_layer || is_overscroll_elasticity_layer ||
                        scroll_child_has_different_target ||
                        is_at_boundary_of_3d_rendering_context;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
   DCHECK(is_root || transform_parent);
 
   int parent_index = kRootPropertyTreeNodeId;
   if (transform_parent)
     parent_index = transform_parent->transform_tree_index();
 
   int source_index = parent_index;
 
   gfx::Vector2dF source_offset;
   if (transform_parent) {
     if (ScrollParent(layer)) {
-      LayerType* source = layer->parent();
+      LayerType* source = Parent(layer);
       source_offset += source->offset_to_transform_parent();
       source_index = source->transform_tree_index();
     } else if (!is_fixed) {
       source_offset = transform_parent->offset_to_transform_parent();
     } else {
       source_offset = data_from_ancestor.transform_tree_parent
                           ->offset_to_transform_parent();
       source_index =
           data_from_ancestor.transform_tree_parent->transform_tree_index();
       source_offset -= data_from_ancestor.scroll_snap;
     }
   }
 
   if (IsContainerForFixedPositionLayers(layer) || is_root) {
     data_for_children->affected_by_inner_viewport_bounds_delta =
         layer == data_from_ancestor.inner_viewport_scroll_layer;
     data_for_children->affected_by_outer_viewport_bounds_delta =
         layer == data_from_ancestor.outer_viewport_scroll_layer;
     if (is_scrollable) {
       DCHECK(!is_root);
       DCHECK(layer->transform().IsIdentity());
-      data_for_children->transform_fixed_parent = layer->parent();
+      data_for_children->transform_fixed_parent = Parent(layer);
     } else {
       data_for_children->transform_fixed_parent = layer;
     }
   }
   data_for_children->transform_tree_parent = layer;
 
   if (IsContainerForFixedPositionLayers(layer) || is_fixed)
     data_for_children->scroll_snap = gfx::Vector2dF();
 
   if (!requires_node) {
@@ skipping 167 matching lines @@
 static inline bool ForceRenderSurface(Layer* layer) {
   return layer->force_render_surface_for_testing();
 }
 
 static inline bool ForceRenderSurface(LayerImpl* layer) {
   return layer->test_properties()->force_render_surface;
 }
 
 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());
+  return layer->Is3dSorted() && Parent(layer) && Parent(layer)->Is3dSorted() &&
+         (Parent(layer)->sorting_context_id() == layer->sorting_context_id());
 }
 
 static inline bool IsRootForIsolatedGroup(Layer* layer) {
   return layer->is_root_for_isolated_group();
 }
 
 static inline bool IsRootForIsolatedGroup(LayerImpl* layer) {
   return false;
 }
 
@@ skipping 47 matching lines @@
   return !layer->test_properties()->copy_requests.empty();
 }
 
 template <typename LayerType>
 bool ShouldCreateRenderSurface(LayerType* layer,
                                gfx::Transform current_transform,
                                bool axis_aligned) {
   const bool preserves_2d_axis_alignment =
       (current_transform * layer->transform()).Preserves2dAxisAlignment() &&
       axis_aligned && layer->AnimationsPreserveAxisAlignment();
-  const bool is_root = !layer->parent();
+  const bool is_root = !Parent(layer);
   if (is_root)
     return true;
 
   // If the layer uses a mask and the layer is not a replica layer.
   // TODO(weiliangc): After slimming paint there won't be replica layers.
-  if (MaskLayer(layer) && ReplicaLayer(layer->parent()) != layer) {
+  if (MaskLayer(layer) && ReplicaLayer(Parent(layer)) != layer) {
     return true;
   }
 
   // If the layer has a reflection.
   if (ReplicaLayer(layer)) {
     return true;
   }
 
   // If the layer uses a CSS filter.
   if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) {
@@ skipping 91 matching lines @@
   for (auto& request : layer->test_properties()->copy_requests)
     copy_requests->push_back(std::move(request));
   layer->test_properties()->copy_requests.clear();
 }
 
 template <typename LayerType>
 bool AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
-  const bool is_root = !layer->parent();
+  const bool is_root = !Parent(layer);
   const bool has_transparency = EffectiveOpacity(layer) != 1.f;
   const bool has_potential_opacity_animation =
       HasPotentialOpacityAnimation(layer);
   const bool should_create_render_surface = ShouldCreateRenderSurface(
       layer, data_from_ancestor.compound_transform_since_render_target,
       data_from_ancestor.axis_align_since_render_target);
   data_for_children->axis_align_since_render_target &=
       layer->AnimationsPreserveAxisAlignment();
 
   bool requires_node = is_root || has_transparency ||
@@ skipping 83 matching lines @@
   return should_create_render_surface;
 }
 
 template <typename LayerType>
 void AddScrollNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   int parent_id = GetScrollParentId(data_from_ancestor, layer);
 
-  bool is_root = !layer->parent();
+  bool is_root = !Parent(layer);
   bool scrollable = layer->scrollable();
   bool contains_non_fast_scrollable_region =
       !layer->non_fast_scrollable_region().IsEmpty();
   uint32_t main_thread_scrolling_reasons =
       layer->main_thread_scrolling_reasons();
 
   bool scroll_node_uninheritable_criteria =
       is_root || scrollable || contains_non_fast_scrollable_region;
   bool has_different_main_thread_scrolling_reasons =
       main_thread_scrolling_reasons !=
@@ skipping 61 matching lines @@
   layer->SetScrollTreeIndex(data_for_children->scroll_tree_parent);
 }
 
 template <typename LayerType>
 void SetBackfaceVisibilityTransform(LayerType* layer,
                                     bool created_transform_node) {
   const bool is_at_boundary_of_3d_rendering_context =
       IsAtBoundaryOf3dRenderingContext(layer);
   if (layer->use_parent_backface_visibility()) {
     DCHECK(!is_at_boundary_of_3d_rendering_context);
-    DCHECK(layer->parent());
-    DCHECK(!layer->parent()->use_parent_backface_visibility());
+    DCHECK(Parent(layer));
+    DCHECK(!Parent(layer)->use_parent_backface_visibility());
     layer->SetUseLocalTransformForBackfaceVisibility(
-        layer->parent()->use_local_transform_for_backface_visibility());
+        Parent(layer)->use_local_transform_for_backface_visibility());
     layer->SetShouldCheckBackfaceVisibility(
-        layer->parent()->should_check_backface_visibility());
+        Parent(layer)->should_check_backface_visibility());
   } else {
     // The current W3C spec on CSS transforms says that backface visibility
     // should be determined differently depending on whether the layer is in a
     // "3d rendering context" or not. For Chromium code, we can determine
     // whether we are in a 3d rendering context by checking if the parent
     // preserves 3d.
     const bool use_local_transform =
         !layer->Is3dSorted() ||
         (layer->Is3dSorted() && is_at_boundary_of_3d_rendering_context);
     layer->SetUseLocalTransformForBackfaceVisibility(use_local_transform);
@@ skipping 75 matching lines @@
       // The child should be included in its scroll parent's list of scroll
       // children.
       DCHECK(ScrollChildren(ScrollParent(current_child))->count(current_child));
     }
   }
 
   if (ScrollChildren(layer)) {
     for (LayerType* scroll_child : *ScrollChildren(layer)) {
       DCHECK_EQ(ScrollParent(scroll_child), layer);
       DataForRecursionFromChild<LayerType> data_from_child;
-      DCHECK(scroll_child->parent());
+      DCHECK(Parent(scroll_child));
       data_for_children.effect_tree_parent =
-          scroll_child->parent()->effect_tree_index();
+          Parent(scroll_child)->effect_tree_index();
       data_for_children.render_target =
-          scroll_child->parent()->effect_tree_index();
+          Parent(scroll_child)->effect_tree_index();
       BuildPropertyTreesInternal(scroll_child, data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
     }
   }
 
   if (ReplicaLayer(layer)) {
     DataForRecursionFromChild<LayerType> data_from_child;
     BuildPropertyTreesInternal(ReplicaLayer(layer), data_for_children,
                                &data_from_child);
@@ skipping 211 matching lines @@
   if (SkColorGetA(color) != 255)
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       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, color);
 }
 
 }  // namespace cc