Pinch/Zoom Infrastructure & Plumbing CL

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/memory/weak_ptr.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 13 matching lines @@
 
 class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollSimple()
       : initial_scroll_(10, 20),
         second_scroll_(40, 5),
         scroll_amount_(2, -1),
         num_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
+    Layer* root_layer = layer_tree_host()->root_layer();
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
+    root_layer->AddChild(scroll_layer);
+    // Create an effective max_scroll_offset of (100, 100).
+    scroll_layer->SetBounds(gfx::Size(root_layer->bounds().width() + 100,
+                                      root_layer->bounds().height() + 100));
+    scroll_layer->SetIsDrawable(true);
+    scroll_layer->SetScrollClipLayer(root_layer);
+    scroll_layer->SetScrollOffset(initial_scroll_);
+    layer_tree_host()->RegisterViewportLayers(root_layer, scroll_layer, NULL);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
+    Layer* scroll_layer = root->children()[0];
     if (!layer_tree_host()->source_frame_number()) {
-      EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
+      EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
     } else {
-      EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_, root->scroll_offset());
+      EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_,
+                       scroll_layer->scroll_offset());
 
       // Pretend like Javascript updated the scroll position itself.
-      root->SetScrollOffset(second_scroll_);
+      scroll_layer->SetScrollOffset(second_scroll_);
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
-    EXPECT_VECTOR_EQ(gfx::Vector2d(), root->ScrollDelta());
+    LayerImpl* scroll_layer = root->children()[0];
+    EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());
 
-    root->SetScrollable(true);
-    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    root->ScrollBy(scroll_amount_);
+    scroll_layer->SetScrollClipLayer(root->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_, root->scroll_offset());
-        EXPECT_VECTOR_EQ(scroll_amount_, root->ScrollDelta());
+        EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());
+        EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(root->scroll_offset(), second_scroll_);
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_);
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), second_scroll_);
+        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
         EndTest();
         break;
     }
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                    float scale) OVERRIDE {
     num_scrolls_++;
   }
 
   virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
 
  private:
   gfx::Vector2d initial_scroll_;
   gfx::Vector2d second_scroll_;
   gfx::Vector2d scroll_amount_;
   int num_scrolls_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollSimple);
 
 class LayerTreeHostScrollTestScrollMultipleRedraw
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollMultipleRedraw()
       : initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
-    layer_tree_host()->root_layer()->SetBounds(gfx::Size(200, 200));
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+    Layer* root_layer = layer_tree_host()->root_layer();
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
+    root_layer->AddChild(scroll_layer);
+    // Create an effective max_scroll_offset of (100, 100).
+    scroll_layer->SetBounds(gfx::Size(root_layer->bounds().width() + 100,
+                                      root_layer->bounds().height() + 100));
+    scroll_layer->SetIsDrawable(true);
+    scroll_layer->SetScrollClipLayer(root_layer);
+    scroll_layer->SetScrollOffset(initial_scroll_);
+    layer_tree_host()->RegisterViewportLayers(root_layer, scroll_layer, NULL);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
+    Layer* scroll_layer = root->children()[0];
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
         break;
       case 1:
-        EXPECT_VECTOR_EQ(root->scroll_offset(),
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
                          initial_scroll_ + scroll_amount_ + scroll_amount_);
       case 2:
-        EXPECT_VECTOR_EQ(root->scroll_offset(),
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
                          initial_scroll_ + scroll_amount_ + scroll_amount_);
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
+    LayerImpl* scroll_layer = root->children()[0];
     if (impl->active_tree()->source_frame_number() == 0 &&
         impl->SourceAnimationFrameNumber() == 1) {
       // First draw after first commit.
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
-      root->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_);
+      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
+      scroll_layer->ScrollBy(scroll_amount_);
+      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
 
-      EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
       PostSetNeedsRedrawToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 0 &&
                impl->SourceAnimationFrameNumber() == 2) {
       // Second draw after first commit.
-      EXPECT_EQ(root->ScrollDelta(), scroll_amount_);
-      root->ScrollBy(scroll_amount_);
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), scroll_amount_ + scroll_amount_);
+      EXPECT_EQ(scroll_layer->ScrollDelta(), scroll_amount_);
+      scroll_layer->ScrollBy(scroll_amount_);
+      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
+                       scroll_amount_ + scroll_amount_);
 
-      EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
       PostSetNeedsCommitToMainThread();
     } else if (impl->active_tree()->source_frame_number() == 1) {
       // Third or later draw after second commit.
       EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
-      EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
-      EXPECT_VECTOR_EQ(root->scroll_offset(),
+      EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
+      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
                        initial_scroll_ + scroll_amount_ + scroll_amount_);
       EndTest();
     }
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                    float scale) OVERRIDE {
     num_scrolls_++;
   }
 
@@ skipping 19 matching lines @@
         num_did_begin_main_frames_(0),
         num_will_commits_(0),
         num_did_commits_(0),
         num_impl_commits_(0),
         num_impl_scrolls_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void SetupTree() OVERRIDE {
     LayerTreeHostScrollTest::SetupTree();
+    Layer* root_layer = layer_tree_host()->root_layer();
     scoped_refptr<Layer> root_scroll_layer = Layer::Create();
-    root_scroll_layer->SetScrollable(true);
+    root_scroll_layer->SetScrollClipLayer(root_layer);
     root_scroll_layer->SetScrollOffset(initial_scroll_);
     root_scroll_layer->SetBounds(gfx::Size(200, 200));
-    root_scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     root_scroll_layer->SetIsDrawable(true);
-    layer_tree_host()->root_layer()->AddChild(root_scroll_layer);
+    root_layer->AddChild(root_scroll_layer);
 
+    layer_tree_host()->RegisterViewportLayers(
+        root_layer, root_scroll_layer, NULL);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
   }
 
   virtual void WillBeginMainFrame() OVERRIDE {
     num_will_begin_main_frames_++;
     Layer* root_scroll_layer = layer_tree_host()->root_layer()->children()[0];
     switch (num_will_begin_main_frames_) {
       case 1:
         // This will not be aborted because of the initial prop changes.
         EXPECT_EQ(0, num_impl_scrolls_);
@@ skipping 133 matching lines @@
   int num_impl_commits_;
   int num_impl_scrolls_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestScrollAbortedCommit);
 
 class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestFractionalScroll() : scroll_amount_(1.75, 0) {}
 
+  virtual void SetupTree() OVERRIDE {
+    LayerTreeHostScrollTest::SetupTree();
+    Layer* root_layer = layer_tree_host()->root_layer();
+    scoped_refptr<Layer> root_scroll_layer = Layer::Create();
+    root_scroll_layer->SetScrollClipLayer(root_layer);
+    root_scroll_layer->SetBounds(
+        gfx::Size(root_layer->bounds().width() + 100,
+                  root_layer->bounds().height() + 100));
+    root_scroll_layer->SetIsDrawable(true);
+    root_layer->AddChild(root_scroll_layer);
+
+    layer_tree_host()->RegisterViewportLayers(
+        root_layer, root_scroll_layer, NULL);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+  }
+
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
+    LayerImpl* scroll_layer = root->children()[0];
 
     // Check that a fractional scroll delta is correctly accumulated over
     // multiple commits.
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(root->scroll_offset(), gfx::Vector2d(0, 0));
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d(0, 0));
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), gfx::Vector2d(0, 0));
+        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d(0, 0));
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(root->scroll_offset(),
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
                          gfx::ToFlooredVector2d(scroll_amount_));
-        EXPECT_VECTOR_EQ(root->ScrollDelta(),
+        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
                          gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f));
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         EXPECT_VECTOR_EQ(
-            root->scroll_offset(),
+            scroll_layer->scroll_offset(),
             gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_));
         EXPECT_VECTOR_EQ(
-            root->ScrollDelta(),
+            scroll_layer->ScrollDelta(),
             gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f));
         EndTest();
         break;
     }
-    root->ScrollBy(scroll_amount_);
+    scroll_layer->ScrollBy(scroll_amount_);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   gfx::Vector2dF scroll_amount_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostScrollTestFractionalScroll);
 
@@ skipping 11 matching lines @@
     scoped_refptr<Layer> root_layer = Layer::Create();
     root_layer->SetBounds(gfx::Size(10, 10));
 
     root_scroll_layer_ = ContentLayer::Create(&fake_content_layer_client_);
     root_scroll_layer_->SetBounds(gfx::Size(110, 110));
 
     root_scroll_layer_->SetPosition(gfx::Point());
     root_scroll_layer_->SetAnchorPoint(gfx::PointF());
 
     root_scroll_layer_->SetIsDrawable(true);
-    root_scroll_layer_->SetScrollable(true);
-    root_scroll_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+    root_scroll_layer_->SetScrollClipLayer(root_layer);
     root_layer->AddChild(root_scroll_layer_);
 
     child_layer_ = ContentLayer::Create(&fake_content_layer_client_);
     child_layer_->set_did_scroll_callback(
         base::Bind(&LayerTreeHostScrollTestCaseWithChild::DidScroll,
                    base::Unretained(this)));
     child_layer_->SetBounds(gfx::Size(110, 110));
 
     if (scroll_child_layer_) {
       // Scrolls on the child layer will happen at 5, 5. If they are treated
       // like device pixels, and device scale factor is 2, then they will
       // be considered at 2.5, 2.5 in logical pixels, and will miss this layer.
       child_layer_->SetPosition(gfx::Point(5, 5));
     } else {
       // Adjust the child layer horizontally so that scrolls will never hit it.
       child_layer_->SetPosition(gfx::Point(60, 5));
     }
     child_layer_->SetAnchorPoint(gfx::PointF());
 
     child_layer_->SetIsDrawable(true);
-    child_layer_->SetScrollable(true);
-    child_layer_->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+    child_layer_->SetScrollClipLayer(root_layer);
+    child_layer_->SetBounds(root_scroll_layer_->bounds());
     root_scroll_layer_->AddChild(child_layer_);
 
     if (scroll_child_layer_) {
       expected_scroll_layer_ = child_layer_;
       expected_no_scroll_layer_ = root_scroll_layer_;
     } else {
       expected_scroll_layer_ = root_scroll_layer_;
       expected_no_scroll_layer_ = child_layer_;
     }
 
     expected_scroll_layer_->SetScrollOffset(initial_offset_);
 
     layer_tree_host()->SetRootLayer(root_layer);
