cc: Clean up root_layer code in LTI

cc/trees/layer_tree_host_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/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 599 matching lines @@
     DRAWS_CONTENT,
     DONE,
   };
 
   void BeginTest() override {
     index_ = STARTUP;
     PostSetNeedsCommitToMainThread();
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
-    VerifyAfterValues(impl->active_tree()->root_layer());
+    VerifyAfterValues(impl->active_tree()->root_layer_for_testing());
   }
 
   void DidCommitAndDrawFrame() override {
     SetBeforeValues(layer_tree_host()->root_layer());
     VerifyBeforeValues(layer_tree_host()->root_layer());
 
     ++index_;
     if (index_ == DONE) {
       EndTest();
       return;
@@ skipping 200 matching lines @@
         scoped_refptr<Layer> replica_layer = Layer::Create();
         layer_tree_host()->root_layer()->SetReplicaLayer(replica_layer.get());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     switch (index_) {
       case 0:
         impl->sync_tree()->ResetAllChangeTracking();
-        EXPECT_FALSE(impl->sync_tree()->root_layer()->LayerPropertyChanged());
+        EXPECT_FALSE(impl->sync_tree()
+                         ->root_layer_for_testing()
+                         ->LayerPropertyChanged());
         PostSetNeedsCommitToMainThread();
         index_++;
         break;
       case 1:
-        EXPECT_TRUE(impl->sync_tree()->root_layer()->LayerPropertyChanged());
+        EXPECT_TRUE(impl->sync_tree()
+                        ->root_layer_for_testing()
+                        ->LayerPropertyChanged());
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
   int index_;
 };
 
@@ skipping 36 matching lines @@
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     gfx::Transform transform;
     FilterOperations filters;
     switch (static_cast<Animations>(index_)) {
       case OPACITY:
         index_++;
         impl->active_tree()->ResetAllChangeTracking();
-        impl->active_tree()->root_layer()->OnOpacityAnimated(0.5f);
+        impl->active_tree()->root_layer_for_testing()->OnOpacityAnimated(0.5f);
         PostSetNeedsCommitToMainThread();
         break;
       case TRANSFORM:
         index_++;
         EXPECT_TRUE(impl->active_tree()
                         ->LayerById(root_->id())
                         ->LayerPropertyChanged());
         impl->active_tree()->ResetAllChangeTracking();
         EXPECT_FALSE(impl->active_tree()
                          ->LayerById(root_->id())
                          ->LayerPropertyChanged());
         EXPECT_FALSE(impl->active_tree()
                          ->LayerById(child_->id())
                          ->LayerPropertyChanged());
         transform.Translate(10, 10);
-        impl->active_tree()->root_layer()->OnTransformAnimated(transform);
+        impl->active_tree()->root_layer_for_testing()->OnTransformAnimated(
+            transform);
         PostSetNeedsCommitToMainThread();
         break;
       case FILTER:
         index_++;
-        EXPECT_TRUE(impl->active_tree()->root_layer()->LayerPropertyChanged());
+        EXPECT_TRUE(impl->active_tree()
+                        ->root_layer_for_testing()
+                        ->LayerPropertyChanged());
         EXPECT_TRUE(impl->active_tree()
                         ->LayerById(child_->id())
                         ->LayerPropertyChanged());
         impl->active_tree()->ResetAllChangeTracking();
-        EXPECT_FALSE(impl->active_tree()->root_layer()->LayerPropertyChanged());
+        EXPECT_FALSE(impl->active_tree()
+                         ->root_layer_for_testing()
+                         ->LayerPropertyChanged());
         EXPECT_FALSE(impl->active_tree()
                          ->LayerById(child_->id())
                          ->LayerPropertyChanged());
         filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
-        impl->active_tree()->root_layer()->OnFilterAnimated(filters);
+        impl->active_tree()->root_layer_for_testing()->OnFilterAnimated(
+            filters);
         PostSetNeedsCommitToMainThread();
         break;
       case END:
-        EXPECT_TRUE(impl->active_tree()->root_layer()->LayerPropertyChanged());
+        EXPECT_TRUE(impl->active_tree()
+                        ->root_layer_for_testing()
+                        ->LayerPropertyChanged());
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
   int index_;
   scoped_refptr<Layer> root_;
@@ skipping 21 matching lines @@
         node->data.is_currently_animating_opacity = true;
         break;
       case 2:
         node->data.is_currently_animating_opacity = false;
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     EffectTree& effect_tree = impl->sync_tree()->property_trees()->effect_tree;
-    EffectNode* node =
-        effect_tree.Node(impl->sync_tree()->root_layer()->effect_tree_index());
+    EffectNode* node = effect_tree.Node(
+        impl->sync_tree()->root_layer_for_testing()->effect_tree_index());
     switch (impl->sync_tree()->source_frame_number()) {
       case 0:
-        impl->sync_tree()->root_layer()->OnOpacityAnimated(0.75f);
+        impl->sync_tree()->root_layer_for_testing()->OnOpacityAnimated(0.75f);
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         EXPECT_EQ(node->data.opacity, 0.75f);
-        impl->sync_tree()->root_layer()->OnOpacityAnimated(0.75f);
+        impl->sync_tree()->root_layer_for_testing()->OnOpacityAnimated(0.75f);
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(node->data.opacity, 0.5f);
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
@@ skipping 31 matching lines @@
       case 3:
         node->data.is_currently_animating = false;
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     TransformTree& transform_tree =
         impl->sync_tree()->property_trees()->transform_tree;
     TransformNode* node = transform_tree.Node(
-        impl->sync_tree()->root_layer()->transform_tree_index());
+        impl->sync_tree()->root_layer_for_testing()->transform_tree_index());
     gfx::Transform rotate10;
     rotate10.Rotate(10.f);
     gfx::Transform rotate20;
     rotate20.Rotate(20.f);
     switch (impl->sync_tree()->source_frame_number()) {
       case 0:
-        impl->sync_tree()->root_layer()->OnTransformAnimated(rotate20);
+        impl->sync_tree()->root_layer_for_testing()->OnTransformAnimated(
+            rotate20);
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
         EXPECT_EQ(node->data.local, rotate20);
-        impl->sync_tree()->root_layer()->OnTransformAnimated(rotate20);
+        impl->sync_tree()->root_layer_for_testing()->OnTransformAnimated(
+            rotate20);
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_EQ(node->data.local, rotate20);
-        impl->sync_tree()->root_layer()->OnTransformAnimated(rotate20);
+        impl->sync_tree()->root_layer_for_testing()->OnTransformAnimated(
+            rotate20);
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         EXPECT_EQ(node->data.local, rotate10);
         EndTest();
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 118 matching lines @@
         layer_tree_host()->root_layer()->RemoveAllChildren();
         layer_tree_host()->root_layer()->SetMaskLayer(mask_layer.get());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     switch (index_) {
       case 0:
         index_++;
-        EXPECT_FALSE(
-            impl->sync_tree()->root_layer()->render_surface()->MaskLayer());
+        EXPECT_FALSE(impl->sync_tree()
+                         ->root_layer_for_testing()
+                         ->render_surface()
+                         ->MaskLayer());
         break;
       case 1:
-        EXPECT_TRUE(
-            impl->sync_tree()->root_layer()->render_surface()->MaskLayer());
+        EXPECT_TRUE(impl->sync_tree()
+                        ->root_layer_for_testing()
+                        ->render_surface()
+                        ->MaskLayer());
         EndTest();
         break;
     }
   }
 
   void AfterTest() override {}
 
   scoped_refptr<Layer> mask_layer;
   int index_;
 };
@@ skipping 126 matching lines @@
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     if (num_draws_ < 2) {
       PostSetNeedsRedrawRectToMainThread(invalid_rect_);
       num_draws_++;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 2) {
       auto pending_tree = host_impl->pending_tree();
-      auto pending_layer_impl =
-          static_cast<FakePictureLayerImpl*>(pending_tree->root_layer());
+      auto pending_layer_impl = static_cast<FakePictureLayerImpl*>(
+          pending_tree->root_layer_for_testing());
       EXPECT_NE(pending_layer_impl, nullptr);
 
       auto active_tree = host_impl->pending_tree();
-      auto active_layer_impl =
-          static_cast<FakePictureLayerImpl*>(active_tree->root_layer());
+      auto active_layer_impl = static_cast<FakePictureLayerImpl*>(
+          active_tree->root_layer_for_testing());
       EXPECT_NE(pending_layer_impl, nullptr);
 
       auto active_tiling_set = active_layer_impl->picture_layer_tiling_set();
       auto active_tiling = active_tiling_set->tiling_at(0);
       auto pending_tiling_set = pending_layer_impl->picture_layer_tiling_set();
       auto pending_tiling = pending_tiling_set->tiling_at(0);
       EXPECT_EQ(
           pending_tiling->TilingDataForTesting().max_texture_size().width(),
           active_tiling->TilingDataForTesting().max_texture_size().width());
       EndTest();
@@ skipping 169 matching lines @@
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     if (host_impl->active_tree()->source_frame_number() == 0) {
       EXPECT_EQ(1.f, host_impl->active_tree()->device_scale_factor());
     } else {
       gfx::Rect root_damage_rect =
           frame_data->render_passes.back()->damage_rect;
-      EXPECT_EQ(gfx::Rect(host_impl->active_tree()->root_layer()->bounds()),
-                root_damage_rect);
+      EXPECT_EQ(
+          gfx::Rect(
+              host_impl->active_tree()->root_layer_for_testing()->bounds()),
+          root_damage_rect);
       EXPECT_EQ(4.f, host_impl->active_tree()->device_scale_factor());
       EndTest();
     }
 
     return draw_result;
   }
 
   void AfterTest() override {}
 
  private:
@@ skipping 581 matching lines @@
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     // Should only do one commit.
     EXPECT_EQ(0, impl->active_tree()->source_frame_number());
     // Device scale factor should come over to impl.
     EXPECT_NEAR(impl->active_tree()->device_scale_factor(), 1.5f, 0.00001f);
 
     // Device viewport is scaled.
     EXPECT_EQ(gfx::Size(60, 60), impl->DrawViewportSize());
 
-    FakePictureLayerImpl* root =
-        static_cast<FakePictureLayerImpl*>(impl->active_tree()->root_layer());
+    FakePictureLayerImpl* root = static_cast<FakePictureLayerImpl*>(
+        impl->active_tree()->root_layer_for_testing());
     FakePictureLayerImpl* child = static_cast<FakePictureLayerImpl*>(
         impl->active_tree()->LayerById(child_layer_->id()));
 
     // Positions remain in layout pixels.
     EXPECT_EQ(gfx::PointF(), root->position());
     EXPECT_EQ(gfx::PointF(2.f, 2.f), child->position());
 
     // Compute all the layer transforms for the frame.
     LayerTreeHostImpl::FrameData frame_data;
     impl->PrepareToDraw(&frame_data);
@@ skipping 268 matching lines @@
         break;
     }
   }
 
   void NotifyTileStateChangedOnThread(LayerTreeHostImpl* host_impl,
                                       const Tile* tile) override {
     ++num_tiles_rastered_;
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
-    PictureLayerImpl* root_layer =
-        static_cast<PictureLayerImpl*>(host_impl->active_tree()->root_layer());
+    PictureLayerImpl* root_layer = static_cast<PictureLayerImpl*>(
+        host_impl->active_tree()->root_layer_for_testing());
     bool can_use_lcd_text =
-        host_impl->active_tree()->root_layer()->CanUseLCDText();
+        host_impl->active_tree()->root_layer_for_testing()->CanUseLCDText();
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // The first draw.
         EXPECT_EQ(1, num_tiles_rastered_);
         EXPECT_TRUE(can_use_lcd_text);
         EXPECT_TRUE(root_layer->RasterSourceUsesLCDText());
         break;
       case 1:
         // Nothing changed on the layer.
         EXPECT_EQ(1, num_tiles_rastered_);
@@ skipping 762 matching lines @@
         // Root is swapped here.
         // Clear the expected push properties the tree will be rebuilt.
         expected_push_properties_root_impl_ = 0;
         expected_push_properties_child_impl_ = 0;
         expected_push_properties_grandchild_impl_ = 0;
         expected_push_properties_child2_impl_ = 0;
         expected_push_properties_grandchild2_impl_ = 0;
 
         // Make sure the new root is pushed.
         EXPECT_EQ(1u, static_cast<PushPropertiesCountingLayerImpl*>(
-                          host_impl->active_tree()->root_layer())
+                          host_impl->active_tree()->root_layer_for_testing())
                           ->push_properties_count());
         return;
       case 4:
         // Root is swapped back all of the layers in the tree get pushed.
         ++expected_push_properties_root_impl_;
         ++expected_push_properties_child_impl_;
         ++expected_push_properties_grandchild_impl_;
         ++expected_push_properties_child2_impl_;
         ++expected_push_properties_grandchild2_impl_;
         break;
@@ skipping 85 matching lines @@
 
     PushPropertiesCountingLayerImpl* root_impl_ = NULL;
     PushPropertiesCountingLayerImpl* child_impl_ = NULL;
     PushPropertiesCountingLayerImpl* child2_impl_ = NULL;
     PushPropertiesCountingLayerImpl* grandchild_impl_ = NULL;
     PushPropertiesCountingLayerImpl* leaf_always_pushing_layer_impl_ = NULL;
 
     // Pull the layers that we need from the tree assuming the same structure
     // as LayerTreeHostTestLayersPushProperties
     root_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
-        host_impl->active_tree()->root_layer());
+        host_impl->active_tree()->root_layer_for_testing());
 
     LayerTreeImpl* impl = root_impl_->layer_tree_impl();
     if (impl->LayerById(child_->id())) {
       child_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
           impl->LayerById(child_->id()));
 
       if (impl->LayerById(grandchild_->id()))
         grandchild_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
             impl->LayerById(grandchild_->id()));
     }
@@ skipping 3329 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc