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

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 54 matching lines @@
 struct DataForRecursionFromChild {
   int num_copy_requests_in_subtree;
 
   DataForRecursionFromChild() : num_copy_requests_in_subtree(0) {}
 
   void Merge(const DataForRecursionFromChild& data) {
     num_copy_requests_in_subtree += data.num_copy_requests_in_subtree;
   }
 };
 
+static LayerPositionConstraint PositionConstraint(Layer* layer) {
+  return layer->position_constraint();
+}
+
+static LayerPositionConstraint PositionConstraint(LayerImpl* layer) {
+  return layer->test_properties()->position_constraint;
+}
+
 template <typename LayerType>
 static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
                                      LayerType* layer) {
-  return layer->position_constraint().is_fixed_position()
+  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 int id = inherits_clip ? data.clip_tree_parent
                                : layer->clip_parent()->clip_tree_index();
@@ skipping 73 matching lines @@
   // a clip node for every render surface.
   bool requires_node = layer_clips_subtree || created_render_surface;
 
   if (!requires_node) {
     data_for_children->clip_tree_parent = parent_id;
     DCHECK_EQ(layers_are_clipped, parent->data.layers_are_clipped);
     DCHECK_EQ(layers_are_clipped_when_surfaces_disabled,
               parent->data.layers_are_clipped_when_surfaces_disabled);
   } else {
     LayerType* transform_parent = data_for_children->transform_tree_parent;
-    if (layer->position_constraint().is_fixed_position() &&
+    if (PositionConstraint(layer).is_fixed_position() &&
         !created_transform_node) {
       transform_parent = data_for_children->transform_fixed_parent;
     }
     ClipNode node;
     node.data.clip =
         gfx::RectF(gfx::PointF() + layer->offset_to_transform_parent(),
                    gfx::SizeF(layer->bounds()));
     node.data.transform_id = transform_parent->transform_tree_index();
     node.data.target_id =
         data_for_children->effect_tree->Node(data_for_children->render_target)
@@ skipping 38 matching lines @@
 }
 
 static inline gfx::Point3F TransformOrigin(Layer* layer) {
   return layer->transform_origin();
 }
 
 static inline gfx::Point3F TransformOrigin(LayerImpl* layer) {
   return layer->test_properties()->transform_origin;
 }
 
+static inline bool IsContainerForFixedPositionLayers(Layer* layer) {
+  return layer->IsContainerForFixedPositionLayers();
+}
+
+static inline bool IsContainerForFixedPositionLayers(LayerImpl* layer) {
+  return layer->test_properties()->is_container_for_fixed_position_layers;
+}
+
+static inline bool ShouldFlattenTransform(Layer* layer) {
+  return layer->should_flatten_transform();
+}
+
+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_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 = layer->position_constraint().is_fixed_position();
+  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
@@ skipping 39 matching lines @@
       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 (layer->IsContainerForFixedPositionLayers() || is_root) {
+  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();
     } else {
       data_for_children->transform_fixed_parent = layer;
     }
   }
   data_for_children->transform_tree_parent = layer;
 
-  if (layer->IsContainerForFixedPositionLayers() || is_fixed)
+  if (IsContainerForFixedPositionLayers(layer) || is_fixed)
     data_for_children->scroll_snap = gfx::Vector2dF();
 
   if (!requires_node) {
-    data_for_children->should_flatten |= layer->should_flatten_transform();
+    data_for_children->should_flatten |= ShouldFlattenTransform(layer);
     gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
                                   layer->transform().To2dTranslation();
     gfx::Vector2dF source_to_parent;
     if (source_index != parent_index) {
       gfx::Transform to_parent;
       data_from_ancestor.transform_tree->ComputeTransform(
           source_index, parent_index, &to_parent);
       source_to_parent = to_parent.To2dTranslation();
     }
     layer->set_offset_to_transform_parent(source_offset + source_to_parent +
@@ skipping 18 matching lines @@
 
   node->data.sorting_context_id = layer->sorting_context_id();
 
   if (layer == data_from_ancestor.page_scale_layer)
     data_for_children->in_subtree_of_page_scale_layer = true;
   node->data.in_subtree_of_page_scale_layer =
       data_for_children->in_subtree_of_page_scale_layer;
 
   // Surfaces inherently flatten transforms.
   data_for_children->should_flatten =
-      layer->should_flatten_transform() || has_surface;
+      ShouldFlattenTransform(layer) || has_surface;
   DCHECK_GT(data_from_ancestor.effect_tree->size(), 0u);
 
   node->data.target_id =
       data_for_children->effect_tree->Node(data_from_ancestor.render_target)
           ->data.transform_id;
   node->data.content_target_id =
       data_for_children->effect_tree->Node(data_for_children->render_target)
           ->data.transform_id;
   DCHECK_NE(node->data.target_id, kInvalidPropertyTreeNodeId);
 
@@ skipping 45 matching lines @@
     DCHECK(!is_scrollable);
     node->data.scroll_offset =
         gfx::ScrollOffset(data_from_ancestor.elastic_overscroll);
   } else if (!layer->scroll_parent()) {
     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 =
-          layer->position_constraint().is_fixed_to_right_edge();
+          PositionConstraint(layer).is_fixed_to_right_edge();
       node->data.affected_by_inner_viewport_bounds_delta_y =
-          layer->position_constraint().is_fixed_to_bottom_edge();
+          PositionConstraint(layer).is_fixed_to_bottom_edge();
       if (node->data.affected_by_inner_viewport_bounds_delta_x ||
           node->data.affected_by_inner_viewport_bounds_delta_y) {
         data_for_children->transform_tree
             ->AddNodeAffectedByInnerViewportBoundsDelta(node->id);
       }
     } else if (data_from_ancestor.affected_by_outer_viewport_bounds_delta) {
       node->data.affected_by_outer_viewport_bounds_delta_x =
-          layer->position_constraint().is_fixed_to_right_edge();
+          PositionConstraint(layer).is_fixed_to_right_edge();
       node->data.affected_by_outer_viewport_bounds_delta_y =
-          layer->position_constraint().is_fixed_to_bottom_edge();
+          PositionConstraint(layer).is_fixed_to_bottom_edge();
       if (node->data.affected_by_outer_viewport_bounds_delta_x ||
           node->data.affected_by_outer_viewport_bounds_delta_y) {
         data_for_children->transform_tree
             ->AddNodeAffectedByOuterViewportBoundsDelta(node->id);
       }
     }
   }
 
   node->data.local = layer->transform();
   node->data.update_pre_local_transform(TransformOrigin(layer));
@@ skipping 38 matching lines @@
   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());
 }
 
+static inline bool IsRootForIsolatedGroup(Layer* layer) {
+  return layer->is_root_for_isolated_group();
+}
+
+static inline bool IsRootForIsolatedGroup(LayerImpl* layer) {
+  return false;
+}
+
+static inline int NumDescendantsThatDrawContent(Layer* layer) {
+  return layer->NumDescendantsThatDrawContent();
+}
+
+static inline int NumDescendantsThatDrawContent(LayerImpl* layer) {
+  return layer->test_properties()->num_descendants_that_draw_content;
+}
+
 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();
   if (is_root)
     return true;
@@ skipping 13 matching lines @@
   if (!layer->filters().IsEmpty() || !layer->background_filters().IsEmpty()) {
     return true;
   }
 
   // If the layer will use a CSS filter.  In this case, the animation
   // will start and add a filter to this layer, so it needs a surface.
   if (layer->HasPotentiallyRunningFilterAnimation()) {
     return true;
   }
 
-  int num_descendants_that_draw_content =
-      layer->NumDescendantsThatDrawContent();
+  int num_descendants_that_draw_content = NumDescendantsThatDrawContent(layer);
 
   // If the layer flattens its subtree, but it is treated as a 3D object by its
   // parent (i.e. parent participates in a 3D rendering context).
   if (LayerIsInExisting3DRenderingContext(layer) &&
-      layer->should_flatten_transform() &&
-      num_descendants_that_draw_content > 0) {
+      ShouldFlattenTransform(layer) && num_descendants_that_draw_content > 0) {
     TRACE_EVENT_INSTANT0(
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface flattening",
         TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   // If the layer has blending.
   // TODO(rosca): this is temporary, until blending is implemented for other
   // types of quads than RenderPassDrawQuad. Layers having descendants that draw
   // content will still create a separate rendering surface.
@@ skipping 16 matching lines @@
 
   // If the layer has some translucency and does not have a preserves-3d
   // transform style.  This condition only needs a render surface if two or more
   // layers in the subtree overlap. But checking layer overlaps is unnecessarily
   // costly so instead we conservatively create a surface whenever at least two
   // layers draw content for this subtree.
   bool at_least_two_layers_in_subtree_draw_content =
       num_descendants_that_draw_content > 0 &&
       (layer->DrawsContent() || num_descendants_that_draw_content > 1);
 
-  if (layer->EffectiveOpacity() != 1.f && layer->should_flatten_transform() &&
+  if (layer->EffectiveOpacity() != 1.f && ShouldFlattenTransform(layer) &&
       at_least_two_layers_in_subtree_draw_content) {
     TRACE_EVENT_INSTANT0(
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface opacity",
         TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!is_root);
     return true;
   }
   // If the layer has isolation.
   // TODO(rosca): to be optimized - create separate rendering surface only when
   // the blending descendants might have access to the content behind this layer
   // (layer has transparent background or descendants overflow).
   // https://code.google.com/p/chromium/issues/detail?id=301738
-  if (layer->is_root_for_isolated_group()) {
+  if (IsRootForIsolatedGroup(layer)) {
     TRACE_EVENT_INSTANT0(
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface isolation",
         TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   // If we force it.
   if (ForceRenderSurface(layer))
     return true;
 
@@ skipping 422 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