Replace LayerImpl::sorting_context_id with transform reference.

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 57 matching lines @@
       draws_content_(false),
       is_drawn_render_surface_layer_list_member_(false),
       was_ever_ready_since_last_transform_animation_(true),
       background_color_(0),
       safe_opaque_background_color_(0),
       draw_blend_mode_(SkBlendMode::kSrcOver),
       transform_tree_index_(TransformTree::kInvalidNodeId),
       effect_tree_index_(EffectTree::kInvalidNodeId),
       clip_tree_index_(ClipTree::kInvalidNodeId),
       scroll_tree_index_(ScrollTree::kInvalidNodeId),
-      sorting_context_id_(0),
       current_draw_mode_(DRAW_MODE_NONE),
       mutable_properties_(MutableProperty::kNone),
       debug_info_(nullptr),
       has_preferred_raster_bounds_(false),
       has_will_change_transform_hint_(false),
       needs_push_properties_(false),
       scrollbars_hidden_(false) {
   DCHECK_GT(layer_id_, 0);
 
   DCHECK(layer_tree_impl_);
@@ skipping 74 matching lines @@
 
 void LayerImpl::ClearRenderSurfaceLayerList() {
   if (render_surface_)
     render_surface_->ClearLayerLists();
 }
 
 void LayerImpl::PopulateSharedQuadState(SharedQuadState* state) const {
   state->SetAll(draw_properties_.target_space_transform, bounds(),
                 draw_properties_.visible_layer_rect, draw_properties_.clip_rect,
                 draw_properties_.is_clipped, draw_properties_.opacity,
-                draw_blend_mode_, sorting_context_id_);
+                draw_blend_mode_, GetSortingContextId());
 }
 
 void LayerImpl::PopulateScaledSharedQuadState(
     SharedQuadState* state,
     float layer_to_content_scale_x,
     float layer_to_content_scale_y) const {
   gfx::Transform scaled_draw_transform =
       draw_properties_.target_space_transform;
   scaled_draw_transform.Scale(SK_MScalar1 / layer_to_content_scale_x,
                               SK_MScalar1 / layer_to_content_scale_y);
   gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(
       bounds(), layer_to_content_scale_x, layer_to_content_scale_y);
   gfx::Rect scaled_visible_layer_rect = gfx::ScaleToEnclosingRect(
       visible_layer_rect(), layer_to_content_scale_x, layer_to_content_scale_y);
   scaled_visible_layer_rect.Intersect(gfx::Rect(scaled_bounds));
 
   state->SetAll(scaled_draw_transform, scaled_bounds, scaled_visible_layer_rect,
                 draw_properties().clip_rect, draw_properties().is_clipped,
                 draw_properties().opacity, draw_blend_mode_,
-                sorting_context_id_);
+                GetSortingContextId());
 }
 
 bool LayerImpl::WillDraw(DrawMode draw_mode,
                          ResourceProvider* resource_provider) {
   // WillDraw/DidDraw must be matched.
   DCHECK_NE(DRAW_MODE_NONE, draw_mode);
   DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
   current_draw_mode_ = draw_mode;
   return true;
 }
@@ skipping 142 matching lines @@
   layer->non_fast_scrollable_region_ = non_fast_scrollable_region_;
   layer->touch_event_handler_region_ = touch_event_handler_region_;
   layer->background_color_ = background_color_;
   layer->safe_opaque_background_color_ = safe_opaque_background_color_;
   layer->draw_blend_mode_ = draw_blend_mode_;
   layer->position_ = position_;
   layer->transform_tree_index_ = transform_tree_index_;
   layer->effect_tree_index_ = effect_tree_index_;
   layer->clip_tree_index_ = clip_tree_index_;
   layer->scroll_tree_index_ = scroll_tree_index_;
-  layer->sorting_context_id_ = sorting_context_id_;
   layer->has_will_change_transform_hint_ = has_will_change_transform_hint_;
   layer->scrollbars_hidden_ = scrollbars_hidden_;
 
   if (layer_property_changed_) {
     layer->layer_tree_impl()->set_needs_update_draw_properties();
     layer->layer_property_changed_ = true;
   }
 
   // If whether layer has render surface changes, we need to update draw
   // properties.
@@ skipping 76 matching lines @@
 
   list = new base::ListValue;
   for (size_t i = 0; i < test_properties()->children.size(); ++i)
     list->Append(test_properties()->children[i]->LayerTreeAsJson());
   result->Set("Children", list);
 
   return result;
 }
 
 bool LayerImpl::LayerPropertyChanged() const {
-  if (layer_property_changed_ ||
-      (GetPropertyTrees() && GetPropertyTrees()->full_tree_damaged))
+  if (layer_property_changed_ || GetPropertyTrees()->full_tree_damaged)
     return true;
   if (transform_tree_index() == TransformTree::kInvalidNodeId)
     return false;
   TransformNode* transform_node =
       GetTransformTree().Node(transform_tree_index());
   if (transform_node && transform_node->transform_changed)
     return true;
   if (effect_tree_index() == EffectTree::kInvalidNodeId)
     return false;
   EffectNode* effect_node = GetEffectTree().Node(effect_tree_index());
@@ skipping 296 matching lines @@
 
   mutable_properties_ = properties;
   // If this layer is already in the element map, update its properties.
   layer_tree_impl_->AddToElementMap(this);
 }
 
 void LayerImpl::SetPosition(const gfx::PointF& position) {
   position_ = position;
 }
 
-void LayerImpl::Set3dSortingContextId(int id) {
-  sorting_context_id_ = id;
-}
-
 bool LayerImpl::TransformIsAnimating() const {
   return GetMutatorHost()->IsAnimatingTransformProperty(
       element_id(), GetElementTypeForAnimation());
 }
 
 bool LayerImpl::HasPotentiallyRunningTransformAnimation() const {
   return GetMutatorHost()->HasPotentiallyRunningTransformAnimation(
       element_id(), GetElementTypeForAnimation());
 }
 
@@ skipping 246 matching lines @@
     return false;
   if (static_cast<int>(offset_to_transform_parent().x()) !=
       offset_to_transform_parent().x())
     return false;
   if (static_cast<int>(offset_to_transform_parent().y()) !=
       offset_to_transform_parent().y())
     return false;
   return true;
 }
 
+int LayerImpl::GetSortingContextId() const {
+  return layer_tree_impl()
+      ->property_trees()
+      ->transform_tree.Node(transform_tree_index())
+      ->sorting_context_id;
+}
+
 Region LayerImpl::GetInvalidationRegionForDebugging() {
   return Region(update_rect_);
 }
 
 gfx::Rect LayerImpl::GetEnclosingRectInTargetSpace() const {
   return MathUtil::MapEnclosingClippedRect(DrawTransform(),
                                            gfx::Rect(bounds()));
 }
 
 gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
@@ skipping 49 matching lines @@
 
 ScrollTree& LayerImpl::GetScrollTree() const {
   return GetPropertyTrees()->scroll_tree;
 }
 
 TransformTree& LayerImpl::GetTransformTree() const {
   return GetPropertyTrees()->transform_tree;
 }
 
 }  // namespace cc