+    layer_tree_host()->RegisterViewportLayers(
+        root_layer, root_scroll_layer_, NULL);
     LayerTreeHostScrollTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void WillCommit() OVERRIDE {
     // Keep the test committing (otherwise the early out for no update
     // will stall the test).
     if (layer_tree_host()->source_frame_number() < 2) {
       layer_tree_host()->SetNeedsCommit();
@@ skipping 256 matching lines @@
 
 class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestSimple()
       : initial_scroll_(10, 20),
         main_thread_scroll_(40, 5),
         impl_thread_scroll1_(2, -1),
         impl_thread_scroll2_(-3, 10),
         num_scrolls_(0) {}
 
+  virtual void SetupTree() OVERRIDE {
+    LayerTreeHostScrollTest::SetupTree();
+    Layer* root_layer = layer_tree_host()->root_layer();
+    scoped_refptr<Layer> root_scroll_layer = Layer::Create();
+    root_scroll_layer->SetScrollClipLayer(root_layer);
+    root_scroll_layer->SetScrollOffset(initial_scroll_);
+    root_scroll_layer->SetBounds(
+        gfx::Size(root_layer->bounds().width() + 100,
+                  root_layer->bounds().height() + 100));
+    root_scroll_layer->SetIsDrawable(true);
+    root_layer->AddChild(root_scroll_layer);
+
+    layer_tree_host()->RegisterViewportLayers(
+        root_layer, root_scroll_layer, NULL);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+  }
+
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()
-        ->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void Layout() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
+    Layer* scroll_layer = root->children()[0];
     if (!layer_tree_host()->source_frame_number()) {
-      EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
+      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
     } else {
-      EXPECT_VECTOR_EQ(root->scroll_offset(),
+      EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
                        initial_scroll_ + impl_thread_scroll1_);
 
       // Pretend like Javascript updated the scroll position itself with a
       // change of main_thread_scroll.
-      root->SetScrollOffset(initial_scroll_ + main_thread_scroll_ +
-                            impl_thread_scroll1_);
+      scroll_layer->SetScrollOffset(initial_scroll_ + main_thread_scroll_ +
+                                    impl_thread_scroll1_);
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // We force a second draw here of the first commit before activating
     // the second commit.
     if (impl->active_tree()->source_frame_number() == 0)
       impl->SetNeedsRedraw();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
+    LayerImpl* scroll_layer = root->children()[0];
     LayerImpl* pending_root =
         impl->active_tree()->FindPendingTreeLayerById(root->id());
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
         if (!impl->pending_tree()) {
           impl->BlockNotifyReadyToActivateForTesting(true);
-          EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
-          root->ScrollBy(impl_thread_scroll1_);
+          EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
+          scroll_layer->ScrollBy(impl_thread_scroll1_);
 
-          EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
-          EXPECT_VECTOR_EQ(root->ScrollDelta(), impl_thread_scroll1_);
-          EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
+          EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+          EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll1_);
+          EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
           PostSetNeedsCommitToMainThread();
 
           // CommitCompleteOnThread will trigger this function again
           // and cause us to take the else clause.
         } else {
           impl->BlockNotifyReadyToActivateForTesting(false);
           ASSERT_TRUE(pending_root);
           EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
 
-          root->ScrollBy(impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
-          EXPECT_VECTOR_EQ(root->ScrollDelta(),
+          scroll_layer->ScrollBy(impl_thread_scroll2_);
+          EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+          EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),
                            impl_thread_scroll1_ + impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(root->sent_scroll_delta(), impl_thread_scroll1_);
+          EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(),
+                           impl_thread_scroll1_);
 
+          LayerImpl* pending_scroll_layer = pending_root->children()[0];
           EXPECT_VECTOR_EQ(
-              pending_root->scroll_offset(),
+              pending_scroll_layer->scroll_offset(),
               initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
-          EXPECT_VECTOR_EQ(pending_root->ScrollDelta(), impl_thread_scroll2_);
-          EXPECT_VECTOR_EQ(pending_root->sent_scroll_delta(), gfx::Vector2d());
+          EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
+                           impl_thread_scroll2_);
+          EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
+                           gfx::Vector2d());
         }
         break;
       case 1:
         EXPECT_FALSE(impl->pending_tree());
         EXPECT_VECTOR_EQ(
-            root->scroll_offset(),
+            scroll_layer->scroll_offset(),
             initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), impl_thread_scroll2_);
-        EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);
+        EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
         EndTest();
         break;
     }
   }
 
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                    float scale) OVERRIDE {
     num_scrolls_++;
   }
 
