cc : Stop pushing properties not used by LayerImpl to LayerImpl (4)

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 62 matching lines @@
 };
 
 static LayerPositionConstraint PositionConstraint(Layer* layer) {
   return layer->position_constraint();
 }
 
 static LayerPositionConstraint PositionConstraint(LayerImpl* layer) {
   return layer->test_properties()->position_constraint;
 }
 
+static Layer* ScrollParent(Layer* layer) {
+  return layer->scroll_parent();
+}
+
+static LayerImpl* ScrollParent(LayerImpl* layer) {
+  return layer->test_properties()->scroll_parent;
+}
+
+static std::set<Layer*>* ScrollChildren(Layer* layer) {
+  return layer->scroll_children();
+}
+
+static std::set<LayerImpl*>* ScrollChildren(LayerImpl* layer) {
+  return layer->test_properties()->scroll_children.get();
+}
+
+static Layer* ClipParent(Layer* layer) {
+  return layer->clip_parent();
+}
+
+static LayerImpl* ClipParent(LayerImpl* layer) {
+  return layer->test_properties()->clip_parent;
+}
+
 template <typename LayerType>
 static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
                                      LayerType* layer) {
   return PositionConstraint(layer).is_fixed_position()
              ? data.transform_fixed_parent
              : data.transform_tree_parent;
 }
 
 template <typename LayerType>
 static ClipNode* GetClipParent(const DataForRecursion<LayerType>& data,
                                LayerType* layer) {
-  const bool inherits_clip = !layer->clip_parent();
+  const bool inherits_clip = !ClipParent(layer);
   const int id = inherits_clip ? data.clip_tree_parent
-                               : layer->clip_parent()->clip_tree_index();
+                               : ClipParent(layer)->clip_tree_index();
   return data.clip_tree->Node(id);
 }
 
 template <typename LayerType>
 static bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 template <typename LayerType>
 static int GetScrollParentId(const DataForRecursion<LayerType>& data,
                              LayerType* layer) {
-  const bool inherits_scroll = !layer->scroll_parent();
+  const bool inherits_scroll = !ScrollParent(layer);
   const int id = inherits_scroll ? data.scroll_tree_parent
-                                 : layer->scroll_parent()->scroll_tree_index();
+                                 : ScrollParent(layer)->scroll_tree_index();
   return id;
 }
 
 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);
@@ skipping 156 matching lines @@
   // 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 =
-      layer->scroll_parent() &&
+      ScrollParent(layer) &&
       layer->parent()->effect_tree_index() !=
-          layer->scroll_parent()->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 (layer->scroll_parent()) {
+    if (ScrollParent(layer)) {
       LayerType* source = layer->parent();
       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();
@@ skipping 111 matching lines @@
   } else {
     node->data.source_offset = source_offset;
     node->data.update_post_local_transform(layer->position(),
                                            TransformOrigin(layer));
   }
 
   if (is_overscroll_elasticity_layer) {
     DCHECK(!is_scrollable);
     node->data.scroll_offset =
         gfx::ScrollOffset(data_from_ancestor.elastic_overscroll);
-  } else if (!layer->scroll_parent()) {
+  } else if (!ScrollParent(layer)) {
     node->data.scroll_offset = layer->CurrentScrollOffset();
   }
 
   if (is_fixed) {
     if (data_from_ancestor.affected_by_inner_viewport_bounds_delta) {
       node->data.affected_by_inner_viewport_bounds_delta_x =
           PositionConstraint(layer).is_fixed_to_right_edge();
       node->data.affected_by_inner_viewport_bounds_delta_y =
           PositionConstraint(layer).is_fixed_to_bottom_edge();
       if (node->data.affected_by_inner_viewport_bounds_delta_x ||
@@ skipping 419 matching lines @@
   AddClipNodeIfNeeded(data_from_parent, layer, created_render_surface,
                       created_transform_node, &data_for_children);
 
   AddScrollNodeIfNeeded(data_from_parent, layer, &data_for_children);
 
   SetBackfaceVisibilityTransform(layer, created_transform_node);
   SetSafeOpaqueBackgroundColor(data_from_parent, layer, &data_for_children);
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     SetLayerPropertyChangedForChild(layer, layer->child_at(i));
-    if (!layer->child_at(i)->scroll_parent()) {
+    if (!ScrollParent(layer->child_at(i))) {
       DataForRecursionFromChild<LayerType> data_from_child;
       BuildPropertyTreesInternal(layer->child_at(i), data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
     } else {
       // The child should be included in its scroll parent's list of scroll
       // children.
-      DCHECK(layer->child_at(i)->scroll_parent()->scroll_children()->count(
-          layer->child_at(i)));
+      DCHECK(ScrollChildren(ScrollParent(layer->child_at(i)))
+                 ->count(layer->child_at(i)));
     }
   }
 
-  if (layer->scroll_children()) {
-    for (LayerType* scroll_child : *layer->scroll_children()) {
-      DCHECK_EQ(scroll_child->scroll_parent(), layer);
+  if (ScrollChildren(layer)) {
+    for (LayerType* scroll_child : *ScrollChildren(layer)) {
+      DCHECK_EQ(ScrollParent(scroll_child), layer);
       DataForRecursionFromChild<LayerType> data_from_child;
       DCHECK(scroll_child->parent());
       data_for_children.effect_tree_parent =
           scroll_child->parent()->effect_tree_index();
       data_for_children.render_target =
           scroll_child->parent()->effect_tree_index();
       BuildPropertyTreesInternal(scroll_child, data_for_children,
                                  &data_from_child);
       data_to_parent->Merge(data_from_child);
     }
@@ skipping 149 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