cc: Clean up root_layer code in LTI

cc/trees/tree_synchronizer_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/trees/tree_synchronizer.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 157 matching lines @@
     }
     return true;
   }
 };
 
 // Attempts to synchronizes a null tree. This should not crash, and should
 // return a null tree.
 TEST_F(TreeSynchronizerTest, SyncNullTree) {
   TreeSynchronizer::SynchronizeTrees(static_cast<Layer*>(NULL),
                                      host_->active_tree());
-  EXPECT_TRUE(!host_->active_tree()->root_layer());
+  EXPECT_TRUE(!host_->active_tree()->root_layer_for_testing());
 }
 
 // Constructs a very simple tree and synchronizes it without trying to reuse any
 // preexisting layers.
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeFromEmpty) {
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
   layer_tree_root->AddChild(Layer::Create());
   layer_tree_root->AddChild(Layer::Create());
 
   host_->SetRootLayer(layer_tree_root);
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
 
   ExpectTreesAreIdentical(layer_tree_root.get(),
-                          host_->active_tree()->root_layer(),
+                          host_->active_tree()->root_layer_for_testing(),
                           host_->active_tree());
 }
 
 // Constructs a very simple tree and synchronizes it attempting to reuse some
 // layers
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeReusingLayers) {
   std::vector<int> layer_impl_destruction_list;
 
   scoped_refptr<Layer> layer_tree_root =
       MockLayer::Create(&layer_impl_destruction_list);
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   int second_layer_impl_id = layer_tree_root->children()[1]->id();
 
   host_->SetRootLayer(layer_tree_root);
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  LayerImpl* layer_impl_tree_root =
+      host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Add a new layer to the Layer side
   layer_tree_root->children()[0]->AddChild(
       MockLayer::Create(&layer_impl_destruction_list));
   // Remove one.
   layer_tree_root->children()[1]->RemoveFromParent();
 
   // Synchronize again. After the sync the trees should be equivalent and we
   // should have created and destroyed one LayerImpl.
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
 
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   ASSERT_EQ(1u, layer_impl_destruction_list.size());
   EXPECT_EQ(second_layer_impl_id, layer_impl_destruction_list[0]);
 
   host_->active_tree()->DetachLayers();
 }
 
 // Constructs a very simple tree and checks that a stacking-order change is
 // tracked properly.
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndTrackStackingOrderChange) {
   std::vector<int> layer_impl_destruction_list;
 
   // Set up the tree and sync once. child2 needs to be synced here, too, even
   // though we remove it to set up the intended scenario.
   scoped_refptr<Layer> layer_tree_root =
       MockLayer::Create(&layer_impl_destruction_list);
   scoped_refptr<Layer> child2 = MockLayer::Create(&layer_impl_destruction_list);
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   layer_tree_root->AddChild(child2);
   int child1_id = layer_tree_root->children()[0]->id();
   int child2_id = layer_tree_root->children()[1]->id();
 
   host_->SetRootLayer(layer_tree_root);
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  LayerImpl* layer_impl_tree_root =
+      host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   host_->active_tree()->ResetAllChangeTracking();
 
   // re-insert the layer and sync again.
   child2->RemoveFromParent();
   layer_tree_root->AddChild(child2);
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Check that the impl thread properly tracked the change.
   EXPECT_FALSE(layer_impl_tree_root->LayerPropertyChanged());
   EXPECT_FALSE(
       host_->active_tree()->LayerById(child1_id)->LayerPropertyChanged());
@@ skipping 14 matching lines @@
   gfx::PointF root_position = gfx::PointF(2.3f, 7.4f);
   layer_tree_root->SetPosition(root_position);
 
   gfx::Size second_child_bounds = gfx::Size(25, 53);
   layer_tree_root->children()[1]->SetBounds(second_child_bounds);
   layer_tree_root->children()[1]->SavePaintProperties();
   int second_child_id = layer_tree_root->children()[1]->id();
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  LayerImpl* layer_impl_tree_root =
+      host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Check that the property values we set on the Layer tree are reflected in
   // the LayerImpl tree.
   gfx::PointF root_layer_impl_position = layer_impl_tree_root->position();
   EXPECT_EQ(root_position.x(), root_layer_impl_position.x());
@@ skipping 27 matching lines @@
   layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list));
 
   scoped_refptr<Layer> layer_c = layer_b->children()[0];
   layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list));
   scoped_refptr<Layer> layer_d = layer_b->children()[1];
 
   host_->SetRootLayer(layer_tree_root);
 
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  LayerImpl* layer_impl_tree_root =
+      host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Now restructure the tree to look like this:
   // root --- D ---+--- A
   //               |
   //               +--- C --- B
   layer_tree_root->RemoveAllChildren();
   layer_d->RemoveAllChildren();
   layer_tree_root->AddChild(layer_d);
   layer_a->RemoveAllChildren();
   layer_d->AddChild(layer_a);
   layer_c->RemoveAllChildren();
   layer_d->AddChild(layer_c);
   layer_b->RemoveAllChildren();
   layer_c->AddChild(layer_b);
 
   // After another synchronize our trees should match and we should not have
   // destroyed any LayerImpls
   TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
                                      host_->active_tree());
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   EXPECT_EQ(0u, layer_impl_destruction_list.size());
 
   host_->active_tree()->DetachLayers();
 }
 
 // Constructs a very simple tree, synchronizes it, then synchronizes to a
 // totally new tree. All layers from the old tree should be deleted.
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeThenDestroy) {
   std::vector<int> layer_impl_destruction_list;
 
   scoped_refptr<Layer> old_layer_tree_root =
       MockLayer::Create(&layer_impl_destruction_list);
   old_layer_tree_root->AddChild(
       MockLayer::Create(&layer_impl_destruction_list));
   old_layer_tree_root->AddChild(
       MockLayer::Create(&layer_impl_destruction_list));
 
   host_->SetRootLayer(old_layer_tree_root);
 
   int old_tree_root_layer_id = old_layer_tree_root->id();
   int old_tree_first_child_layer_id = old_layer_tree_root->children()[0]->id();
   int old_tree_second_child_layer_id = old_layer_tree_root->children()[1]->id();
 
   TreeSynchronizer::SynchronizeTrees(old_layer_tree_root.get(),
                                      host_->active_tree());
-  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  LayerImpl* layer_impl_tree_root =
+      host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(old_layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
   TreeSynchronizer::PushLayerProperties(old_layer_tree_root->layer_tree_host(),
                                         host_->active_tree());
 
   // Remove all children on the Layer side.
   old_layer_tree_root->RemoveAllChildren();
 
   // Synchronize again. After the sync all LayerImpls from the old tree should
   // be deleted.
   scoped_refptr<Layer> new_layer_tree_root = Layer::Create();
   host_->SetRootLayer(new_layer_tree_root);
 
   TreeSynchronizer::SynchronizeTrees(new_layer_tree_root.get(),
                                      host_->active_tree());
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(new_layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   ASSERT_EQ(3u, layer_impl_destruction_list.size());
 
   EXPECT_TRUE(std::find(layer_impl_destruction_list.begin(),
                         layer_impl_destruction_list.end(),
                         old_tree_root_layer_id) !=
               layer_impl_destruction_list.end());
   EXPECT_TRUE(std::find(layer_impl_destruction_list.begin(),
@@ skipping 25 matching lines @@
   scoped_refptr<Layer> replica_layer_with_mask = Layer::Create();
   scoped_refptr<Layer> replica_mask_layer = Layer::Create();
   replica_layer_with_mask->SetMaskLayer(replica_mask_layer.get());
   layer_tree_root->children()[2]->SetReplicaLayer(
       replica_layer_with_mask.get());
 
   host_->SetRootLayer(layer_tree_root);
   host_->BuildPropertyTreesForTesting();
   host_->CommitAndCreateLayerImplTree();
 
-  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  LayerImpl* layer_impl_tree_root =
+      host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the mask layer.
   layer_tree_root->children()[0]->SetMaskLayer(NULL);
   host_->BuildPropertyTreesForTesting();
   host_->CommitAndCreateLayerImplTree();
 
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the replica layer.
   layer_tree_root->children()[1]->SetReplicaLayer(NULL);
   host_->BuildPropertyTreesForTesting();
   host_->CommitAndCreateLayerImplTree();
 
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the replica mask.
   replica_layer_with_mask->SetMaskLayer(NULL);
   host_->BuildPropertyTreesForTesting();
   host_->CommitAndCreateLayerImplTree();
 
-  layer_impl_tree_root = host_->active_tree()->root_layer();
+  layer_impl_tree_root = host_->active_tree()->root_layer_for_testing();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   host_->active_tree()->DetachLayers();
 }
 
 TEST_F(TreeSynchronizerTest, SynchronizeCurrentlyScrollingNode) {
   LayerTreeSettings settings;
   FakeLayerTreeHostImplClient client;
   FakeImplTaskRunnerProvider task_runner_provider;
@@ skipping 16 matching lines @@
 
   transient_scroll_layer->SetScrollClipLayerId(
       transient_scroll_clip_layer->id());
   scroll_layer->SetScrollClipLayerId(scroll_clip_layer->id());
   host_->SetRootLayer(layer_tree_root);
   host_->BuildPropertyTreesForTesting();
   host_->CommitAndCreatePendingTree();
   host_impl->ActivateSyncTree();
 
   ExpectTreesAreIdentical(layer_tree_root.get(),
-                          host_impl->active_tree()->root_layer(),
+                          host_impl->active_tree()->root_layer_for_testing(),
                           host_impl->active_tree());
 
   host_impl->active_tree()->SetCurrentlyScrollingLayer(
       host_impl->active_tree()->LayerById(scroll_layer->id()));
   transient_scroll_layer->SetScrollClipLayerId(Layer::INVALID_ID);
   host_->BuildPropertyTreesForTesting();
 
   host_impl->CreatePendingTree();
   host_->CommitAndCreatePendingTree();
   host_impl->ActivateSyncTree();
@@ skipping 30 matching lines @@
   scroll_layer->SetScrollClipLayerId(scroll_clip_layer->id());
   transient_scroll_layer->SetScrollOffset(gfx::ScrollOffset(1, 2));
   scroll_layer->SetScrollOffset(gfx::ScrollOffset(10, 20));
 
   host_->SetRootLayer(layer_tree_root);
   host_->BuildPropertyTreesForTesting();
   host_->CommitAndCreatePendingTree();
   host_impl->ActivateSyncTree();
 
   ExpectTreesAreIdentical(layer_tree_root.get(),
-                          host_impl->active_tree()->root_layer(),
+                          host_impl->active_tree()->root_layer_for_testing(),
                           host_impl->active_tree());
 
   // After the initial commit, scroll_offset_map in scroll_tree is expected to
   // have one entry for scroll_layer and one entry for transient_scroll_layer,
   // the pending base and active base must be the same at this stage.
   ScrollTree::ScrollOffsetMap scroll_offset_map;
   scroll_offset_map[scroll_layer->id()] = new SyncedScrollOffset;
   scroll_offset_map[transient_scroll_layer->id()] = new SyncedScrollOffset;
   scroll_offset_map[scroll_layer->id()]->PushFromMainThread(
       scroll_layer->scroll_offset());
@@ skipping 42 matching lines @@
   scroll_offset_map[scroll_layer->id()]->PullDeltaForMainThread();
   scroll_offset_map[scroll_layer->id()]->SetCurrent(gfx::ScrollOffset(40, 50));
   scroll_offset_map[scroll_layer->id()]->PushFromMainThread(
       gfx::ScrollOffset(100, 100));
   scroll_offset_map[scroll_layer->id()]->PushPendingToActive();
   EXPECT_TRUE(is_equal(scroll_offset_map, scroll_tree.scroll_offset_map()));
 }
 
 }  // namespace
 }  // namespace cc