cc: Make LayerTreeHost a protected Layer member.

cc/layers/layer_unittest.cc

 // Copyright 2011 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.h"
 
 #include <stddef.h>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
@@ skipping 40 matching lines @@
 
 #define EXPECT_SET_NEEDS_FULL_TREE_SYNC(expect, code_to_test)          \
   do {                                                                 \
     EXPECT_CALL(*layer_tree_, SetNeedsFullTreeSync()).Times((expect)); \
     code_to_test;                                                      \
     Mock::VerifyAndClearExpectations(layer_tree_);                     \
   } while (false)
 
 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test)                       \
   code_to_test;                                                                \
-  root->layer_tree_host()->BuildPropertyTreesForTesting();                     \
+  root->GetLayerTree()->BuildPropertyTreesForTesting();                        \
   EXPECT_TRUE(root->subtree_property_changed());                               \
   EXPECT_TRUE(                                                                 \
       root->GetLayerTree()->LayerNeedsPushPropertiesForTesting(root.get()));   \
   EXPECT_TRUE(child->subtree_property_changed());                              \
   EXPECT_TRUE(                                                                 \
       child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(child.get())); \
   EXPECT_TRUE(grand_child->subtree_property_changed());                        \
   EXPECT_TRUE(grand_child->GetLayerTree()->LayerNeedsPushPropertiesForTesting( \
       grand_child.get()));
 
 #define EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(code_to_test)                 \
   code_to_test;                                                                \
   EXPECT_FALSE(root->subtree_property_changed());                              \
   EXPECT_FALSE(                                                                \
       root->GetLayerTree()->LayerNeedsPushPropertiesForTesting(root.get()));   \
   EXPECT_FALSE(child->subtree_property_changed());                             \
   EXPECT_FALSE(                                                                \
       child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(child.get())); \
   EXPECT_FALSE(grand_child->subtree_property_changed());                       \
   EXPECT_FALSE(                                                                \
       grand_child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(         \
           grand_child.get()));
 
 #define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test)                    \
   code_to_test;                                                                \
-  root->layer_tree_host()->BuildPropertyTreesForTesting();                     \
+  root->GetLayerTree()->BuildPropertyTreesForTesting();                        \
   EXPECT_TRUE(root->layer_property_changed());                                 \
   EXPECT_FALSE(root->subtree_property_changed());                              \
   EXPECT_TRUE(                                                                 \
       root->GetLayerTree()->LayerNeedsPushPropertiesForTesting(root.get()));   \
   EXPECT_FALSE(child->layer_property_changed());                               \
   EXPECT_FALSE(child->subtree_property_changed());                             \
   EXPECT_FALSE(                                                                \
       child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(child.get())); \
   EXPECT_FALSE(grand_child->layer_property_changed());                         \
   EXPECT_FALSE(grand_child->subtree_property_changed());                       \
@@ skipping 1784 matching lines @@
 
  private:
   FakeLayerTreeHostClient client_;
   StubLayerTreeHostSingleThreadClient single_thread_client_;
   TestSharedBitmapManager shared_bitmap_manager_;
   TestTaskGraphRunner task_graph_runner_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
 };
 
 void AssertLayerTreeHostMatchesForSubtree(Layer* layer, LayerTreeHost* host) {
-  EXPECT_EQ(host, layer->layer_tree_host());
+  EXPECT_EQ(host, layer->GetLayerTreeHostForTesting());
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     AssertLayerTreeHostMatchesForSubtree(layer->children()[i].get(), host);
 
   if (layer->mask_layer())
     AssertLayerTreeHostMatchesForSubtree(layer->mask_layer(), host);
 
   if (layer->replica_layer())
     AssertLayerTreeHostMatchesForSubtree(layer->replica_layer(), host);
 }
@@ skipping 33 matching lines @@
 }
 
 TEST_F(LayerLayerTreeHostTest, AddingLayerSubtree) {
   scoped_refptr<Layer> parent = Layer::Create();
   LayerTreeHostFactory factory;
   std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   LayerTree* layer_tree = layer_tree_host->GetLayerTree();
 
   layer_tree->SetRootLayer(parent.get());
 
-  EXPECT_EQ(parent->layer_tree_host(), layer_tree_host.get());
+  EXPECT_EQ(parent->GetLayerTreeHostForTesting(), layer_tree_host.get());
 
   // Adding a subtree to a layer already associated with a host should set the
   // host pointer on all layers in that subtree.
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   child->AddChild(grand_child);
 
   // Masks, replicas, and replica masks should pick up the new host too.
   scoped_refptr<Layer> child_mask = Layer::Create();
   child->SetMaskLayer(child_mask.get());
@@ skipping 59 matching lines @@
                                        first_layer_tree_host.get());
 
   // Now reparent the subtree starting at second_child to a layer in a different
   // tree.
   std::unique_ptr<LayerTreeHost> second_layer_tree_host = factory.Create();
   second_layer_tree_host->GetLayerTree()->SetRootLayer(second_parent.get());
 
   second_parent->AddChild(second_child);
 
   // The moved layer and its children should point to the new host.
