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_id = root_picture_layer_->id();
   }
 
   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_id = picture->id();

[ajuma, 2016/04/20 21:40:52]

Changing picture_id on the main thread will accessing it on the compositor
thread is something to avoid (even if there's an argument that it happens to be
safe in this case). Please use two different variables, and use
source_frame_number on the compositor side to decide which one to use.

[sunxd, 2016/04/21 17:31:16]

Done.

         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();
 
-    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()) {
+    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_id;

[ajuma, 2016/04/20 21:40:52]

nit: picture_id_

[sunxd, 2016/04/21 17:31:16]

Done.

 };
 
 // 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