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

cc/trees/layer_tree_host_unittest_scroll.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/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 67 matching lines @@
 
 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollSimple()
       : initial_scroll_(10, 20),
         second_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   void BeginTest() override {
+    outer_viewport_container_layer_id_ = layer_tree_host()
+                                             ->outer_viewport_scroll_layer()
+                                             ->scroll_clip_layer()
+                                             ->id();
     layer_tree_host()->outer_viewport_scroll_layer()->SetScrollOffset(
         initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   void UpdateLayerTreeHost() override {
     Layer* scroll_layer = layer_tree_host()->outer_viewport_scroll_layer();
     if (!layer_tree_host()->source_frame_number()) {
       EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
       EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_,
                                                   scroll_amount_),
                        scroll_layer->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
       scroll_layer->SetScrollOffset(second_scroll_);
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
     EXPECT_VECTOR_EQ(gfx::Vector2d(), ScrollDelta(scroll_layer));
 
-    scroll_layer->SetScrollClipLayer(root->children()[0]->id());
+    scroll_layer->SetScrollClipLayer(outer_viewport_container_layer_id_);
     scroll_layer->SetBounds(
         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
     scroll_layer->ScrollBy(scroll_amount_);
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         EXPECT_VECTOR_EQ(initial_scroll_, ScrollTreeForLayer(scroll_layer)
                                               ->GetScrollOffsetBaseForTesting(
                                                   scroll_layer->id()));
         EXPECT_VECTOR_EQ(scroll_amount_, ScrollDelta(scroll_layer));
@@ skipping 17 matching lines @@
     num_scrolls_++;
   }
 
   void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::ScrollOffset initial_scroll_;
   gfx::ScrollOffset second_scroll_;
   gfx::Vector2dF scroll_amount_;
   int num_scrolls_;
+  int outer_viewport_container_layer_id_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollSimple);
 
 class LayerTreeHostScrollTestScrollMultipleRedraw
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollMultipleRedraw()
       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 
@@ skipping 439 matching lines @@
                          expected_scroll_layer_->scroll_offset());
         break;
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* inner_scroll = impl->InnerViewportScrollLayer();
     FakePictureLayerImpl* root_scroll_layer_impl =
         static_cast<FakePictureLayerImpl*>(impl->OuterViewportScrollLayer());
     FakePictureLayerImpl* child_layer_impl = static_cast<FakePictureLayerImpl*>(
-        root_scroll_layer_impl->children()[0]);
+        root_scroll_layer_impl->layer_tree_impl()->LayerById(
+            child_layer_->id()));
 
     LayerImpl* expected_scroll_layer_impl = NULL;
     LayerImpl* expected_no_scroll_layer_impl = NULL;
     if (scroll_child_layer_) {
       expected_scroll_layer_impl = child_layer_impl;
       expected_no_scroll_layer_impl = root_scroll_layer_impl;
     } else {
       expected_scroll_layer_impl = root_scroll_layer_impl;
       expected_no_scroll_layer_impl = child_layer_impl;
     }
@@ skipping 448 matching lines @@
 };
 
 // This tests scrolling on the impl side which is only possible with a thread.
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestImplOnlyScroll);
 
 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
-  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+  void BeginTest() override {
+    outer_viewport_container_layer_id_ = layer_tree_host()
+                                             ->outer_viewport_scroll_layer()
+                                             ->scroll_clip_layer()
+                                             ->id();
+    PostSetNeedsCommitToMainThread();
+  }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* scroll_layer = impl->OuterViewportScrollLayer();
-    scroll_layer->SetScrollClipLayer(root->children()[0]->id());
+    scroll_layer->SetScrollClipLayer(outer_viewport_container_layer_id_);
 
     // Set max_scroll_offset = (100, 100).
     scroll_layer->SetBounds(
         gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
     impl->active_tree()->property_trees()->needs_rebuild = true;
     impl->active_tree()->BuildPropertyTreesForTesting();
 
     ScrollTree& scroll_tree =
         impl->active_tree()->property_trees()->scroll_tree;
     ScrollNode* scroll_node =
@@ skipping 28 matching lines @@
     status = impl->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::TOUCHSCREEN,
                              scroll_tree, scroll_node);
     EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
     EXPECT_EQ(MainThreadScrollingReason::kNotScrollable,
               status.main_thread_scrolling_reasons);
 
     EndTest();
   }
 
   void AfterTest() override {}
+
+ private:
+  int outer_viewport_container_layer_id_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostScrollTestScrollZeroMaxScrollOffset);
 
 class LayerTreeHostScrollTestScrollNonDrawnLayer
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollNonDrawnLayer() {}
 
@@ skipping 282 matching lines @@
   RunTest(CompositorMode::THREADED, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
   scroll_destroy_whole_tree_ = true;
   RunTest(CompositorMode::THREADED, false);
 }
 
 }  // namespace
 }  // namespace cc