cc : Replace LayerImpl::children calls with LayerById

cc/layers/scrollbar_layer_unittest.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 <stddef.h>
 
 #include <unordered_map>
 
 #include "base/thread_task_runner_handle.h"
 #include "cc/input/scrollbar_animation_controller.h"
@@ skipping 19 matching lines @@
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
-LayerImpl* LayerImplForScrollAreaAndScrollbar(
-    FakeLayerTreeHost* host,
-    std::unique_ptr<Scrollbar> scrollbar,
-    bool reverse_order,
-    bool use_solid_color_scrollbar,
-    int thumb_thickness,
-    int track_start) {
-  scoped_refptr<Layer> layer_tree_root = Layer::Create();
-  scoped_refptr<Layer> child1 = Layer::Create();
-  scoped_refptr<Layer> child2;
-  if (use_solid_color_scrollbar) {
-    const bool kIsLeftSideVerticalScrollbar = false;
-    child2 = SolidColorScrollbarLayer::Create(
-        scrollbar->Orientation(), thumb_thickness, track_start,
-        kIsLeftSideVerticalScrollbar, child1->id());
-  } else {
-    child2 = PaintedScrollbarLayer::Create(std::move(scrollbar), child1->id());
-  }
-  layer_tree_root->AddChild(child1);
-  layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
-  host->SetRootLayer(layer_tree_root);
-  return host->CommitAndCreateLayerImplTree();
-}
-
 class FakeResourceTrackingLayerTreeHost : public FakeLayerTreeHost {
  public:
   FakeResourceTrackingLayerTreeHost(FakeLayerTreeHostClient* client,
                                     LayerTreeHost::InitParams* params)
       : FakeLayerTreeHost(client, params, CompositorMode::SINGLE_THREADED),
         next_id_(1),
         total_ui_resource_created_(0),
         total_ui_resource_deleted_(0) {
     InitializeSingleThreaded(client, base::ThreadTaskRunnerHandle::Get(),
                              nullptr);
@@ skipping 39 matching lines @@
       std::unordered_map<UIResourceId, UIResourceBitmap>;
   UIResourceBitmapMap ui_resource_bitmap_map_;
 
   int next_id_;
   int total_ui_resource_created_;
   int total_ui_resource_deleted_;
 };
 
 class ScrollbarLayerTest : public testing::Test {
  public:
   ScrollbarLayerTest() : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {

[ajuma, 2016/04/21 18:33:19]

initialize scrollbar_layer_id_ here too

[jaydasika, 2016/04/21 18:47:00]

Done.

     layer_tree_settings_.single_thread_proxy_scheduler = false;
     layer_tree_settings_.use_zero_copy = true;
 
     LayerTreeHost::InitParams params;
     params.client = &fake_client_;
     params.settings = &layer_tree_settings_;
     params.task_graph_runner = &task_graph_runner_;
 
     layer_tree_host_.reset(
         new FakeResourceTrackingLayerTreeHost(&fake_client_, &params));
     layer_tree_host_->SetVisible(true);
     fake_client_.SetLayerTreeHost(layer_tree_host_.get());
     // Force output surface creation for renderer capabilities.
     layer_tree_host_->Composite(base::TimeTicks());
     EXPECT_FALSE(layer_tree_host_->output_surface_lost());
   }
 
+  LayerImpl* LayerImplForScrollAreaAndScrollbar(
+      FakeLayerTreeHost* host,
+      std::unique_ptr<Scrollbar> scrollbar,
+      bool reverse_order,
+      bool use_solid_color_scrollbar,
+      int thumb_thickness,
+      int track_start) {
+    scoped_refptr<Layer> layer_tree_root = Layer::Create();
+    scoped_refptr<Layer> child1 = Layer::Create();
+    scoped_refptr<Layer> child2;
+    if (use_solid_color_scrollbar) {
+      const bool kIsLeftSideVerticalScrollbar = false;
+      child2 = SolidColorScrollbarLayer::Create(
+          scrollbar->Orientation(), thumb_thickness, track_start,
+          kIsLeftSideVerticalScrollbar, child1->id());
+    } else {
+      child2 =
+          PaintedScrollbarLayer::Create(std::move(scrollbar), child1->id());
+    }
+    layer_tree_root->AddChild(child1);
+    layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
+    scrollbar_layer_id_ = reverse_order ? child1->id() : child2->id();
+    host->SetRootLayer(layer_tree_root);
+    return host->CommitAndCreateLayerImplTree();
+  }
+
  protected:
   FakeLayerTreeHostClient fake_client_;
   TestTaskGraphRunner task_graph_runner_;
   LayerTreeSettings layer_tree_settings_;
   std::unique_ptr<FakeResourceTrackingLayerTreeHost> layer_tree_host_;
+  int scrollbar_layer_id_;
 };
 
 TEST_F(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
   // Create and attach a non-overlay scrollbar.
   std::unique_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       layer_tree_host_.get(), std::move(scrollbar), false, false, 0, 0);
   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
       static_cast<PaintedScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1]);
+          layer_impl_tree_root->layer_tree_impl()->LayerById(
+              scrollbar_layer_id_));
   layer_impl_tree_root->layer_tree_impl()->BuildPropertyTreesForTesting();
   ScrollTree& scroll_tree =
       layer_impl_tree_root->layer_tree_impl()->property_trees()->scroll_tree;
   ScrollNode* scroll_node =
       scroll_tree.Node(scrollbar_layer_impl->scroll_tree_index());
 
   // When the scrollbar is not an overlay scrollbar, the scroll should be
   // responded to on the main thread as the compositor does not yet implement
   // scrollbar scrolling.
   InputHandler::ScrollStatus status = layer_tree_host_->host_impl()->TryScroll(
       gfx::PointF(), InputHandler::TOUCHSCREEN, scroll_tree, scroll_node);
   EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kScrollbarScrolling,
             status.main_thread_scrolling_reasons);
 
   // Create and attach an overlay scrollbar.
   scrollbar.reset(new FakeScrollbar(false, false, true));
 
   layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       layer_tree_host_.get(), std::move(scrollbar), false, false, 0, 0);
   scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      layer_impl_tree_root->children()[1]);
+      layer_impl_tree_root->layer_tree_impl()->LayerById(scrollbar_layer_id_));
   layer_impl_tree_root->layer_tree_impl()->BuildPropertyTreesForTesting();
   scroll_tree =
       layer_impl_tree_root->layer_tree_impl()->property_trees()->scroll_tree;
   scroll_node = scroll_tree.Node(scrollbar_layer_impl->scroll_tree_index());
 
   // The user shouldn't be able to drag an overlay scrollbar and the scroll
   // may be handled in the compositor.
   status = layer_tree_host_->host_impl()->TryScroll(
       gfx::PointF(), InputHandler::TOUCHSCREEN, scroll_tree, scroll_node);
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
@@ skipping 24 matching lines @@
 
   layer_tree_root->SavePaintProperties();
   content_layer->SavePaintProperties();
 
   layer_tree_host_->UpdateLayers();
   LayerImpl* layer_impl_tree_root =
       layer_tree_host_->CommitAndCreateLayerImplTree();
 
   ScrollbarLayerImplBase* cc_scrollbar_layer =
       static_cast<PaintedScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1]);
+          layer_impl_tree_root->layer_tree_impl()->LayerById(
+              scrollbar_layer->id()));
 
   EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(30, cc_scrollbar_layer->scroll_layer_length() -
                     cc_scrollbar_layer->clip_layer_length());
 
   layer_tree_root->SetBounds(gfx::Size(700, 1500));
   layer_tree_root->SavePaintProperties();
   scroll_layer->SetBounds(gfx::Size(1000, 2000));
   scroll_layer->SetScrollOffset(gfx::ScrollOffset(100, 200));
   scroll_layer->SavePaintProperties();
   content_layer->SetBounds(gfx::Size(1000, 2000));
   content_layer->SavePaintProperties();
 
   layer_tree_host_->UpdateLayers();
   layer_impl_tree_root = layer_tree_host_->CommitAndCreateLayerImplTree();
 
   EXPECT_EQ(100.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(300, cc_scrollbar_layer->scroll_layer_length() -
                      cc_scrollbar_layer->clip_layer_length());
 
-  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
+  LayerImpl* scroll_layer_impl =
+      layer_impl_tree_root->layer_tree_impl()->LayerById(scroll_layer->id());
   scroll_layer_impl->ScrollBy(gfx::Vector2d(12, 34));
 
   EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(300, cc_scrollbar_layer->scroll_layer_length() -
                      cc_scrollbar_layer->clip_layer_length());
 }
 
 #define UPDATE_AND_EXTRACT_LAYER_POINTERS()                                  \
   do {                                                                       \
     scrollbar_layer->UpdateInternalContentScale();                           \
     scrollbar_layer->UpdateThumbAndTrackGeometry();                          \
     root_clip_layer_impl = layer_tree_host_->CommitAndCreateLayerImplTree(); \
-    root_layer_impl = root_clip_layer_impl->children()[0];                   \
     scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(          \
-        root_layer_impl->children()[1]);                                     \
+        root_clip_layer_impl->layer_tree_impl()->LayerById(                  \
+            scrollbar_layer->id()));                                         \
   } while (false)
 
 TEST_F(ScrollbarLayerTest, UpdatePropertiesOfScrollBarWhenThumbRemoved) {
   scoped_refptr<Layer> root_clip_layer = Layer::Create();
   scoped_refptr<Layer> root_layer = Layer::Create();
   scoped_refptr<Layer> content_layer = Layer::Create();
   scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
       FakePaintedScrollbarLayer::Create(false, true, root_layer->id());
 
   root_layer->SetScrollClipLayerId(root_clip_layer->id());
   // Give the root-clip a size that will result in MaxScrollOffset = (80, 0).
   root_clip_layer->SetBounds(gfx::Size(20, 50));
   root_layer->SetBounds(gfx::Size(100, 50));
   content_layer->SetBounds(gfx::Size(100, 50));
 
   layer_tree_host_->SetRootLayer(root_clip_layer);
   root_clip_layer->AddChild(root_layer);
   root_layer->AddChild(content_layer);
   root_layer->AddChild(scrollbar_layer);
 
   root_layer->SetScrollOffset(gfx::ScrollOffset(0, 0));
   scrollbar_layer->SetBounds(gfx::Size(70, 10));
   scrollbar_layer->SetScrollLayer(root_layer->id());
   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(20, 10));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(10);
   scrollbar_layer->fake_scrollbar()->set_thumb_length(4);
   LayerImpl* root_clip_layer_impl = nullptr;
-  LayerImpl* root_layer_impl = nullptr;
   PaintedScrollbarLayerImpl* scrollbar_layer_impl = nullptr;
 
   UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   scrollbar_layer->fake_scrollbar()->set_has_thumb(false);
 
   UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(10, 0, 0, 0).ToString(),
@@ skipping 20 matching lines @@
 
   root_layer->SetScrollOffset(gfx::ScrollOffset(0, 0));
   scrollbar_layer->SetBounds(gfx::Size(70, 10));
   scrollbar_layer->SetScrollLayer(root_layer->id());
   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(20, 10));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(10);
   scrollbar_layer->fake_scrollbar()->set_thumb_length(4);
   layer_tree_host_->UpdateLayers();
   LayerImpl* root_clip_layer_impl = nullptr;
-  LayerImpl* root_layer_impl = nullptr;
   PaintedScrollbarLayerImpl* scrollbar_layer_impl = nullptr;
 
   // Thumb is at the edge of the scrollbar (should be inset to
   // the start of the track within the scrollbar layer's
   // position).
   UPDATE_AND_EXTRACT_LAYER_POINTERS();
   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Under-scroll (thumb position should clamp and be unchanged).
@@ skipping 41 matching lines @@
   const int kThumbThickness = 3;
   const int kTrackStart = 1;
   const int kTrackLength = 100;
 
   std::unique_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       layer_tree_host_.get(), std::move(scrollbar), false, true,
       kThumbThickness, kTrackStart);
   ScrollbarLayerImplBase* scrollbar_layer_impl =
       static_cast<SolidColorScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1]);
+          layer_impl_tree_root->layer_tree_impl()->LayerById(
+              scrollbar_layer_id_));
   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(10.f);
   scrollbar_layer_impl->SetClipLayerLength(200 / 3.f);
   scrollbar_layer_impl->SetScrollLayerLength(100 + 200 / 3.f);
 
   // Thickness should be overridden to 3.
   {
     std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
     AppendQuadsData data;
     scrollbar_layer_impl->AppendQuads(render_pass.get(), &data);
@@ skipping 35 matching lines @@
   }
 }
 
 TEST_F(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
   const int kThumbThickness = 3;
   const int kTrackStart = 0;
   const int kTrackLength = 10;
 
   std::unique_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
 
-  {
-    scoped_refptr<Layer> layer_tree_root = Layer::Create();
-    scoped_refptr<Layer> scroll_layer = Layer::Create();
-    scroll_layer->SetScrollClipLayerId(layer_tree_root->id());
-    scoped_refptr<Layer> child1 = Layer::Create();
-    scoped_refptr<Layer> child2;
-    const bool kIsLeftSideVerticalScrollbar = false;
-    child2 = SolidColorScrollbarLayer::Create(
-        scrollbar->Orientation(), kThumbThickness, kTrackStart,
-        kIsLeftSideVerticalScrollbar, child1->id());
-    child2->ToScrollbarLayer()->SetScrollLayer(scroll_layer->id());
-    scroll_layer->AddChild(child1);
-    scroll_layer->InsertChild(child2, 1);
-    layer_tree_root->AddChild(scroll_layer);
-    layer_tree_host_->SetRootLayer(layer_tree_root);
+  scoped_refptr<Layer> layer_tree_root = Layer::Create();
+  scoped_refptr<Layer> scroll_layer = Layer::Create();
+  scroll_layer->SetScrollClipLayerId(layer_tree_root->id());
+  scoped_refptr<Layer> child1 = Layer::Create();
+  scoped_refptr<Layer> child2;
+  const bool kIsLeftSideVerticalScrollbar = false;
+  child2 = SolidColorScrollbarLayer::Create(
+      scrollbar->Orientation(), kThumbThickness, kTrackStart,
+      kIsLeftSideVerticalScrollbar, child1->id());
+  child2->ToScrollbarLayer()->SetScrollLayer(scroll_layer->id());
+  scroll_layer->AddChild(child1);
+  scroll_layer->InsertChild(child2, 1);
+  layer_tree_root->AddChild(scroll_layer);
+  layer_tree_host_->SetRootLayer(layer_tree_root);
 
-    // Choose layer bounds to give max_scroll_offset = (8, 8).
-    layer_tree_root->SetBounds(gfx::Size(2, 2));
-    scroll_layer->SetBounds(gfx::Size(10, 10));
+  // Choose layer bounds to give max_scroll_offset = (8, 8).
+  layer_tree_root->SetBounds(gfx::Size(2, 2));
+  scroll_layer->SetBounds(gfx::Size(10, 10));
 
-    layer_tree_host_->UpdateLayers();
-  }
+  layer_tree_host_->UpdateLayers();
 
   LayerImpl* layer_impl_tree_root =
       layer_tree_host_->CommitAndCreateLayerImplTree();
-  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
+  LayerImpl* scroll_layer_impl =
+      layer_impl_tree_root->layer_tree_impl()->LayerById(scroll_layer->id());
 
-  auto* scrollbar_layer_impl =
-      static_cast<ScrollbarLayerImplBase*>(scroll_layer_impl->children()[1]);
+  auto* scrollbar_layer_impl = static_cast<ScrollbarLayerImplBase*>(
+      scroll_layer_impl->layer_tree_impl()->LayerById(child2->id()));
 
   scroll_layer_impl->ScrollBy(gfx::Vector2dF(4.f, 0.f));
 
   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(4.f);
 
   {
     std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
 
     AppendQuadsData data;
@@ skipping 528 matching lines @@
   TestScale(gfx::Rect(1240, 0, 15, 1333), 2.7754839f);
   TestScale(gfx::Rect(1240, 0, 15, 677), 2.46677136f);
 
   // Horizontal Scrollbars.
   TestScale(gfx::Rect(0, 1240, 1333, 15), 2.7754839f);
   TestScale(gfx::Rect(0, 1240, 677, 15), 2.46677136f);
 }
 
 }  // namespace
 }  // namespace cc