Pinch/Zoom Infrastructure & Plumbing CL

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 "base/containers/hash_tables.h"
 #include "cc/animation/scrollbar_animation_controller.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/scrollbar_layer_interface.h"
@@ skipping 27 matching lines @@
     bool reverse_order,
     bool use_solid_color_scrollbar,
     int thumb_thickness) {
   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,
-        kIsLeftSideVerticalScrollbar, child1->id());
+        kIsLeftSideVerticalScrollbar, child1.get());
   } else {
-    child2 = PaintedScrollbarLayer::Create(scrollbar.Pass(), child1->id());
+    child2 = PaintedScrollbarLayer::Create(scrollbar.Pass(), child1.get());
   }
   layer_tree_root->AddChild(child1);
   layer_tree_root->InsertChild(child2, reverse_order ? 0 : 1);
   host->SetRootLayer(layer_tree_root);
   return host->CommitAndCreateLayerImplTree();
 }
 
 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       host.get(), scrollbar.Pass(), false, false, 0);
 
   LayerImpl* cc_child1 = layer_impl_tree_root->children()[0];
   PaintedScrollbarLayerImpl* cc_child2 =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
-  EXPECT_EQ(cc_child1->horizontal_scrollbar_layer(), cc_child2);
+  EXPECT_EQ(cc_child1->scrollbars()->size(), 1UL);
+  EXPECT_EQ(*(cc_child1->scrollbars()->begin()), cc_child2);
 }
 
 TEST(ScrollbarLayerTest, ResolveScrollLayerPointer_ReverseOrder) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       host.get(), scrollbar.Pass(), true, false, 0);
 
   PaintedScrollbarLayerImpl* cc_child1 =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[0]);
   LayerImpl* cc_child2 = layer_impl_tree_root->children()[1];
 
-  EXPECT_EQ(cc_child2->horizontal_scrollbar_layer(), cc_child1);
+  EXPECT_EQ(cc_child2->scrollbars()->size(), 1UL);
+  EXPECT_EQ(*(cc_child2->scrollbars()->begin()), cc_child1);
 }
 
 TEST(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
 
   // Create and attach a non-overlay scrollbar.
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       host.get(), scrollbar.Pass(), false, false, 0);
   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
@@ skipping 20 matching lines @@
   EXPECT_EQ(InputHandler::ScrollIgnored,
             scrollbar_layer_impl->TryScroll(gfx::Point(0, 0),
                                             InputHandler::Gesture));
 }
 
 TEST(PaintedScrollbarLayerTest, ScrollOffsetSynchronization) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
 
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
+  scoped_refptr<Layer> scroll_layer = Layer::Create();
   scoped_refptr<Layer> content_layer = Layer::Create();
   scoped_refptr<Layer> scrollbar_layer =
-      PaintedScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root->id());
+      PaintedScrollbarLayer::Create(scrollbar.Pass(), layer_tree_root.get());
 
-  layer_tree_root->SetScrollable(true);
-  layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
-  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
-  layer_tree_root->SetBounds(gfx::Size(100, 200));
+  // Choose bounds to give max_scroll_offset = (30, 50).
+  layer_tree_root->SetBounds(gfx::Size(70, 150));
+  scroll_layer->SetScrollClipLayer(layer_tree_root.get());
+  scroll_layer->SetScrollOffset(gfx::Vector2d(10, 20));
+  scroll_layer->SetBounds(gfx::Size(100, 200));
   content_layer->SetBounds(gfx::Size(100, 200));
 
   host->SetRootLayer(layer_tree_root);
-  layer_tree_root->AddChild(content_layer);
+  layer_tree_root->AddChild(scroll_layer);
+  scroll_layer->AddChild(content_layer);
   layer_tree_root->AddChild(scrollbar_layer);
+  scrollbar_layer->ToScrollbarLayer()->SetScrollLayer(scroll_layer);
+  scrollbar_layer->ToScrollbarLayer()->SetClipLayer(layer_tree_root);
 
   layer_tree_root->SavePaintProperties();
   content_layer->SavePaintProperties();
 
   LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
 
   ScrollbarLayerImplBase* cc_scrollbar_layer =
       static_cast<PaintedScrollbarLayerImpl*>(
           layer_impl_tree_root->children()[1]);
 
   EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(30, cc_scrollbar_layer->maximum());
 
-  layer_tree_root->SetScrollOffset(gfx::Vector2d(100, 200));
-  layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(300, 500));
-  layer_tree_root->SetBounds(gfx::Size(1000, 2000));
+  layer_tree_root->SetBounds(gfx::Size(700, 1500));
   layer_tree_root->SavePaintProperties();
+  scroll_layer->SetBounds(gfx::Size(1000, 2000));
+  scroll_layer->SetScrollOffset(gfx::Vector2d(100, 200));
+  scroll_layer->SavePaintProperties();
   content_layer->SetBounds(gfx::Size(1000, 2000));
   content_layer->SavePaintProperties();
 
   ScrollbarAnimationController* scrollbar_controller =
       layer_impl_tree_root->scrollbar_animation_controller();
   layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
   EXPECT_EQ(scrollbar_controller,
             layer_impl_tree_root->scrollbar_animation_controller());
 
   EXPECT_EQ(100.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 
-  layer_impl_tree_root->ScrollBy(gfx::Vector2d(12, 34));
+  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
+  scroll_layer_impl->ScrollBy(gfx::Vector2d(12, 34));
 
   EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(300, cc_scrollbar_layer->maximum());
 }
 
+#define UPDATE_AND_EXTRACT_LAYER_POINTERS \

[enne (OOO), 2014/01/21 19:00:06]

Can you make this macro more function-like by adding parenthesis and making it
require a semicolon at the end by wrapping it in a do { } while(false)?

[wjmaclean, 2014/01/21 22:37:27]

Done.

+  scrollbar_layer->UpdateThumbAndTrackGeometry(); \
+  root_clip_layer_impl = host->CommitAndCreateLayerImplTree(); \
+  root_layer_impl = root_clip_layer_impl->children()[0]; \
+  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>( \
+      root_layer_impl->children()[1]); \
+  scrollbar_layer_impl->ScrollbarParametersDidChange(); \

[enne (OOO), 2014/01/21 19:00:06]

Trailing \

[wjmaclean, 2014/01/21 22:37:27]

Done.

+
 TEST(ScrollbarLayerTest, ThumbRect) {
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
+  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());
+      FakePaintedScrollbarLayer::Create(false, true, root_layer.get());
 
-  root_layer->SetScrollable(true);
-  root_layer->SetMaxScrollOffset(gfx::Vector2d(80, 0));
+  root_layer->SetScrollClipLayer(root_clip_layer.get());
+  // 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));
 
-  host->SetRootLayer(root_layer);
+  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::Vector2d(0, 0));
   scrollbar_layer->SetBounds(gfx::Size(70, 10));
+  scrollbar_layer->SetScrollLayer(root_layer.get());
+  scrollbar_layer->SetClipLayer(root_clip_layer.get());
   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);
   scrollbar_layer->UpdateThumbAndTrackGeometry();
+  LayerImpl* root_clip_layer_impl = NULL;
   LayerImpl* root_layer_impl = NULL;
   PaintedScrollbarLayerImpl* scrollbar_layer_impl = NULL;
 
   // Thumb is at the edge of the scrollbar (should be inset to
   // the start of the track within the scrollbar layer's
   // position).
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  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).
   root_layer->SetScrollOffset(gfx::Vector2d(-5, 0));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS
   EXPECT_EQ(gfx::Rect(10, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Over-scroll (thumb position should clamp on the far side).
   root_layer->SetScrollOffset(gfx::Vector2d(85, 0));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS
   EXPECT_EQ(gfx::Rect(56, 0, 4, 10).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Change thumb thickness and length.
   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(4);
   scrollbar_layer->fake_scrollbar()->set_thumb_length(6);
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS
   EXPECT_EQ(gfx::Rect(54, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Shrink the scrollbar layer to cover only the track.
   scrollbar_layer->SetBounds(gfx::Size(50, 10));
   scrollbar_layer->fake_scrollbar()->set_location(gfx::Point(30, 10));
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS
   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 
   // Shrink the track in the non-scrolling dimension so that it only covers the
   // middle third of the scrollbar layer (this does not affect the thumb
   // position).
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 12, 50, 6));
 
-  scrollbar_layer->UpdateThumbAndTrackGeometry();
-  root_layer_impl = host->CommitAndCreateLayerImplTree();
-  scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      root_layer_impl->children()[1]);
+  UPDATE_AND_EXTRACT_LAYER_POINTERS
   EXPECT_EQ(gfx::Rect(44, 0, 6, 4).ToString(),
             scrollbar_layer_impl->ComputeThumbQuadRect().ToString());
 }
 
 TEST(ScrollbarLayerTest, SolidColorDrawQuads) {
   const int kThumbThickness = 3;
   const int kTrackLength = 100;
 
   LayerTreeSettings layer_tree_settings;
   scoped_ptr<FakeLayerTreeHost> host =
@@ skipping 55 matching lines @@
 
 TEST(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
   const int kThumbThickness = 3;
   const int kTrackLength = 10;
 
   LayerTreeSettings layer_tree_settings;
   scoped_ptr<FakeLayerTreeHost> host =
       FakeLayerTreeHost::Create(layer_tree_settings);
 
   scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar(false, true, true));
-  LayerImpl* layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
-      host.get(), scrollbar.Pass(), false, true, kThumbThickness);
+
+  {
+    scoped_refptr<Layer> layer_tree_root = Layer::Create();
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
+    scroll_layer->SetScrollClipLayer(layer_tree_root);
+    scoped_refptr<Layer> child1 = Layer::Create();
+    scoped_refptr<Layer> child2;
+    const bool kIsLeftSideVerticalScrollbar = false;
+    child2 = SolidColorScrollbarLayer::Create(
+        scrollbar->Orientation(), kThumbThickness,
+        kIsLeftSideVerticalScrollbar, child1.get());
+    child2->ToScrollbarLayer()->SetScrollLayer(scroll_layer);
+    child2->ToScrollbarLayer()->SetClipLayer(layer_tree_root);
+    scroll_layer->AddChild(child1);
+    scroll_layer->InsertChild(child2, 1);
+    layer_tree_root->AddChild(scroll_layer);
+    host->SetRootLayer(layer_tree_root);
+  }
+  LayerImpl* layer_impl_tree_root = host->CommitAndCreateLayerImplTree();
+  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
+
   ScrollbarLayerImplBase* scrollbar_layer_impl =
       static_cast<PaintedScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1]);
+          scroll_layer_impl->children()[1]);
+
+  // Choose layer bounds to give max_scroll_offset = (8, 8).
+  layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
+  scroll_layer_impl->SetBounds(gfx::Size(10, 10));
+  scroll_layer_impl->ScrollBy(gfx::Vector2dF(4.f, 0.f));
 
   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(4.f);
   scrollbar_layer_impl->SetMaximum(8);
 
-  layer_impl_tree_root->SetScrollable(true);
-  layer_impl_tree_root->SetHorizontalScrollbarLayer(scrollbar_layer_impl);
-  layer_impl_tree_root->SetMaxScrollOffset(gfx::Vector2d(8, 8));
-  layer_impl_tree_root->SetBounds(gfx::Size(2, 2));
-  layer_impl_tree_root->ScrollBy(gfx::Vector2dF(4.f, 0.f));
-
   {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     scrollbar_layer_impl->AppendQuads(&quad_culler, &data);
 
     const QuadList& quads = quad_culler.quad_list();
     ASSERT_EQ(1u, quads.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
     EXPECT_RECT_EQ(gfx::Rect(3, 0, 3, 3), quads[0]->rect);
   }
 }
 
 class ScrollbarLayerSolidColorThumbTest : public testing::Test {
  public:
   ScrollbarLayerSolidColorThumbTest() {
     LayerTreeSettings layer_tree_settings;
     host_impl_.reset(new FakeLayerTreeHostImpl(layer_tree_settings, &proxy_));
 
     const int kThumbThickness = 3;
     const bool kIsLeftSideVerticalScrollbar = false;
+    const bool kIsOverlayScrollbar = false;
 
     horizontal_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
         host_impl_->active_tree(), 1, HORIZONTAL, kThumbThickness,
-        kIsLeftSideVerticalScrollbar);
+        kIsLeftSideVerticalScrollbar, kIsOverlayScrollbar);
     vertical_scrollbar_layer_ = SolidColorScrollbarLayerImpl::Create(
         host_impl_->active_tree(), 2, VERTICAL, kThumbThickness,
-        kIsLeftSideVerticalScrollbar);
+        kIsLeftSideVerticalScrollbar, kIsOverlayScrollbar);
   }
 
  protected:
   FakeImplProxy proxy_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
   scoped_ptr<SolidColorScrollbarLayerImpl> horizontal_scrollbar_layer_;
   scoped_ptr<SolidColorScrollbarLayerImpl> vertical_scrollbar_layer_;
 };
 
 TEST_F(ScrollbarLayerSolidColorThumbTest, SolidColorThumbLength) {
@@ skipping 61 matching lines @@
                  vertical_scrollbar_layer_->ComputeThumbQuadRect());
 }
 
 class ScrollbarLayerTestMaxTextureSize : public LayerTreeTest {
  public:
   ScrollbarLayerTestMaxTextureSize() {}
 
   void SetScrollbarBounds(gfx::Size bounds) { bounds_ = bounds; }
 
   virtual void BeginTest() OVERRIDE {
+    scroll_layer_ = Layer::Create();
+    layer_tree_host()->root_layer()->AddChild(scroll_layer_);
+
     scoped_ptr<Scrollbar> scrollbar(new FakeScrollbar);
-    scrollbar_layer_ = PaintedScrollbarLayer::Create(scrollbar.Pass(), 1);
+    scrollbar_layer_ =
+        PaintedScrollbarLayer::Create(scrollbar.Pass(), scroll_layer_.get());
+    scrollbar_layer_->SetScrollLayer(scroll_layer_);
     scrollbar_layer_->SetLayerTreeHost(layer_tree_host());
     scrollbar_layer_->SetBounds(bounds_);
     layer_tree_host()->root_layer()->AddChild(scrollbar_layer_);
 
-    scroll_layer_ = Layer::Create();
-    scrollbar_layer_->SetScrollLayerId(scroll_layer_->id());
-    layer_tree_host()->root_layer()->AddChild(scroll_layer_);
-
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     const int kMaxTextureSize =
         layer_tree_host()->GetRendererCapabilities().max_texture_size;
 
     // Check first that we're actually testing something.
     EXPECT_GT(scrollbar_layer_->bounds().width(), kMaxTextureSize);
 
@@ skipping 98 matching lines @@
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
     scoped_refptr<Layer> scrollbar_layer;
     if (use_solid_color_scrollbar) {
       const int kThumbThickness = 3;
       const bool kIsLeftSideVerticalScrollbar = false;
       scrollbar_layer =
           SolidColorScrollbarLayer::Create(scrollbar->Orientation(),
                                            kThumbThickness,
                                            kIsLeftSideVerticalScrollbar,
-                                           layer_tree_root->id());
+                                           layer_tree_root.get());
     } else {
       scrollbar_layer = PaintedScrollbarLayer::Create(scrollbar.Pass(),
-                                                      layer_tree_root->id());
+                                                      layer_tree_root.get());
     }
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
     scrollbar_layer->SetBounds(gfx::Size(100, 100));
     layer_tree_root->SetScrollOffset(gfx::Vector2d(10, 20));
-    layer_tree_root->SetMaxScrollOffset(gfx::Vector2d(30, 50));
     layer_tree_root->SetBounds(gfx::Size(100, 200));
     content_layer->SetBounds(gfx::Size(100, 200));
     scrollbar_layer->draw_properties().content_bounds = gfx::Size(100, 200);
     scrollbar_layer->draw_properties().visible_content_rect =
         gfx::Rect(0, 0, 100, 200);
     scrollbar_layer->CreateRenderSurface();
     scrollbar_layer->draw_properties().render_target = scrollbar_layer.get();
 
     testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
     EXPECT_EQ(scrollbar_layer->layer_tree_host(), layer_tree_host_.get());
@@ skipping 46 matching lines @@
       : fake_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
 
   void TestResourceUpload(const float test_scale) {
     layer_tree_host_.reset(
         new MockLayerTreeHost(&fake_client_, layer_tree_settings_));
 
     gfx::Point scrollbar_location(0, 185);
     scoped_refptr<Layer> layer_tree_root = Layer::Create();
     scoped_refptr<Layer> content_layer = Layer::Create();
     scoped_refptr<FakePaintedScrollbarLayer> scrollbar_layer =
-        FakePaintedScrollbarLayer::Create(false, true, layer_tree_root->id());
+        FakePaintedScrollbarLayer::Create(false, true, layer_tree_root.get());
 
     layer_tree_root->AddChild(content_layer);
     layer_tree_root->AddChild(scrollbar_layer);
 
     layer_tree_host_->SetRootLayer(layer_tree_root);
 
     scrollbar_layer->SetIsDrawable(true);
     scrollbar_layer->SetBounds(gfx::Size(100, 15));
     scrollbar_layer->SetPosition(scrollbar_location);
     layer_tree_root->SetBounds(gfx::Size(100, 200));
@@ skipping 49 matching lines @@
 TEST_F(ScaledScrollbarLayerTestResourceCreation, ScaledResourceUpload) {
   // Pick a test scale that moves the scrollbar's (non-zero) position to
   // a non-pixel-aligned location.
   TestResourceUpload(.041f);
   TestResourceUpload(1.41f);
   TestResourceUpload(4.1f);
 }
 
 }  // namespace
 }  // namespace cc