cc: Remove LayerImpl::children() calls from descendants of LayerTreeTest

cc/trees/layer_tree_host_unittest_damage.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/trees/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/time/time.h"
@@ skipping 320 matching lines @@
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDamageTestForcedFullDamage);
 
 class LayerTreeHostScrollbarDamageTest : public LayerTreeHostDamageTest {
   void SetupTree() override {
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(400, 400));
     root_layer->SetMasksToBounds(true);
     layer_tree_host()->SetRootLayer(root_layer);
 
     scoped_refptr<Layer> scroll_clip_layer = Layer::Create();
-    scoped_refptr<Layer> content_layer = FakePictureLayer::Create(&client_);
-    content_layer->SetScrollClipLayerId(scroll_clip_layer->id());
-    content_layer->SetScrollOffset(gfx::ScrollOffset(10, 20));
-    content_layer->SetBounds(gfx::Size(100, 200));
-    content_layer->SetIsDrawable(true);
+    content_layer_ = FakePictureLayer::Create(&client_);
+    content_layer_->SetScrollClipLayerId(scroll_clip_layer->id());
+    content_layer_->SetScrollOffset(gfx::ScrollOffset(10, 20));
+    content_layer_->SetBounds(gfx::Size(100, 200));
+    content_layer_->SetIsDrawable(true);
     scroll_clip_layer->SetBounds(
-        gfx::Size(content_layer->bounds().width() - 30,
-                  content_layer->bounds().height() - 50));
-    scroll_clip_layer->AddChild(content_layer);
+        gfx::Size(content_layer_->bounds().width() - 30,
+                  content_layer_->bounds().height() - 50));
+    scroll_clip_layer->AddChild(content_layer_);
     root_layer->AddChild(scroll_clip_layer);
 
     scoped_refptr<Layer> scrollbar_layer =
-        FakePaintedScrollbarLayer::Create(false, true, content_layer->id());
+        FakePaintedScrollbarLayer::Create(false, true, content_layer_->id());
     scrollbar_layer->SetPosition(gfx::PointF(300.f, 300.f));
     scrollbar_layer->SetBounds(gfx::Size(10, 100));
-    scrollbar_layer->ToScrollbarLayer()->SetScrollLayer(content_layer->id());
+    scrollbar_layer->ToScrollbarLayer()->SetScrollLayer(content_layer_->id());
     root_layer->AddChild(scrollbar_layer);
 
-    gfx::RectF content_rect(content_layer->position(),
-                            gfx::SizeF(content_layer->bounds()));
+    gfx::RectF content_rect(content_layer_->position(),
+                            gfx::SizeF(content_layer_->bounds()));
     gfx::RectF scrollbar_rect(scrollbar_layer->position(),
                               gfx::SizeF(scrollbar_layer->bounds()));
     EXPECT_FALSE(content_rect.Intersects(scrollbar_rect));
 
     LayerTreeHostDamageTest::SetupTree();
     client_.set_bounds(root_layer->bounds());
   }
 
  private:
   FakeContentLayerClient client_;
+
+ protected:
+  scoped_refptr<Layer> content_layer_;
 };
 
 class LayerTreeHostDamageTestScrollbarDoesDamage
     : public LayerTreeHostScrollbarDamageTest {
   void BeginTest() override {
     did_swaps_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
@@ skipping 22 matching lines @@
         EXPECT_TRUE(root_damage.Contains(gfx::Rect(300, 300, 10, 100)));
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     ++did_swaps_;
     EXPECT_TRUE(result);
-    LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* scroll_clip_layer = root->children()[0];
-    LayerImpl* scroll_layer = scroll_clip_layer->children()[0];
+    LayerImpl* scroll_layer =
+        host_impl->active_tree()->LayerById(content_layer_->id());
     switch (did_swaps_) {
       case 1:
         // Test that modifying the position of the content layer (not
         // scrolling) won't damage the scrollbar.
         MainThreadTaskRunner()->PostTask(
             FROM_HERE, base::Bind(&LayerTreeHostDamageTestScrollbarDoesDamage::
                                       ModifyContentLayerPosition,
                                   base::Unretained(this)));
         break;
       case 2:
         scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f));
         host_impl->SetNeedsRedraw();
         break;
       case 3:
         // We will resize the content layer, on the main thread.
         MainThreadTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(
                 &LayerTreeHostDamageTestScrollbarDoesDamage::ResizeScrollLayer,
                 base::Unretained(this)));
         break;
     }
   }
 
   void ModifyContentLayerPosition() {
     EXPECT_EQ(1, did_swaps_);
-    Layer* root = layer_tree_host()->root_layer();
-    Layer* scroll_clip_layer = root->child_at(0);
-    Layer* scroll_layer = scroll_clip_layer->child_at(0);
-    scroll_layer->SetPosition(gfx::PointF(10.f, 10.f));
+    content_layer_->SetPosition(gfx::PointF(10.f, 10.f));
   }
 
   void ResizeScrollLayer() {
     EXPECT_EQ(3, did_swaps_);
     Layer* root = layer_tree_host()->root_layer();
-    Layer* scroll_clip_layer = root->child_at(0);
-    Layer* scroll_layer = scroll_clip_layer->child_at(0);
-    scroll_layer->SetBounds(
+    content_layer_->SetBounds(
         gfx::Size(root->bounds().width() + 60, root->bounds().height() + 100));
   }
 
   void AfterTest() override { EXPECT_EQ(4, did_swaps_); }
 
   int did_swaps_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarDoesDamage);
 
@@ skipping 32 matching lines @@
       default:
         NOTREACHED();
         break;
     }
     return draw_result;
   }
 
   void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
     ++did_swaps_;
     EXPECT_TRUE(result);
-    LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* scroll_clip_layer = root->children()[0];
-    LayerImpl* scroll_layer = scroll_clip_layer->children()[0];
+    LayerImpl* scroll_layer =
+        host_impl->active_tree()->LayerById(content_layer_->id());
     switch (did_swaps_) {
       case 1:
         // Scroll on the thread.  This should damage the scrollbar for the
         // next draw on the thread.
         scroll_layer->ScrollBy(gfx::Vector2dF(10.f, 10.f));
         host_impl->SetNeedsRedraw();
         break;
       case 2:
         // Forcibly send the scroll to the main thread.
         PostSetNeedsCommitToMainThread();
@@ skipping 10 matching lines @@
 
   void AfterTest() override { EXPECT_EQ(3, did_swaps_); }
 
   int did_swaps_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarCommitDoesNoDamage);
 
 }  // namespace
 }  // namespace cc