Replace LayerImpl::sorting_context_id with transform reference.

cc/trees/layer_tree_impl_unittest.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/layer_tree_impl.h"
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 62 matching lines @@
     std::unique_ptr<LayerImpl> left_child =
         LayerImpl::Create(host_impl().active_tree(), left_child_id);
     std::unique_ptr<LayerImpl> right_child =
         LayerImpl::Create(host_impl().active_tree(), right_child_id);
 
     gfx::Size bounds(100, 100);
     {
       gfx::Transform translate_z;
       translate_z.Translate3d(0, 0, root_depth);
       root->test_properties()->transform = translate_z;
+      root->test_properties()->sorting_context_id = root_sorting_context;
       root->SetBounds(bounds);
       root->SetDrawsContent(true);
-      root->Set3dSortingContextId(root_sorting_context);
     }
     {
       gfx::Transform translate_z;
       translate_z.Translate3d(0, 0, left_child_depth);
       left_child->test_properties()->transform = translate_z;
+      left_child->test_properties()->sorting_context_id =
+          left_child_sorting_context;
       left_child->SetBounds(bounds);
       left_child->SetDrawsContent(true);
-      left_child->Set3dSortingContextId(left_child_sorting_context);
       left_child->test_properties()->should_flatten_transform = false;
     }
     {
       gfx::Transform translate_z;
       translate_z.Translate3d(0, 0, right_child_depth);
       right_child->test_properties()->transform = translate_z;
+      right_child->test_properties()->sorting_context_id =
+          right_child_sorting_context;
       right_child->SetBounds(bounds);
       right_child->SetDrawsContent(true);
-      right_child->Set3dSortingContextId(right_child_sorting_context);
     }
 
     root->test_properties()->AddChild(std::move(left_child));
     root->test_properties()->AddChild(std::move(right_child));
 
     host_impl().SetViewportSize(root->bounds());
     host_impl().active_tree()->SetRootLayerForTesting(std::move(root));
     host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
     CHECK_EQ(1u, RenderSurfaceLayerList().size());
 
@@ skipping 821 matching lines @@
                                        /* sorting_contexts */ 10, 10, 10,
                                        /* depths */ 0, -1, -1);
   EXPECT_EQ(1, hit_layer_id);
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
   LayerImpl* root = root_layer();
   root->SetBounds(gfx::Size(100, 100));
   root->SetDrawsContent(true);
   root->test_properties()->should_flatten_transform = false;
-  root->Set3dSortingContextId(1);
+  root->test_properties()->sorting_context_id = 1;
   {
     // child 1 and child2 are initialized to overlap between x=50 and x=60.
     // grand_child is set to overlap both child1 and child2 between y=50 and
     // y=60.  The expected stacking order is: (front) child2, (second)
     // grand_child, (third) child1, and (back) the root layer behind all other
     // layers.
 
     std::unique_ptr<LayerImpl> child1 =
         LayerImpl::Create(host_impl().active_tree(), 2);
     std::unique_ptr<LayerImpl> child2 =
         LayerImpl::Create(host_impl().active_tree(), 3);
     std::unique_ptr<LayerImpl> grand_child1 =
         LayerImpl::Create(host_impl().active_tree(), 4);
 
     child1->SetPosition(gfx::PointF(10.f, 10.f));
     child1->SetBounds(gfx::Size(50, 50));
     child1->SetDrawsContent(true);
     child1->test_properties()->should_flatten_transform = false;
-    child1->Set3dSortingContextId(1);
+    child1->test_properties()->sorting_context_id = 1;
 
     child2->SetPosition(gfx::PointF(50.f, 10.f));
     child2->SetBounds(gfx::Size(50, 50));
     gfx::Transform translate_z;
     translate_z.Translate3d(0, 0, 10.f);
     child2->test_properties()->transform = translate_z;
     child2->SetDrawsContent(true);
     child2->test_properties()->should_flatten_transform = false;
-    child2->Set3dSortingContextId(1);
+    child2->test_properties()->sorting_context_id = 1;
 
     // Remember that grand_child is positioned with respect to its parent (i.e.
     // child1).  In screen space, the intended position is (10, 50), with size
     // 100 x 50.
     grand_child1->SetPosition(gfx::PointF(0.f, 40.f));
     grand_child1->SetBounds(gfx::Size(100, 50));
     grand_child1->SetDrawsContent(true);
     grand_child1->test_properties()->should_flatten_transform = false;
 
     child1->test_properties()->AddChild(std::move(grand_child1));
@@ skipping 1424 matching lines @@
     auto weak_promise = promise->AsWeakPtr();
     host_impl().active_tree()->QueueSwapPromise(std::move(promise));
     host_impl().active_tree()->BreakSwapPromises(
         SwapPromise::DidNotSwapReason::SWAP_FAILS);
     EXPECT_FALSE(weak_promise);
   }
 }
 
 }  // namespace
 }  // namespace cc