Replace LayerImpl::sorting_context_id with transform reference.

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 437 matching lines @@
 
     data_for_children->clip_tree_parent =
         data_for_children->property_trees->clip_tree.Insert(node, parent_id);
     data_for_children->property_trees->clip_id_to_index_map[layer->id()] =
         data_for_children->clip_tree_parent;
   }
 
   layer->SetClipTreeIndex(data_for_children->clip_tree_parent);
 }
 
+static inline int SortingContextId(Layer* layer) {
+  return layer->sorting_context_id();
+}
+
+static inline int SortingContextId(LayerImpl* layer) {
+  return layer->test_properties()->sorting_context_id;
+}
+
+static inline bool Is3dSorted(Layer* layer) {
+  return layer->Is3dSorted();
+}
+
+static inline bool Is3dSorted(LayerImpl* layer) {
+  return layer->test_properties()->sorting_context_id != 0;
+}
+
 template <typename LayerType>
 static inline bool IsAtBoundaryOf3dRenderingContext(LayerType* layer) {
   return Parent(layer)
-             ? Parent(layer)->sorting_context_id() !=
-                   layer->sorting_context_id()
-             : layer->Is3dSorted();
+             ? SortingContextId(Parent(layer)) != SortingContextId(layer)
+             : Is3dSorted(layer);
 }
 
 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 130 matching lines @@
   TransformNode* node =
       data_for_children->property_trees->transform_tree.back();
   layer->SetTransformTreeIndex(node->id);
   data_for_children->property_trees->transform_id_to_index_map[layer->id()] =
       node->id;
 
   node->scrolls = is_scrollable;
   node->should_be_snapped = is_snapped;
   node->flattens_inherited_transform = data_for_children->should_flatten;
 
-  node->sorting_context_id = layer->sorting_context_id();
+  node->sorting_context_id = SortingContextId(layer);
 
   if (layer == data_from_ancestor.page_scale_layer)
     data_for_children->in_subtree_of_page_scale_layer = true;
   node->in_subtree_of_page_scale_layer =
       data_for_children->in_subtree_of_page_scale_layer;
 
   // Surfaces inherently flatten transforms.
   data_for_children->should_flatten =
       ShouldFlattenTransform(layer) || has_surface;
   DCHECK_GT(data_from_ancestor.property_trees->effect_tree.size(), 0u);
@@ skipping 141 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() && Parent(layer) && Parent(layer)->Is3dSorted() &&
-         (Parent(layer)->sorting_context_id() == layer->sorting_context_id());
+  return Is3dSorted(layer) && Parent(layer) && Is3dSorted(Parent(layer)) &&
+         (SortingContextId(Parent(layer)) == SortingContextId(layer));
 }
 
 static inline bool IsRootForIsolatedGroup(Layer* layer) {
   return layer->is_root_for_isolated_group();
 }
 
 static inline bool IsRootForIsolatedGroup(LayerImpl* layer) {
   return false;
 }
 
@@ skipping 401 matching lines @@
         Parent(layer)->use_local_transform_for_backface_visibility());
     layer->SetShouldCheckBackfaceVisibility(
         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);
+        !Is3dSorted(layer) ||
+        (Is3dSorted(layer) && 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 (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);
@@ skipping 291 matching lines @@
     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);
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc