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

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 453 matching lines @@
 
 bool IsAnimatingOpacity(Layer* layer) {
   return layer->HasPotentiallyRunningOpacityAnimation() ||
          layer->OpacityCanAnimateOnImplThread();
 }
 
 bool IsAnimatingOpacity(LayerImpl* layer) {
   return layer->HasPotentiallyRunningOpacityAnimation();
 }
 
+static inline bool DoubleSided(Layer* layer) {
+  return layer->double_sided();
+}
+
+static inline bool DoubleSided(LayerImpl* layer) {
+  return layer->test_properties()->double_sided;
+}
+
+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());
 }
 
 template <typename LayerType>
 bool ShouldCreateRenderSurface(LayerType* layer,
                                gfx::Transform current_transform,
@@ skipping 85 matching lines @@
   // (layer has transparent background or descendants overflow).
   // https://code.google.com/p/chromium/issues/detail?id=301738
   if (layer->is_root_for_isolated_group()) {
     TRACE_EVENT_INSTANT0(
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface isolation",
         TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   // If we force it.
-  if (layer->force_render_surface())
+  if (ForceRenderSurface(layer))
     return true;
 
   // If we'll make a copy of the layer's contents.
   if (layer->HasCopyRequest())
     return true;
 
   return false;
 }
 
 template <typename LayerType>
@@ skipping 23 matching lines @@
     return false;
   }
 
   EffectNode node;
   node.owner_id = layer->id();
   node.data.opacity = layer->EffectiveOpacity();
   node.data.has_render_surface = should_create_render_surface;
   node.data.has_copy_request = layer->HasCopyRequest();
   node.data.has_background_filters = !layer->background_filters().IsEmpty();
   node.data.has_animated_opacity = has_animated_opacity;
-  node.data.double_sided = layer->double_sided();
+  node.data.double_sided = DoubleSided(layer);
 
   if (!is_root) {
     // The effect node's transform id is used only when we create a render
     // surface. So, we can leave the default value when we don't create a render
     // surface.
     if (should_create_render_surface) {
       // In this case, we will create a transform node, so it's safe to use the
       // next available id from the transform tree as this effect node's
       // transform id.
       node.data.transform_id =
@@ skipping 117 matching lines @@
     // 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);
 
     // A double-sided layer's backface can been shown when its visibile.
-    if (layer->double_sided())
+    if (DoubleSided(layer))
       layer->SetShouldCheckBackfaceVisibility(false);
     // The backface of a layer that uses local transform for backface visibility
     // is not visible when it does not create a transform node as its local
     // transform is identity or 2d translation and is not animating.
     else if (use_local_transform && !created_transform_node)
       layer->SetShouldCheckBackfaceVisibility(false);
     else
       layer->SetShouldCheckBackfaceVisibility(true);
   }
 }
@@ skipping 232 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