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

cc/trees/layer_tree_host_unittest_picture.cc

 // Copyright 2013 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 "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_picture_layer.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/layer_tree_test.h"
@@ skipping 18 matching lines @@
   }
 
   scoped_refptr<FakePictureLayer> root_picture_layer_;
   FakeContentLayerClient client_;
 };
 
 class LayerTreeHostPictureTestTwinLayer
     : public LayerTreeHostPictureTest {
   void SetupTree() override {
     SetupTreeWithSinglePictureLayer(gfx::Size(1, 1));
+    picture_id1_ = root_picture_layer_->id();
+    picture_id2_ = -1;
   }
 
   void BeginTest() override {
     activates_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         // Activate while there are pending and active twins in place.
         layer_tree_host()->SetNeedsCommit();
         break;
       case 2:
         // Drop the picture layer from the tree so the activate will have an
         // active layer without a pending twin.
-        layer_tree_host()->root_layer()->children()[0]->RemoveFromParent();
+        root_picture_layer_->RemoveFromParent();
         break;
       case 3: {
         // Add a new picture layer so the activate will have a pending layer
         // without an active twin.
         scoped_refptr<FakePictureLayer> picture =
             FakePictureLayer::Create(&client_);
+        picture_id2_ = picture->id();
         layer_tree_host()->root_layer()->AddChild(picture);
         break;
       }
       case 4:
         // Active while there are pending and active twins again.
         layer_tree_host()->SetNeedsCommit();
         break;
       case 5:
         EndTest();
         break;
     }
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* pending_root_impl = impl->pending_tree()->root_layer();
     LayerImpl* active_root_impl = impl->active_tree()->root_layer();
+    int picture_id = impl->active_tree()->source_frame_number() < 2
+                         ? picture_id1_
+                         : picture_id2_;
 
-    if (pending_root_impl->children().empty()) {
+    if (!impl->pending_tree()->LayerById(picture_id)) {
       EXPECT_EQ(2, activates_);
       return;
     }
 
     FakePictureLayerImpl* pending_picture_impl =
-        static_cast<FakePictureLayerImpl*>(pending_root_impl->children()[0]);
+        static_cast<FakePictureLayerImpl*>(
+            impl->pending_tree()->LayerById(picture_id));
 
     if (!active_root_impl) {
       EXPECT_EQ(0, activates_);
       EXPECT_EQ(nullptr, pending_picture_impl->GetPendingOrActiveTwinLayer());
       return;
     }
 
-    if (active_root_impl->children().empty()) {
+    if (!impl->active_tree()->LayerById(picture_id)) {
       EXPECT_EQ(3, activates_);
       EXPECT_EQ(nullptr, pending_picture_impl->GetPendingOrActiveTwinLayer());
       return;
     }
 
     FakePictureLayerImpl* active_picture_impl =
-        static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
+        static_cast<FakePictureLayerImpl*>(
+            impl->active_tree()->LayerById(picture_id));
 
     // After the first activation, when we commit again, we'll have a pending
     // and active layer. Then we recreate a picture layer in the 4th activate
     // and the next commit will have a pending and active twin again.
     EXPECT_TRUE(activates_ == 1 || activates_ == 4) << activates_;
 
     EXPECT_EQ(pending_picture_impl,
               active_picture_impl->GetPendingOrActiveTwinLayer());
     EXPECT_EQ(active_picture_impl,
               pending_picture_impl->GetPendingOrActiveTwinLayer());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* active_root_impl = impl->active_tree()->root_layer();
-    if (active_root_impl->children().empty()) {
+    int picture_id = impl->active_tree()->source_frame_number() < 3
+                         ? picture_id1_
+                         : picture_id2_;
+    if (!impl->active_tree()->LayerById(picture_id)) {
       EXPECT_EQ(2, activates_);
     } else {
       FakePictureLayerImpl* active_picture_impl =
-          static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
+          static_cast<FakePictureLayerImpl*>(
+              impl->active_tree()->LayerById(picture_id));
       EXPECT_EQ(nullptr, active_picture_impl->GetPendingOrActiveTwinLayer());
     }
 
     ++activates_;
   }
 
   void AfterTest() override { EXPECT_EQ(5, activates_); }
 
   int activates_;
+  int picture_id1_;
+  int picture_id2_;
 };
 
 // There is no pending layers in single thread mode.
 MULTI_THREAD_TEST_F(LayerTreeHostPictureTestTwinLayer);
 
 class LayerTreeHostPictureTestResizeViewportWithGpuRaster
     : public LayerTreeHostPictureTest {
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     scoped_refptr<Layer> root = Layer::Create();
     root->SetBounds(gfx::Size(768, 960));
     client_.set_bounds(root->bounds());
     client_.set_fill_with_nonsolid_color(true);
     picture_ = FakePictureLayer::Create(&client_);
     picture_->SetBounds(gfx::Size(768, 960));
     root->AddChild(picture_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* child = impl->sync_tree()->root_layer()->children()[0];
+    LayerImpl* child = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     gfx::Size tile_size =
         picture_impl->HighResTiling()->TileAt(0, 0)->content_rect().size();
 
     switch (impl->sync_tree()->source_frame_number()) {
       case 0:
         tile_size_ = tile_size;
         // GPU Raster picks a tile size based on the viewport size.
         EXPECT_EQ(gfx::Size(768, 256), tile_size);
@@ skipping 48 matching lines @@
     picture_->SetScrollClipLayerId(root->id());
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
     client_.set_bounds(picture_->bounds());
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* child = impl->active_tree()->root_layer()->children()[0];
+    LayerImpl* child = impl->active_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     switch (++frame_) {
       case 1: {
         PictureLayerTiling* tiling = picture_impl->HighResTiling();
         int num_tiles_y = tiling->TilingDataForTesting().num_tiles_y();
 
         // There should be tiles at the top of the picture layer but not at the
         // bottom.
         EXPECT_TRUE(tiling->TileAt(0, 0));
@@ skipping 28 matching lines @@
         // Make a new main frame without changing the picture layer at all, so
         // it won't need to update or push properties.
         did_post_commit_ = true;
         PostSetNeedsCommitToMainThread();
         break;
       }
     }
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* child = impl->sync_tree()->root_layer()->children()[0];
+    LayerImpl* child = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     PictureLayerTiling* tiling = picture_impl->HighResTiling();
     int num_tiles_y = tiling->TilingDataForTesting().num_tiles_y();
 
     if (!impl->active_tree()->root_layer()) {
       // If active tree doesn't have the layer, then pending tree should have
       // all needed tiles.
       EXPECT_TRUE(tiling->TileAt(0, 0));
     } else {
@@ skipping 33 matching lines @@
     picture_->SetBounds(gfx::Size(100, 100));
     child_->AddChild(picture_);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostPictureTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* root = impl->sync_tree()->root_layer();
-    LayerImpl* child = root->children()[0];
-    LayerImpl* gchild = child->children()[0];
+    LayerImpl* gchild = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     switch (impl->sync_tree()->source_frame_number()) {
       case 0:
         // On 1st commit the layer has tilings.
         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
         break;
       case 1:
         // On 2nd commit, the layer is transparent, but its tilings are left
         // there.
         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
         break;
       case 2:
         // On 3rd commit, the layer is visible again, so has tilings.
         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
     }
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0];
-    LayerImpl* gchild = child->children()[0];
+    LayerImpl* gchild = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         // On 1st commit the layer has tilings.
         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
         break;
       case 1:
         // On 2nd commit, the layer is transparent, but its tilings are left
         // there.
@@ skipping 64 matching lines @@
 
   void BeginTest() override {
     frame_ = 0;
     draws_in_frame_ = 0;
     last_frame_drawn_ = -1;
     ready_to_draw_ = false;
     PostSetNeedsCommitToMainThread();
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* root = impl->sync_tree()->root_layer();
-    LayerImpl* pinch = root->children()[0]->children()[0];
-    LayerImpl* gchild = pinch->children()[0];
+    LayerImpl* gchild = impl->sync_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
     ready_to_draw_ = false;
 
     switch (frame_) {
       case 0:
         // On 1st commit the pending layer has tilings.
         ASSERT_EQ(1u, picture->tilings()->num_tilings());
         EXPECT_EQ(1.f, picture->tilings()->tiling_at(0)->contents_scale());
         break;
       case 1:
         // On 2nd commit, the pending layer is transparent, so has a stale
         // value.
         ASSERT_EQ(1u, picture->tilings()->num_tilings());
         EXPECT_EQ(1.f, picture->tilings()->tiling_at(0)->contents_scale());
         break;
       case 2:
         // On 3rd commit, the pending layer is visible again, so has tilings and
         // is updated for the pinch.
         ASSERT_EQ(1u, picture->tilings()->num_tilings());
         EXPECT_EQ(2.f, picture->tilings()->tiling_at(0)->contents_scale());
     }
   }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* pinch = root->children()[0]->children()[0];
-    LayerImpl* gchild = pinch->children()[0];
+    LayerImpl* gchild = impl->active_tree()->LayerById(picture_->id());
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     if (frame_ != last_frame_drawn_)
       draws_in_frame_ = 0;
     ++draws_in_frame_;
     last_frame_drawn_ = frame_;
 
     switch (frame_) {
       case 0:
         if (draws_in_frame_ == 1) {
@@ skipping 82 matching lines @@
   int last_frame_drawn_;
   bool ready_to_draw_;
 };
 
 // Multi-thread only because in single thread you can't pinch zoom on the
 // compositor thread.
 MULTI_THREAD_TEST_F(LayerTreeHostPictureTestRSLLMembershipWithScale);
 
 }  // namespace
 }  // namespace cc