Pinch/Zoom Infrastructure & Plumbing CL

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 186 matching lines @@
       if (scroll_info.scrolls[i].layer_id != id)
         continue;
       times_encountered++;
     }
 
     ASSERT_EQ(0, times_encountered);
   }
 
   LayerImpl* CreateScrollAndContentsLayers(LayerTreeImpl* layer_tree_impl,
                                            gfx::Size content_size) {
+    const int kInnerViewportScrollLayerId = 2;
+    const int kInnerViewportClipLayerId = 4;
+    const int kPageScaleLayerId = 5;
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(layer_tree_impl, 1);
     root->SetBounds(content_size);
     root->SetContentBounds(content_size);
     root->SetPosition(gfx::PointF());
     root->SetAnchorPoint(gfx::PointF());
 
     scoped_ptr<LayerImpl> scroll =
-        LayerImpl::Create(layer_tree_impl, 2);
+        LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
     LayerImpl* scroll_layer = scroll.get();
-    scroll->SetScrollable(true);
     scroll->SetScrollOffset(gfx::Vector2d());
-    scroll->SetMaxScrollOffset(gfx::Vector2d(content_size.width(),
-                                             content_size.height()));
+
+    scoped_ptr<LayerImpl> clip =
+        LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
+    clip->SetBounds(
+        gfx::Size(content_size.width() / 2, content_size.height() / 2));
+
+    scoped_ptr<LayerImpl> page_scale =
+        LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
+
+    scroll->SetScrollClipLayer(clip->id());
     scroll->SetBounds(content_size);
     scroll->SetContentBounds(content_size);
     scroll->SetPosition(gfx::PointF());
     scroll->SetAnchorPoint(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, 3);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetContentBounds(content_size);
     contents->SetPosition(gfx::PointF());
     contents->SetAnchorPoint(gfx::PointF());
 
     scroll->AddChild(contents.Pass());
-    root->AddChild(scroll.Pass());
+    page_scale->AddChild(scroll.Pass());
+    clip->AddChild(page_scale.Pass());
+    root->AddChild(clip.Pass());
 
     layer_tree_impl->SetRootLayer(root.Pass());
+    layer_tree_impl->SetViewportLayersFromIds(
+        kPageScaleLayerId, kInnerViewportScrollLayerId, Layer::INVALID_ID);
+
     return scroll_layer;
   }
 
   LayerImpl* SetupScrollAndContentsLayers(gfx::Size content_size) {
     LayerImpl* scroll_layer = CreateScrollAndContentsLayers(
         host_impl_->active_tree(), content_size);
     host_impl_->active_tree()->DidBecomeActive();
     return scroll_layer;
   }
 
-  scoped_ptr<LayerImpl> CreateScrollableLayer(int id, gfx::Size size) {
+  // TODO(wjmaclean) Add clip-layer pointer to parameters.
+  scoped_ptr<LayerImpl> CreateScrollableLayer(int id,
+                                              gfx::Size size,
+                                              LayerImpl* clip_layer) {
+    DCHECK(clip_layer);
+    DCHECK(id != clip_layer->id());
     scoped_ptr<LayerImpl> layer =
         LayerImpl::Create(host_impl_->active_tree(), id);
-    layer->SetScrollable(true);
+    layer->SetScrollClipLayer(clip_layer->id());
     layer->SetDrawsContent(true);
     layer->SetBounds(size);
     layer->SetContentBounds(size);
-    layer->SetMaxScrollOffset(gfx::Vector2d(size.width() * 2,
-                                            size.height() * 2));
+    clip_layer->SetBounds(gfx::Size(size.width() / 2, size.height() / 2));
     return layer.Pass();
   }
 
   void DrawFrame() {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
@@ skipping 147 matching lines @@
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 0u);
   ExpectClearedScrollDeltasRecursive(root);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) {
   gfx::Vector2d scroll_offset(20, 30);
   gfx::Vector2d scroll_delta(11, -15);
   {
+    scoped_ptr<LayerImpl> root_clip =
+        LayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
-    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    root->SetScrollOffset(scroll_offset);
-    root->SetScrollable(true);
-    root->ScrollBy(scroll_delta);
-    host_impl_->active_tree()->SetRootLayer(root.Pass());
+    root_clip->SetBounds(gfx::Size(10, 10));
+    LayerImpl* root_layer = root.get();
+    root_clip->AddChild(root.Pass());
+    root_layer->SetBounds(gfx::Size(110, 110));
+    root_layer->SetScrollClipLayer(root_clip->id());
+    root_layer->SetScrollOffset(scroll_offset);
+    root_layer->ScrollBy(scroll_delta);
+    host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   }
-  LayerImpl* root = host_impl_->active_tree()->root_layer();
+  LayerImpl* root = host_impl_->active_tree()->root_layer()->children()[0];
 
   scoped_ptr<ScrollAndScaleSet> scroll_info;
 
   scroll_info = host_impl_->ProcessScrollDeltas();
   ASSERT_EQ(scroll_info->scrolls.size(), 1u);
   EXPECT_VECTOR_EQ(root->sent_scroll_delta(), scroll_delta);
   ExpectContains(*scroll_info, root->id(), scroll_delta);
 
   gfx::Vector2d scroll_delta2(-5, 27);
   root->ScrollBy(scroll_delta2);
@@ skipping 270 matching lines @@
       gfx::Point(), SCROLL_FORWARD));
   EXPECT_FALSE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_BACKWARD));
 
   scoped_ptr<PaintedScrollbarLayerImpl> vertical_scrollbar(
       PaintedScrollbarLayerImpl::Create(
           host_impl_->active_tree(),
           20,
           VERTICAL));
   vertical_scrollbar->SetBounds(gfx::Size(15, 1000));
-  host_impl_->RootScrollLayer()->SetVerticalScrollbarLayer(
+  host_impl_->InnerViewportScrollLayer()->AddScrollbar(
       vertical_scrollbar.get());
 
   // Trying to scroll with a vertical scrollbar will succeed.
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_FORWARD));
-  EXPECT_FLOAT_EQ(875.f, host_impl_->RootScrollLayer()->ScrollDelta().y());
+  EXPECT_FLOAT_EQ(875.f,
+                  host_impl_->InnerViewportScrollLayer()->ScrollDelta().y());
   EXPECT_TRUE(host_impl_->ScrollVerticallyByPage(
       gfx::Point(), SCROLL_BACKWARD));
 }
 
 // The user-scrollability breaks for zoomed-in pages. So disable this.
 // http://crbug.com/322223
 TEST_F(LayerTreeHostImplTest, DISABLED_ScrollWithUserUnscrollableLayers) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(200, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   gfx::Size overflow_size(400, 400);
   ASSERT_EQ(1u, scroll_layer->children().size());
   LayerImpl* overflow = scroll_layer->children()[0];
   overflow->SetBounds(overflow_size);
   overflow->SetContentBounds(overflow_size);
-  overflow->SetScrollable(true);
-  overflow->SetMaxScrollOffset(gfx::Vector2d(overflow_size.width(),
-                                             overflow_size.height()));
+  overflow->SetScrollClipLayer(scroll_layer->parent()->id());
   overflow->SetScrollOffset(gfx::Vector2d());
   overflow->SetPosition(gfx::PointF());
   overflow->SetAnchorPoint(gfx::PointF());
 
   DrawFrame();
   gfx::Point scroll_position(10, 10);
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(scroll_position, InputHandler::Wheel));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->TotalScrollOffset());
@@ skipping 42 matching lines @@
   host_impl_->active_tree()->set_needs_update_draw_properties();
 
   EXPECT_EQ(host_impl_->HaveTouchEventHandlersAt(gfx::Point()), false);
 }
 
 TEST_F(LayerTreeHostImplTest, ImplPinchZoom) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
-  EXPECT_EQ(scroll_layer, host_impl_->RootScrollLayer());
+  EXPECT_EQ(scroll_layer, host_impl_->InnerViewportScrollLayer());
 
   float min_page_scale = 1.f, max_page_scale = 4.f;
 
   // The impl-based pinch zoom should adjust the max scroll position.
   {
     host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f,
                                                            min_page_scale,
                                                            max_page_scale);
     host_impl_->active_tree()->SetPageScaleDelta(1.f);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
 
     float page_scale_delta = 2.f;
     host_impl_->ScrollBegin(gfx::Point(50, 50), InputHandler::Gesture);
+    host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(50, 50));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd();
     EXPECT_TRUE(did_request_redraw_);
     EXPECT_TRUE(did_request_commit_);
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
 
     EXPECT_EQ(gfx::Vector2d(75, 75).ToString(),
-              scroll_layer->max_scroll_offset().ToString());
+              scroll_layer->MaxScrollOffset().ToString());
   }
 
   // Scrolling after a pinch gesture should always be in local space.  The
   // scroll deltas do not have the page scale factor applied.
   {
     host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f,
                                                            min_page_scale,
                                                            max_page_scale);
     host_impl_->active_tree()->SetPageScaleDelta(1.f);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
@@ skipping 18 matching lines @@
                    scroll_layer->id(),
                    scroll_delta);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PinchGesture) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
-  LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
+  LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 1.f;
   float max_page_scale = 4.f;
 
   // Basic pinch zoom in gesture
   {
     host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f,
                                                            min_page_scale,
                                                            max_page_scale);
@@ skipping 99 matching lines @@
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(-10, -10));
   }
 
   // Two-finger panning should work when starting fully zoomed out.
   {
     host_impl_->active_tree()->SetPageScaleFactorAndLimits(0.5f,
                                                            0.5f,
                                                            4.f);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
     scroll_layer->SetScrollOffset(gfx::Vector2d(0, 0));
-    host_impl_->active_tree()->UpdateMaxScrollOffset();
 
     host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::Gesture);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(2.f, gfx::Point(0, 0));
     host_impl_->PinchGestureUpdate(1.f, gfx::Point(0, 0));
     host_impl_->ScrollBy(gfx::Point(0, 0), gfx::Vector2d(10, 10));
     host_impl_->PinchGestureUpdate(1.f, gfx::Point(10, 10));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, 2.f);
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(20, 20));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimation) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
-  LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
+  LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 0.5f;
   float max_page_scale = 4.f;
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
@@ skipping 49 matching lines @@
     // Pushed to (0,0) via clamping against contents layer size.
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(-50, -50));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleAnimationNoOp) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
-  LayerImpl* scroll_layer = host_impl_->RootScrollLayer();
+  LayerImpl* scroll_layer = host_impl_->InnerViewportScrollLayer();
   DCHECK(scroll_layer);
 
   float min_page_scale = 0.5f;
   float max_page_scale = 4.f;
   base::TimeTicks start_time = base::TimeTicks() +
                                base::TimeDelta::FromSeconds(1);
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(100);
   base::TimeTicks halfway_through_animation = start_time + duration / 2;
   base::TimeTicks end_time = start_time + duration;
 
@@ skipping 59 matching lines @@
   host_impl_ = make_scoped_ptr(host_impl_override_time);
   host_impl_->InitializeRenderer(CreateOutputSurface());
   host_impl_->SetViewportSize(viewport_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(viewport_size);
 
   scoped_ptr<LayerImpl> scroll =
       LayerImpl::Create(host_impl_->active_tree(), 2);
-  scroll->SetScrollable(true);
+  scroll->SetScrollClipLayer(root->id());
   scroll->SetScrollOffset(gfx::Vector2d());
-  scroll->SetMaxScrollOffset(gfx::Vector2d(content_size.width(),
-                                           content_size.height()));
+  root->SetBounds(viewport_size);
   scroll->SetBounds(content_size);
   scroll->SetContentBounds(content_size);
 
   scoped_ptr<LayerImpl> contents =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   contents->SetDrawsContent(true);
   contents->SetBounds(content_size);
   contents->SetContentBounds(content_size);
 
   scoped_ptr<PaintedScrollbarLayerImpl> scrollbar =
       PaintedScrollbarLayerImpl::Create(host_impl_->active_tree(), 4, VERTICAL);
-  scroll->SetVerticalScrollbarLayer(scrollbar.get());
+  scrollbar->SetScrollLayerById(2);
+  scrollbar->SetClipLayerById(1);
 
   scroll->AddChild(contents.Pass());
   root->AddChild(scroll.Pass());
   root->AddChild(scrollbar.PassAs<LayerImpl>());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 2, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
 
   base::TimeTicks fake_now = gfx::FrameTime::Now();
   host_impl_override_time->SetCurrentPhysicalTimeTicksForTest(fake_now);
 
   // If no scroll happened recently, StartScrollbarAnimation should have no
   // effect.
   host_impl_->StartScrollbarAnimation();
   EXPECT_EQ(base::TimeDelta(), requested_scrollbar_animation_delay_);
@@ skipping 30 matching lines @@
   // If no scroll happened recently, StartScrollbarAnimation should have no
   // effect.
   fake_now += base::TimeDelta::FromMilliseconds(25);
   host_impl_override_time->SetCurrentPhysicalTimeTicksForTest(fake_now);
   host_impl_->StartScrollbarAnimation();
   EXPECT_EQ(base::TimeDelta(), requested_scrollbar_animation_delay_);
   EXPECT_FALSE(did_request_redraw_);
 
   // Setting the scroll offset outside a scroll should also cause the scrollbar
   // to appear and to schedule a fade.
-  host_impl_->RootScrollLayer()->SetScrollOffset(gfx::Vector2d(5, 5));
+  host_impl_->InnerViewportScrollLayer()->SetScrollOffset(gfx::Vector2d(5, 5));
   host_impl_->StartScrollbarAnimation();
   EXPECT_LT(base::TimeDelta::FromMilliseconds(19),
             requested_scrollbar_animation_delay_);
   EXPECT_FALSE(did_request_redraw_);
   requested_scrollbar_animation_delay_ = base::TimeDelta();
 
   // None of the above should have called CurrentFrameTimeTicks, so if we call
   // it now we should get the current time.
   fake_now += base::TimeDelta::FromMilliseconds(10);
   host_impl_override_time->SetCurrentPhysicalTimeTicksForTest(fake_now);
@@ skipping 13 matching lines @@
   CreateHostImpl(settings, CreateOutputSurface());
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->SetViewportSize(device_viewport_size);
 
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(viewport_size);
 
   scoped_ptr<LayerImpl> scroll =
       LayerImpl::Create(host_impl_->active_tree(), 2);
-  scroll->SetScrollable(true);
+  scroll->SetScrollClipLayer(root->id());
   scroll->SetScrollOffset(gfx::Vector2d());
-  scroll->SetMaxScrollOffset(gfx::Vector2d(content_size.width(),
-                                           content_size.height()));
   scroll->SetBounds(content_size);
   scroll->SetContentBounds(content_size);
 
   scoped_ptr<LayerImpl> contents =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   contents->SetDrawsContent(true);
   contents->SetBounds(content_size);
   contents->SetContentBounds(content_size);
 
   // The scrollbar is on the right side.
   scoped_ptr<PaintedScrollbarLayerImpl> scrollbar =
       PaintedScrollbarLayerImpl::Create(host_impl_->active_tree(), 5, VERTICAL);
   scrollbar->SetDrawsContent(true);
   scrollbar->SetBounds(gfx::Size(15, viewport_size.height()));
   scrollbar->SetContentBounds(gfx::Size(15, viewport_size.height()));
   scrollbar->SetPosition(gfx::Point(285, 0));
-  scroll->SetVerticalScrollbarLayer(scrollbar.get());
+  scrollbar->SetScrollLayerById(2);
 
   scroll->AddChild(contents.Pass());
   root->AddChild(scroll.Pass());
   root->AddChild(scrollbar.PassAs<LayerImpl>());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 2, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
 
-  LayerImpl* root_scroll = host_impl_->active_tree()->RootScrollLayer();
+  LayerImpl* root_scroll =
+      host_impl_->active_tree()->InnerViewportScrollLayer();
   ASSERT_TRUE(root_scroll->scrollbar_animation_controller());
   ScrollbarAnimationControllerThinning* scrollbar_animation_controller =
       static_cast<ScrollbarAnimationControllerThinning*>(
           root_scroll->scrollbar_animation_controller());
   scrollbar_animation_controller->set_mouse_move_distance_for_test(100.f);
 
   host_impl_->MouseMoveAt(gfx::Point(1, 1));
   EXPECT_FALSE(scrollbar_animation_controller->mouse_is_near_scrollbar());
 
   host_impl_->MouseMoveAt(gfx::Point(200, 50));
@@ skipping 427 matching lines @@
                                            true,
                                            host_impl_->resource_provider()));
 
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetScrollable(false);
+  root->SetScrollClipLayer(Layer::INVALID_ID);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   DrawFrame();
 
   // Scroll event is ignored because layer is not scrollable.
   EXPECT_EQ(InputHandler::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollNonScrollableRootWithTopControls) {
   LayerTreeSettings settings;
   settings.calculate_top_controls_position = true;
   settings.top_controls_height = 50;
 
   CreateHostImpl(settings, CreateOutputSurface());
 
-  gfx::Size layer_size(5, 5);
+  gfx::Size layer_size(10, 10);
+  gfx::Size clip_size(5, 5);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetScrollable(true);
-  root->SetMaxScrollOffset(gfx::Vector2d(layer_size.width(),
-                                         layer_size.height()));
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 2);
+  root_clip->SetBounds(clip_size);
+  root->SetScrollClipLayer(root_clip->id());
   root->SetBounds(layer_size);
   root->SetContentBounds(layer_size);
   root->SetPosition(gfx::PointF());
   root->SetAnchorPoint(gfx::PointF());
   root->SetDrawsContent(false);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
-  host_impl_->active_tree()->FindRootScrollLayer();
+  int root_id = root->id();
+  root_clip->AddChild(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(
+      root_id, root_id, Layer::INVALID_ID);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture));
 
   host_impl_->top_controls_manager()->ScrollBegin();
   host_impl_->top_controls_manager()->ScrollBy(gfx::Vector2dF(0.f, 50.f));
   host_impl_->top_controls_manager()->ScrollEnd();
   EXPECT_EQ(host_impl_->top_controls_manager()->content_top_offset(), 0.f);
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(),
                                     InputHandler::Gesture));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollNonCompositedRoot) {
   // Test the configuration where a non-composited root layer is embedded in a
   // scrollable outer layer.
   gfx::Size surface_size(10, 10);
+  gfx::Size contents_size(20, 20);
 
   scoped_ptr<LayerImpl> content_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   content_layer->SetDrawsContent(true);
   content_layer->SetPosition(gfx::PointF());
   content_layer->SetAnchorPoint(gfx::PointF());
   content_layer->SetBounds(surface_size);
-  content_layer->SetContentBounds(gfx::Size(surface_size.width() * 2,
-                                            surface_size.height() * 2));
+  content_layer->SetContentBounds(contents_size);
   content_layer->SetContentsScale(2.f, 2.f);
 
+  scoped_ptr<LayerImpl> scroll_clip_layer =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scroll_clip_layer->SetBounds(surface_size);
+
   scoped_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 2);
-  scroll_layer->SetScrollable(true);
-  scroll_layer->SetMaxScrollOffset(gfx::Vector2d(surface_size.width(),
-                                                 surface_size.height()));
-  scroll_layer->SetBounds(surface_size);
-  scroll_layer->SetContentBounds(surface_size);
+  scroll_layer->SetScrollClipLayer(3);
+  scroll_layer->SetBounds(contents_size);
+  scroll_layer->SetContentBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
   scroll_layer->SetAnchorPoint(gfx::PointF());
   scroll_layer->AddChild(content_layer.Pass());
+  scroll_clip_layer->AddChild(scroll_layer.Pass());
 
-  host_impl_->active_tree()->SetRootLayer(scroll_layer.Pass());
+  host_impl_->active_tree()->SetRootLayer(scroll_clip_layer.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
+  gfx::Size contents_size(20, 20);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
-  root->SetContentBounds(surface_size);
-  root->AddChild(CreateScrollableLayer(2, surface_size));
+  root->SetContentBounds(contents_size);
+  root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  root->AddChild(CreateScrollableLayer(2, surface_size));
+  root->AddChild(CreateScrollableLayer(2, surface_size, root.get()));
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   // Scroll event is ignored because the input coordinate is outside the layer
   // boundaries.
   EXPECT_EQ(InputHandler::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(15, 5),
                                     InputHandler::Wheel));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, surface_size);
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, surface_size, root.get());
   host_impl_->SetViewportSize(surface_size);
 
   gfx::Transform matrix;
   matrix.RotateAboutXAxis(180.0);
   child->SetTransform(matrix);
   child->SetDoubleSided(false);
 
   root->AddChild(child.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   DrawFrame();
 
   // Scroll event is ignored because the scrollable layer is not facing the
   // viewer and there is nothing scrollable behind it.
   EXPECT_EQ(InputHandler::ScrollIgnored,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlockedByContentLayer) {
   gfx::Size surface_size(10, 10);
-  scoped_ptr<LayerImpl> content_layer = CreateScrollableLayer(1, surface_size);
+  scoped_ptr<LayerImpl> clip_layer =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scoped_ptr<LayerImpl> content_layer =
+      CreateScrollableLayer(1, surface_size, clip_layer.get());
   content_layer->SetShouldScrollOnMainThread(true);
-  content_layer->SetScrollable(false);
+  content_layer->SetScrollClipLayer(Layer::INVALID_ID);
 
-  scoped_ptr<LayerImpl> scroll_layer = CreateScrollableLayer(2, surface_size);
+  // Note: we can use the same clip layer for both since both calls to
+  // CreateScrollableLayer() use the same surface size.
+  scoped_ptr<LayerImpl> scroll_layer =
+      CreateScrollableLayer(2, surface_size, clip_layer.get());
   scroll_layer->AddChild(content_layer.Pass());
+  clip_layer->AddChild(scroll_layer.Pass());
 
-  host_impl_->active_tree()->SetRootLayer(scroll_layer.Pass());
+  host_impl_->active_tree()->SetRootLayer(clip_layer.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   // Scrolling fails because the content layer is asking to be scrolled on the
   // main thread.
   EXPECT_EQ(InputHandler::ScrollOnMainThread,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnMainThread) {
-  gfx::Size surface_size(10, 10);
+  gfx::Size surface_size(20, 20);
   float page_scale = 2.f;
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  scoped_ptr<LayerImpl> root_scrolling = CreateScrollableLayer(2, surface_size);
-  root->AddChild(root_scrolling.Pass());
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 2);
+  scoped_ptr<LayerImpl> root_scrolling =
+      CreateScrollableLayer(3, surface_size, root_clip.get());
+  root_clip->AddChild(root_scrolling.Pass());
+  root->AddChild(root_clip.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
+  // The behaviour in this test assumes the page scale is applied at a layer
+  // above the clip layer.
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 3, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
-  LayerImpl* root_scroll = host_impl_->active_tree()->RootScrollLayer();
+  LayerImpl* root_scroll =
+      host_impl_->active_tree()->InnerViewportScrollLayer();
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta = scroll_delta;
-  gfx::Vector2d expected_max_scroll = root_scroll->max_scroll_offset();
+  gfx::Vector2d expected_max_scroll = root_scroll->MaxScrollOffset();
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
   // Set new page scale from main thread.
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(page_scale,
                                                          page_scale,
                                                          page_scale);
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(), root_scroll->id(), expected_scroll_delta);
 
   // The scroll range should also have been updated.
-  EXPECT_EQ(expected_max_scroll, root_scroll->max_scroll_offset());
+  EXPECT_EQ(expected_max_scroll, root_scroll->MaxScrollOffset());
 
   // The page scale delta remains constant because the impl thread did not
   // scale.
   EXPECT_EQ(1.f, host_impl_->active_tree()->page_scale_delta());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootAndChangePageScaleOnImplThread) {
-  gfx::Size surface_size(10, 10);
+  gfx::Size surface_size(20, 20);
   float page_scale = 2.f;
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  scoped_ptr<LayerImpl> root_scrolling = CreateScrollableLayer(2, surface_size);
-  root->AddChild(root_scrolling.Pass());
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 2);
+  scoped_ptr<LayerImpl> root_scrolling =
+      CreateScrollableLayer(3, surface_size, root_clip.get());
+  root_clip->AddChild(root_scrolling.Pass());
+  root->AddChild(root_clip.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
+  // The behaviour in this test assumes the page scale is applied at a layer
+  // above the clip layer.
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 3, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, page_scale);
   DrawFrame();
 
-  LayerImpl* root_scroll = host_impl_->active_tree()->RootScrollLayer();
+  LayerImpl* root_scroll =
+      host_impl_->active_tree()->InnerViewportScrollLayer();
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta = scroll_delta;
-  gfx::Vector2d expected_max_scroll = root_scroll->max_scroll_offset();
+  gfx::Vector2d expected_max_scroll = root_scroll->MaxScrollOffset();
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
   // Set new page scale on impl thread by pinching.
   host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(page_scale, gfx::Point());
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd();
   DrawOneFrame();
 
   // The scroll delta is not scaled because the main thread did not scale.
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(), root_scroll->id(), expected_scroll_delta);
 
   // The scroll range should also have been updated.
-  EXPECT_EQ(expected_max_scroll, root_scroll->max_scroll_offset());
+  EXPECT_EQ(expected_max_scroll, root_scroll->MaxScrollOffset());
 
   // The page scale delta should match the new scale on the impl side.
   EXPECT_EQ(page_scale, host_impl_->active_tree()->total_page_scale_factor());
 }
 
 TEST_F(LayerTreeHostImplTest, PageScaleDeltaAppliedToRootScrollLayerOnly) {
   gfx::Size surface_size(10, 10);
   float default_page_scale = 1.f;
   gfx::Transform default_page_scale_matrix;
   default_page_scale_matrix.Scale(default_page_scale, default_page_scale);
 
   float new_page_scale = 2.f;
   gfx::Transform new_page_scale_matrix;
   new_page_scale_matrix.Scale(new_page_scale, new_page_scale);
 
   // Create a normal scrollable root layer and another scrollable child layer.
   LayerImpl* scroll = SetupScrollAndContentsLayers(surface_size);
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   LayerImpl* child = scroll->children()[0];
 
+  scoped_ptr<LayerImpl> scrollable_child_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 6);
   scoped_ptr<LayerImpl> scrollable_child =
-      CreateScrollableLayer(4, surface_size);
-  child->AddChild(scrollable_child.Pass());
+      CreateScrollableLayer(7, surface_size, scrollable_child_clip.get());
+  scrollable_child_clip->AddChild(scrollable_child.Pass());
+  child->AddChild(scrollable_child_clip.Pass());
   LayerImpl* grand_child = child->children()[0];
 
   // Set new page scale on impl thread by pinching.
   host_impl_->ScrollBegin(gfx::Point(), InputHandler::Gesture);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(new_page_scale, gfx::Point());
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd();
   DrawOneFrame();
 
@@ skipping 19 matching lines @@
   EXPECT_EQ(new_page_scale, scroll->draw_transform().matrix().getDouble(1, 1));
   EXPECT_EQ(new_page_scale, child->draw_transform().matrix().getDouble(0, 0));
   EXPECT_EQ(new_page_scale, child->draw_transform().matrix().getDouble(1, 1));
   EXPECT_EQ(new_page_scale,
             grand_child->draw_transform().matrix().getDouble(0, 0));
   EXPECT_EQ(new_page_scale,
             grand_child->draw_transform().matrix().getDouble(1, 1));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildAndChangePageScaleOnMainThread) {
-  gfx::Size surface_size(10, 10);
+  gfx::Size surface_size(30, 30);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
+  root->SetBounds(gfx::Size(5, 5));
   scoped_ptr<LayerImpl> root_scrolling =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   root_scrolling->SetBounds(surface_size);
   root_scrolling->SetContentBounds(surface_size);
-  root_scrolling->SetScrollable(true);
+  root_scrolling->SetScrollClipLayer(root->id());
+  LayerImpl* root_scrolling_ptr = root_scrolling.get();
   root->AddChild(root_scrolling.Pass());
   int child_scroll_layer_id = 3;
-  scoped_ptr<LayerImpl> child_scrolling =
-      CreateScrollableLayer(child_scroll_layer_id, surface_size);
+  scoped_ptr<LayerImpl> child_scrolling = CreateScrollableLayer(
+      child_scroll_layer_id, surface_size, root_scrolling_ptr);
   LayerImpl* child = child_scrolling.get();
-  root->AddChild(child_scrolling.Pass());
+  root_scrolling_ptr->AddChild(child_scrolling.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 2, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta(scroll_delta);
-  gfx::Vector2d expected_max_scroll(child->max_scroll_offset());
+  gfx::Vector2d expected_max_scroll(child->MaxScrollOffset());
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), scroll_delta);
   host_impl_->ScrollEnd();
 
   float page_scale = 2.f;
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(page_scale,
                                                          1.f,
                                                          page_scale);
 
   DrawOneFrame();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(
       *scroll_info.get(), child_scroll_layer_id, expected_scroll_delta);
 
   // The scroll range should not have changed.
-  EXPECT_EQ(child->max_scroll_offset(), expected_max_scroll);
+  EXPECT_EQ(child->MaxScrollOffset(), expected_max_scroll);
 
   // The page scale delta remains constant because the impl thread did not
   // scale.
   EXPECT_EQ(1.f, host_impl_->active_tree()->page_scale_delta());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildBeyondLimit) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // parent layer is scrolled on the axis on which the child was unable to
   // scroll.
   gfx::Size surface_size(10, 10);
-  scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, surface_size);
+  gfx::Size content_size(20, 20);
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
+  root->SetBounds(surface_size);
 
-  scoped_ptr<LayerImpl> grand_child = CreateScrollableLayer(3, surface_size);
-  grand_child->SetScrollOffset(gfx::Vector2d(0, 5));
+    scoped_ptr<LayerImpl> grand_child =
+        CreateScrollableLayer(3, content_size, root.get());
 
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, surface_size);
-  child->SetScrollOffset(gfx::Vector2d(3, 0));
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, content_size, root.get());
+  LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(grand_child.Pass());
 
+  LayerImpl* child_layer = child.get();
   root->AddChild(child.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
+  grand_child_layer->SetScrollOffset(gfx::Vector2d(0, 5));
+  child_layer->SetScrollOffset(gfx::Vector2d(3, 0));
+
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(-8, -7);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::Wheel));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // The grand child should have scrolled up to its limit.
     LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
     LayerImpl* grand_child = child->children()[0];
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, -5));
 
     // The child should have only scrolled on the other axis.
     ExpectContains(*scroll_info.get(), child->id(), gfx::Vector2d(-3, 0));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
-  gfx::Size surface_size(10, 10);
+  gfx::Size surface_size(20, 20);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  scoped_ptr<LayerImpl> root_scrolling = CreateScrollableLayer(2, surface_size);
+  scoped_ptr<LayerImpl> root_scrolling =
+      CreateScrollableLayer(2, surface_size, root.get());
 
-  scoped_ptr<LayerImpl> grand_child = CreateScrollableLayer(4, surface_size);
-  grand_child->SetScrollOffset(gfx::Vector2d(0, 2));
+  scoped_ptr<LayerImpl> grand_child =
+      CreateScrollableLayer(4, surface_size, root.get());
 
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(3, surface_size);
-  child->SetScrollOffset(gfx::Vector2d(0, 3));
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(3, surface_size, root.get());
+  LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(grand_child.Pass());
 
+  LayerImpl* child_layer = child.get();
   root_scrolling->AddChild(child.Pass());
   root->AddChild(root_scrolling.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 2, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
+
+  grand_child_layer->SetScrollOffset(gfx::Vector2d(0, 2));
+  child_layer->SetScrollOffset(gfx::Vector2d(0, 3));
+
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::NonBubblingGesture));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
@@ skipping 57 matching lines @@
     EXPECT_EQ(grand_child, host_impl_->CurrentlyScrollingLayer());
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scroll_info = host_impl_->ProcessScrollDeltas();
 
     // Should have scrolled by half the amount in layer space (5 - 2/2)
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, 4));
   }
 }
-
 TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
-  scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, content_size);
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, content_size);
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scoped_ptr<LayerImpl> root =
+      CreateScrollableLayer(1, content_size, root_clip.get());
+  // Make 'root' the clip layer for child: since they have the same sizes the
+  // child will have zero max_scroll_offset and scrolls will bubble.
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, content_size, root.get());
+  root->SetBounds(content_size);
 
-  child->SetScrollable(false);
+  int root_scroll_id = root->id();
   root->AddChild(child.Pass());
+  root_clip->AddChild(root.Pass());
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(3, 2, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 4);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::Wheel));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
-    // Only the root should have scrolled.
+    // Only the root scroll should have scrolled.
     ASSERT_EQ(scroll_info->scrolls.size(), 1u);
-    ExpectContains(*scroll_info.get(),
-                   host_impl_->active_tree()->root_layer()->id(),
-                   scroll_delta);
+    ExpectContains(*scroll_info.get(), root_scroll_id, scroll_delta);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   gfx::Size surface_size(10, 10);
-  host_impl_->active_tree()->SetRootLayer(
-      CreateScrollableLayer(1, surface_size));
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 1);
+  scoped_ptr<LayerImpl> root_scroll =
+      CreateScrollableLayer(2, surface_size, root_clip.get());
+  root_clip->AddChild(root_scroll.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(1, 2, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   DrawFrame();
   host_impl_->active_tree()->DetachLayerTree();
-  host_impl_->active_tree()->SetRootLayer(
-      CreateScrollableLayer(2, surface_size));
+  scoped_ptr<LayerImpl> root_clip2 =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scoped_ptr<LayerImpl> root_scroll2 =
+      CreateScrollableLayer(4, surface_size, root_clip2.get());
+  root_clip2->AddChild(root_scroll2.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip2.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(3, 4, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
 
   // Scrolling should still work even though we did not draw yet.
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(5, 5),
                                     InputHandler::Wheel));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollAxisAlignedRotatedLayer) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
@@ skipping 32 matching lines @@
 
   // The layer should have scrolled down in its local coordinates.
   scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(),
                  scroll_layer->id(),
                  wheel_scroll_delta);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollNonAxisAlignedRotatedLayer) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
-  int child_layer_id = 4;
+  int child_layer_id = 6;
   float child_layer_angle = -20.f;
 
   // Create a child layer that is rotated to a non-axis-aligned angle.
+  LayerImpl* clip_layer = host_impl_->active_tree()->root_layer();
   scoped_ptr<LayerImpl> child = CreateScrollableLayer(
-      child_layer_id,
-      scroll_layer->content_bounds());
+      child_layer_id, scroll_layer->content_bounds(), clip_layer);
   gfx::Transform rotate_transform;
   rotate_transform.Translate(-50.0, -50.0);
   rotate_transform.Rotate(child_layer_angle);
   rotate_transform.Translate(50.0, 50.0);
   child->SetTransform(rotate_transform);
 
   // Only allow vertical scrolling.
-  child->SetMaxScrollOffset(gfx::Vector2d(0, child->content_bounds().height()));
+  clip_layer->SetBounds(gfx::Size(child->bounds().width(), 0));
   scroll_layer->AddChild(child.Pass());
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d gesture_scroll_delta(0, 10);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(1, 1),
@@ skipping 144 matching lines @@
   gfx::Vector2dF getter_return_value_;
   gfx::Vector2dF max_scroll_offset_;
   gfx::SizeF scrollable_size_;
   float page_scale_factor_;
 };
 
 TEST_F(LayerTreeHostImplTest, RootLayerScrollOffsetDelegation) {
   TestScrollOffsetDelegate scroll_delegate;
   host_impl_->SetViewportSize(gfx::Size(10, 20));
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
+  LayerImpl* clip_layer = scroll_layer->parent()->parent();
+  clip_layer->SetBounds(gfx::Size(10, 20));
 
   // Setting the delegate results in the current scroll offset being set.
   gfx::Vector2dF initial_scroll_delta(10.f, 10.f);
   scroll_layer->SetScrollOffset(gfx::Vector2d());
   scroll_layer->SetScrollDelta(initial_scroll_delta);
   host_impl_->SetRootLayerScrollOffsetDelegate(&scroll_delegate);
   EXPECT_EQ(initial_scroll_delta.ToString(),
             scroll_delegate.last_set_scroll_offset().ToString());
 
   // Setting the delegate results in the scrollable_size, max_scroll_offset and
@@ skipping 103 matching lines @@
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20));
   EXPECT_EQ(gfx::Vector2dF(0, -20), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(gfx::Vector2dF(10, 0), host_impl_->current_fling_velocity());
 }
 
 
 TEST_F(LayerTreeHostImplTest, OverscrollChildWithoutBubbling) {
   // Scroll child layers beyond their maximum scroll range and make sure root
   // overscroll does not accumulate.
   gfx::Size surface_size(10, 10);
-  scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, surface_size);
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 4);
+  scoped_ptr<LayerImpl> root =
+      CreateScrollableLayer(1, surface_size, root_clip.get());
 
-  scoped_ptr<LayerImpl> grand_child = CreateScrollableLayer(3, surface_size);
-  grand_child->SetScrollOffset(gfx::Vector2d(0, 2));
+  scoped_ptr<LayerImpl> grand_child =
+      CreateScrollableLayer(3, surface_size, root_clip.get());
 
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, surface_size);
-  child->SetScrollOffset(gfx::Vector2d(0, 3));
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, surface_size, root_clip.get());
+  LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(grand_child.Pass());
 
+  LayerImpl* child_layer = child.get();
   root->AddChild(child.Pass());
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  root_clip->AddChild(root.Pass());
+  child_layer->SetScrollOffset(gfx::Vector2d(0, 3));
+  grand_child_layer->SetScrollOffset(gfx::Vector2d(0, 2));
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::NonBubblingGesture));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
 
-    LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
-    LayerImpl* grand_child = child->children()[0];
-
     // The next time we scroll we should only scroll the parent, but overscroll
     // should still not reach the root layer.
     scroll_delta = gfx::Vector2d(0, -30);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::NonBubblingGesture));
-    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
+    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
-    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child);
+    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child_layer);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
 
     // After scrolling the parent, another scroll on the opposite direction
     // should scroll the child, resetting the fling velocity.
     scroll_delta = gfx::Vector2d(0, 70);
     host_impl_->NotifyCurrentFlingVelocity(gfx::Vector2dF(10, 0));
     EXPECT_EQ(gfx::Vector2dF(10, 0), host_impl_->current_fling_velocity());
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::NonBubblingGesture));
-    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
+    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
-    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
+    EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->current_fling_velocity());
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollChildEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible. Overscroll should
   // be reflected only when it has bubbled up to the root scrolling layer.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
-  scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, content_size);
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, content_size);
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scoped_ptr<LayerImpl> root =
+      CreateScrollableLayer(1, content_size, root_clip.get());
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, content_size, root_clip.get());
 
-  child->SetScrollable(false);
+  child->SetScrollClipLayer(Layer::INVALID_ID);
   root->AddChild(child.Pass());
+  root_clip->AddChild(root.Pass());
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(3, 1, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 8);
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::Wheel));
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     EXPECT_EQ(gfx::Vector2dF(0, 6), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     EXPECT_EQ(gfx::Vector2dF(0, 14), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollAlways) {
   LayerTreeSettings settings;
   settings.always_overscroll = true;
   CreateHostImpl(settings, CreateOutputSurface());
 
-  SetupScrollAndContentsLayers(gfx::Size(50, 50));
+  LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(50, 50));
+  LayerImpl* clip_layer = scroll_layer->parent()->parent();
+  clip_layer->SetBounds(gfx::Size(50, 50));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->SetPageScaleFactorAndLimits(1.f, 0.5f, 4.f);
   DrawFrame();
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->current_fling_velocity());
 
   // Even though the layer can't scroll the overscroll still happens.
   EXPECT_EQ(InputHandler::ScrollStarted,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
@@ skipping 2009 matching lines @@
   scoped_ptr<FakePictureLayerImpl> scoped_content_layer =
       FakePictureLayerImpl::CreateWithPile(host_impl_->pending_tree(), 3, pile);
   LayerImpl* content_layer = scoped_content_layer.get();
   scrolling_layer->AddChild(scoped_content_layer.PassAs<LayerImpl>());
   content_layer->SetBounds(content_layer_bounds);
   content_layer->SetDrawsContent(true);
 
   root->SetBounds(root_size);
 
   gfx::Vector2d scroll_offset(100000, 0);
-  scrolling_layer->SetScrollable(true);
-  scrolling_layer->SetMaxScrollOffset(scroll_offset);
+  scrolling_layer->SetScrollClipLayer(root->id());
   scrolling_layer->SetScrollOffset(scroll_offset);
 
   host_impl_->ActivatePendingTree();
 
   host_impl_->active_tree()->UpdateDrawProperties();
   ASSERT_EQ(1u, host_impl_->active_tree()->RenderSurfaceLayerList().size());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
 
@@ skipping 411 matching lines @@
   // released, and the texture deleted.
   EXPECT_TRUE(context_provider->HasOneRef());
   EXPECT_EQ(0u, context_provider->TestContext3d()->NumTextures());
 }
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldNotBubble) {
   // When flinging via touch, only the child should scroll (we should not
   // bubble).
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
-  scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, content_size);
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, content_size);
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scoped_ptr<LayerImpl> root =
+      CreateScrollableLayer(1, content_size, root_clip.get());
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, content_size, root_clip.get());
 
   root->AddChild(child.Pass());
+  int root_id = root->id();
+  root_clip->AddChild(root.Pass());
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
+  host_impl_->active_tree()->SetViewportLayersFromIds(3, 1, Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::Gesture));
 
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->FlingScrollBegin());
 
     gfx::Vector2d scroll_delta(0, 100);
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
 
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // Only the child should have scrolled.
     ASSERT_EQ(1u, scroll_info->scrolls.size());
-    ExpectNone(*scroll_info.get(),
-               host_impl_->active_tree()->root_layer()->id());
+    ExpectNone(*scroll_info.get(), root_id);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldLockToFirstScrolledLayer) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
-  scoped_ptr<LayerImpl> root_scrolling = CreateScrollableLayer(2, surface_size);
+  scoped_ptr<LayerImpl> root_scrolling =
+      CreateScrollableLayer(2, surface_size, root.get());
 
-  scoped_ptr<LayerImpl> grand_child = CreateScrollableLayer(4, surface_size);
+  scoped_ptr<LayerImpl> grand_child =
+      CreateScrollableLayer(4, surface_size, root.get());
   grand_child->SetScrollOffset(gfx::Vector2d(0, 2));
 
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(3, surface_size);
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(3, surface_size, root.get());
   child->SetScrollOffset(gfx::Vector2d(0, 4));
   child->AddChild(grand_child.Pass());
 
   root_scrolling->AddChild(child.Pass());
   root->AddChild(root_scrolling.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
@@ skipping 39 matching lines @@
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child);
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, WheelFlingShouldBubble) {
   // When flinging via wheel, the root should eventually scroll (we should
   // bubble).
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
-  scoped_ptr<LayerImpl> root = CreateScrollableLayer(1, content_size);
-  scoped_ptr<LayerImpl> child = CreateScrollableLayer(2, content_size);
+  scoped_ptr<LayerImpl> root_clip =
+      LayerImpl::Create(host_impl_->active_tree(), 3);
+  scoped_ptr<LayerImpl> root_scroll =
+      CreateScrollableLayer(1, content_size, root_clip.get());
+  int root_scroll_id = root_scroll->id();
+  scoped_ptr<LayerImpl> child =
+      CreateScrollableLayer(2, content_size, root_clip.get());
 
-  root->AddChild(child.Pass());
+  root_scroll->AddChild(child.Pass());
+  root_clip->AddChild(root_scroll.Pass());
 
   host_impl_->SetViewportSize(surface_size);
-  host_impl_->active_tree()->SetRootLayer(root.Pass());
+  host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::Wheel));
 
     EXPECT_EQ(InputHandler::ScrollStarted,
               host_impl_->FlingScrollBegin());
 
     gfx::Vector2d scroll_delta(0, 100);
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
     host_impl_->ScrollBy(gfx::Point(), scroll_delta);
 
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // The root should have scrolled.
     ASSERT_EQ(2u, scroll_info->scrolls.size());
-    ExpectContains(*scroll_info.get(),
-                   host_impl_->active_tree()->root_layer()->id(),
-                   gfx::Vector2d(0, 10));
+    ExpectContains(*scroll_info.get(), root_scroll_id, gfx::Vector2d(0, 10));
   }
 }
 
 // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed
 // to CompositorFrameMetadata after SwapBuffers();
 TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetAnchorPoint(gfx::PointF());
   root->SetPosition(gfx::PointF());
@@ skipping 97 matching lines @@
                                      &set_needs_redraw_count));
     // Empty damage rect won't signal the monitor.
     host_impl_->SetNeedsRedrawRect(gfx::Rect());
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
   }
 }
 
 }  // namespace
 }  // namespace cc