@@ skipping 12 matching lines @@
 // This test makes sure that layers pick up scrolls that occur between
 // beginning a commit and finishing a commit (aka scroll deltas not
 // included in sent scroll delta) still apply to layers that don't
 // push properties.
 class ImplSidePaintingScrollTestImplOnlyScroll
     : public ImplSidePaintingScrollTest {
  public:
   ImplSidePaintingScrollTestImplOnlyScroll()
       : initial_scroll_(20, 10), impl_thread_scroll_(-2, 3) {}
 
+  virtual void SetupTree() OVERRIDE {
+    LayerTreeHostScrollTest::SetupTree();
+    Layer* root_layer = layer_tree_host()->root_layer();
+    scoped_refptr<Layer> root_scroll_layer = Layer::Create();
+    root_scroll_layer->SetScrollClipLayer(root_layer);
+    root_scroll_layer->SetScrollOffset(initial_scroll_);
+    root_scroll_layer->SetBounds(
+        gfx::Size(root_layer->bounds().width() + 100,
+                  root_layer->bounds().height() + 100));
+    root_scroll_layer->SetIsDrawable(true);
+    root_layer->AddChild(root_scroll_layer);
+
+    layer_tree_host()->RegisterViewportLayers(
+        root_layer, root_scroll_layer, NULL);
+    layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
+  }
+
   virtual void BeginTest() OVERRIDE {
-    layer_tree_host()->root_layer()->SetScrollable(true);
-    layer_tree_host()->root_layer()->SetMaxScrollOffset(
-        gfx::Vector2d(100, 100));
-    layer_tree_host()->root_layer()->SetScrollOffset(initial_scroll_);
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void WillCommit() OVERRIDE {
     Layer* root = layer_tree_host()->root_layer();
+    Layer* scroll_layer = root->children()[0];
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
-        EXPECT_TRUE(root->needs_push_properties());
+        EXPECT_TRUE(scroll_layer->needs_push_properties());
         break;
       case 1:
         // Even if this layer doesn't need push properties, it should
         // still pick up scrolls that happen on the active layer during
         // commit.
-        EXPECT_FALSE(root->needs_push_properties());
+        EXPECT_FALSE(scroll_layer->needs_push_properties());
         break;
     }
   }
 
   virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // Scroll after the 2nd commit has started.
     if (impl->active_tree()->source_frame_number() == 0) {
       LayerImpl* active_root = impl->active_tree()->root_layer();
+      LayerImpl* active_scroll_layer = active_root->children()[0];
       ASSERT_TRUE(active_root);
-      active_root->ScrollBy(impl_thread_scroll_);
+      ASSERT_TRUE(active_scroll_layer);
+      active_scroll_layer->ScrollBy(impl_thread_scroll_);
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     // We force a second draw here of the first commit before activating
     // the second commit.
     LayerImpl* active_root = impl->active_tree()->root_layer();
+    LayerImpl* active_scroll_layer =
+        active_root ? active_root->children()[0] : NULL;
     LayerImpl* pending_root = impl->pending_tree()->root_layer();
+    LayerImpl* pending_scroll_layer = pending_root->children()[0];
 
     ASSERT_TRUE(pending_root);
+    ASSERT_TRUE(pending_scroll_layer);
     switch (impl->pending_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(pending_root->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(pending_root->ScrollDelta(), gfx::Vector2d());
-        EXPECT_VECTOR_EQ(pending_root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
+                         initial_scroll_);
+        EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2d());
         EXPECT_FALSE(active_root);
         break;
       case 1:
         // Even though the scroll happened during the commit, both layers
         // should have the appropriate scroll delta.
-        EXPECT_VECTOR_EQ(pending_root->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(pending_root->ScrollDelta(), impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(pending_root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
+                         initial_scroll_);
+        EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
+                         impl_thread_scroll_);
+        EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2d());
         ASSERT_TRUE(active_root);
-        EXPECT_VECTOR_EQ(active_root->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(active_root->ScrollDelta(), impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(active_root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(active_scroll_layer->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR_EQ(active_scroll_layer->ScrollDelta(),
+                         impl_thread_scroll_);
+        EXPECT_VECTOR_EQ(active_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2d());
         break;
       case 2:
         // On the next commit, this delta should have been sent and applied.
-        EXPECT_VECTOR_EQ(pending_root->scroll_offset(),
+        EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
                          initial_scroll_ + impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(pending_root->ScrollDelta(), gfx::Vector2d());
-        EXPECT_VECTOR_EQ(pending_root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
+                         gfx::Vector2d());
         EndTest();
         break;
     }
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
 
     LayerImpl* root = impl->active_tree()->root_layer();
+    LayerImpl* scroll_layer = root->children()[0];
 
     switch (impl->active_tree()->source_frame_number()) {
       case 0:
-        EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), gfx::Vector2d());
-        EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
         PostSetNeedsCommitToMainThread();
         break;
       case 1:
-        EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
-        EXPECT_VECTOR_EQ(root->ScrollDelta(), impl_thread_scroll_);
-        EXPECT_VECTOR_EQ(root->sent_scroll_delta(), gfx::Vector2d());
+        EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);
+        EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);
+        EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());
         PostSetNeedsCommitToMainThread();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   gfx::Vector2d initial_scroll_;
   gfx::Vector2d impl_thread_scroll_;
 };
 
 MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestImplOnlyScroll);
 
 class LayerTreeHostScrollTestScrollZeroMaxScrollOffset
     : public LayerTreeHostScrollTest {
  public:
   LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
 
+  virtual void SetupTree() OVERRIDE {
+    LayerTreeTest::SetupTree();
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
+    layer_tree_host()->root_layer()->AddChild(scroll_layer);
+  }
+
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerImpl* root = impl->active_tree()->root_layer();
-    root->SetScrollable(true);
+    LayerImpl* scroll_layer = root->children()[0];
+    scroll_layer->SetScrollClipLayer(root->id());
 
-    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+    // Set max_scroll_offset = (100, 100).
+    scroll_layer->SetBounds(
+        gfx::Size(root->bounds().width() + 100, root->bounds().height() + 100));
     EXPECT_EQ(InputHandler::ScrollStarted,
-              root->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::Gesture));
+              scroll_layer->TryScroll(gfx::PointF(0.0f, 1.0f),
+                                      InputHandler::Gesture));
 
-    root->SetMaxScrollOffset(gfx::Vector2d(0, 0));
+    // Set max_scroll_offset = (0, 0).
+    scroll_layer->SetBounds(root->bounds());
     EXPECT_EQ(InputHandler::ScrollIgnored,
-              root->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::Gesture));
+              scroll_layer->TryScroll(gfx::PointF(0.0f, 1.0f),
+                                      InputHandler::Gesture));
 
-    root->SetMaxScrollOffset(gfx::Vector2d(-100, -100));
+    // Set max_scroll_offset = (-100, -100).
+    scroll_layer->SetBounds(gfx::Size());
     EXPECT_EQ(InputHandler::ScrollIgnored,
-              root->TryScroll(gfx::PointF(0.0f, 1.0f), InputHandler::Gesture));
+              scroll_layer->TryScroll(gfx::PointF(0.0f, 1.0f),
+                                      InputHandler::Gesture));
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostScrollTestScrollZeroMaxScrollOffset);
 
@@ skipping 121 matching lines @@
     Layer* layer_;
   };
 
   Layer* CreateScrollLayer(Layer* parent, FakeLayerScrollClient* client) {
     scoped_refptr<Layer> scroll_layer =
         ContentLayer::Create(&fake_content_layer_client_);
     scroll_layer->SetBounds(gfx::Size(110, 110));
     scroll_layer->SetPosition(gfx::Point(0, 0));
     scroll_layer->SetAnchorPoint(gfx::PointF());
     scroll_layer->SetIsDrawable(true);
-    scroll_layer->SetScrollable(true);
-    scroll_layer->SetMaxScrollOffset(gfx::Vector2d(100, 100));
+    scroll_layer->SetScrollClipLayer(parent);
+    scroll_layer->SetBounds(gfx::Size(parent->bounds().width() + 100,
+                                      parent->bounds().height() + 100));
     scroll_layer->set_did_scroll_callback(base::Bind(
         &FakeLayerScrollClient::DidScroll, base::Unretained(client)));
     client->owner_ = this;
     client->layer_ = scroll_layer.get();
     parent->AddChild(scroll_layer);
     return scroll_layer.get();
   }
 
   FakeLayerScrollClient root_scroll_layer_client_;
   FakeLayerScrollClient sibling_scroll_layer_client_;
   FakeLayerScrollClient child_scroll_layer_client_;
 
   FakeContentLayerClient fake_content_layer_client_;
 
   bool scroll_destroy_whole_tree_;
 };
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyLayer) {
     RunTest(true, false, false);
 }
 
 TEST_F(LayerTreeHostScrollTestLayerStructureChange, ScrollDestroyWholeTree) {
     scroll_destroy_whole_tree_ = true;
     RunTest(true, false, false);
 }
 
 }  // namespace
 }  // namespace cc