-  EXPECT_EQ(second_layer_tree_host.get(), second_child->layer_tree_host());
   EXPECT_EQ(second_layer_tree_host.get(),
-            second_grand_child->layer_tree_host());
+            second_child->GetLayerTreeHostForTesting());
+  EXPECT_EQ(second_layer_tree_host.get(),
+            second_grand_child->GetLayerTreeHostForTesting());
 
   // Test over, cleanup time.
   first_layer_tree_host->GetLayerTree()->SetRootLayer(nullptr);
   second_layer_tree_host->GetLayerTree()->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, ReplaceMaskAndReplicaLayer) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> mask = Layer::Create();
   scoped_refptr<Layer> replica = Layer::Create();
   scoped_refptr<Layer> mask_child = Layer::Create();
   scoped_refptr<Layer> replica_child = Layer::Create();
   scoped_refptr<Layer> mask_replacement = Layer::Create();
   scoped_refptr<Layer> replica_replacement = Layer::Create();
 
   parent->SetMaskLayer(mask.get());
   parent->SetReplicaLayer(replica.get());
   mask->AddChild(mask_child);
   replica->AddChild(replica_child);
 
   LayerTreeHostFactory factory;
   std::unique_ptr<LayerTreeHost> layer_tree_host = factory.Create();
   layer_tree_host->GetLayerTree()->SetRootLayer(parent.get());
 
   AssertLayerTreeHostMatchesForSubtree(parent.get(), layer_tree_host.get());
 
   // Replacing the mask should clear out the old mask's subtree's host pointers.
   parent->SetMaskLayer(mask_replacement.get());
-  EXPECT_EQ(nullptr, mask->layer_tree_host());
-  EXPECT_EQ(nullptr, mask_child->layer_tree_host());
+  EXPECT_EQ(nullptr, mask->GetLayerTreeHostForTesting());
+  EXPECT_EQ(nullptr, mask_child->GetLayerTreeHostForTesting());
 
   // Same for replacing a replica layer.
   parent->SetReplicaLayer(replica_replacement.get());
-  EXPECT_EQ(nullptr, replica->layer_tree_host());
-  EXPECT_EQ(nullptr, replica_child->layer_tree_host());
+  EXPECT_EQ(nullptr, replica->GetLayerTreeHostForTesting());
+  EXPECT_EQ(nullptr, replica_child->GetLayerTreeHostForTesting());
 
   // Test over, cleanup time.
   layer_tree_host->GetLayerTree()->SetRootLayer(nullptr);
 }
 
 TEST_F(LayerLayerTreeHostTest, DestroyHostWithNonNullRootLayer) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   root->AddChild(child);
   LayerTreeHostFactory factory;
@@ skipping 12 matching lines @@
   for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
     for (int layer_opaque = 0; layer_opaque < 2; ++layer_opaque) {
       for (int host_opaque = 0; host_opaque < 2; ++host_opaque) {
         layer->SetContentsOpaque(!!contents_opaque);
         layer->SetBackgroundColor(layer_opaque ? SK_ColorRED
                                                : SK_ColorTRANSPARENT);
         layer_tree->set_background_color(host_opaque ? SK_ColorRED
                                                      : SK_ColorTRANSPARENT);
 
         layer_tree->property_trees()->needs_rebuild = true;
-        layer_tree_host->BuildPropertyTreesForTesting();
+        layer_tree_host->GetLayerTree()->BuildPropertyTreesForTesting();
         SkColor safe_color = layer->SafeOpaqueBackgroundColor();
         if (contents_opaque) {
           EXPECT_EQ(SkColorGetA(safe_color), 255u)
               << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
               << host_opaque << "\n";
         } else {
           EXPECT_NE(SkColorGetA(safe_color), 255u)
               << "Flags: " << contents_opaque << ", " << layer_opaque << ", "
               << host_opaque << "\n";
         }
@@ skipping 445 matching lines @@
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(ElementId(2, 0), impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc