Implement pinch-zoom scaling for main-frame scrollbars and pinch-zoom overlay scrollbars.

cc/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/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 161 matching lines @@
         scoped_ptr<LayerImpl> contents = LayerImpl::create(m_hostImpl->activeTree(), 2);
         contents->setDrawsContent(true);
         contents->setBounds(contentSize);
         contents->setContentBounds(contentSize);
         contents->setPosition(gfx::PointF(0, 0));
         contents->setAnchorPoint(gfx::PointF(0, 0));
         root->addChild(contents.Pass());
         m_hostImpl->activeTree()->SetRootLayer(root.Pass());
     }
 
+    // Create a non-scrolling root and a scrollable child for tests that involve
+    // application of the implTransform().
+    void createRootWithScrollingChildLayer(const gfx::Size& contentSize)
+    {
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 1);
+        root->setBounds(contentSize);
+        root->setContentBounds(contentSize);
+        root->setPosition(gfx::PointF(0, 0));
+        root->setAnchorPoint(gfx::PointF(0, 0));
+
+        scoped_ptr<LayerImpl> child = LayerImpl::create(m_hostImpl->activeTree(), 2);
+        child->setScrollable(true);
+        child->setScrollOffset(gfx::Vector2d(0, 0));
+        child->setDrawsContent(true);
+        child->setBounds(contentSize);
+        child->setContentBounds(contentSize);
+        child->setPosition(gfx::PointF(0, 0));
+        child->setAnchorPoint(gfx::PointF(0, 0));
+        child->setMaxScrollOffset(gfx::Vector2d(contentSize.width() * 2, contentSize.height() * 2));
+        root->addChild(child.Pass());
+        m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+    }
+
     scoped_ptr<LayerImpl> createScrollableLayer(int id, const gfx::Size& size)
     {
         scoped_ptr<LayerImpl> layer = LayerImpl::create(m_hostImpl->activeTree(), id);
         layer->setScrollable(true);
         layer->setDrawsContent(true);
         layer->setBounds(size);
         layer->setContentBounds(size);
         layer->setMaxScrollOffset(gfx::Vector2d(size.width() * 2, size.height() * 2));
         return layer.Pass();
     }
@@ skipping 1157 matching lines @@
     EXPECT_EQ(0.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 0));
     EXPECT_EQ(0.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 1));
     EXPECT_EQ(0.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 2));
     EXPECT_EQ(1.0, m_hostImpl->rootLayer()->implTransform().matrix().getDouble(3, 3));
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
 {
     gfx::Size surfaceSize(10, 10);
     float pageScale = 2;
-    scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
-    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+
+    createRootWithScrollingChildLayer(surfaceSize);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
+    ASSERT_TRUE(m_hostImpl->rootLayer()->children().size() == 1);
+    LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
+
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
-    gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
+    gfx::Vector2d expectedMaxScroll(m_hostImpl->rootScrollLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
-    EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollOffset(), expectedMaxScroll);
+    EXPECT_EQ(m_hostImpl->rootScrollLayer()->maxScrollOffset(), expectedMaxScroll);
 
     // The page scale delta should match the new scale on the impl side.
     gfx::Transform expectedScale;
     expectedScale.Scale(pageScale, pageScale);
-    EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedScale);
+    // The impl transform is applied to the children of the root, which won't
+    // in general be the rootScrollLayer().
+    EXPECT_EQ(child->implTransform(), expectedScale);
 }
 
 TEST_P(LayerTreeHostImplTest, pageScaleDeltaAppliedToRootScrollLayerOnly)
 {
     gfx::Size surfaceSize(10, 10);
     float defaultPageScale = 1;
     gfx::Transform defaultPageScaleMatrix;
 
     float newPageScale = 2;
     gfx::Transform newPageScaleMatrix;
     newPageScaleMatrix.Scale(newPageScale, newPageScale);
 
     // Create a normal scrollable root layer and another scrollable child layer.
     setupScrollAndContentsLayers(surfaceSize);
     LayerImpl* root = m_hostImpl->rootLayer();
     LayerImpl* child = root->children()[0];
 
     scoped_ptr<LayerImpl> scrollableChild = createScrollableLayer(3, surfaceSize);
     child->addChild(scrollableChild.Pass());
     LayerImpl* grandChild = child->children()[0];
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(newPageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     // The page scale delta should only be applied to the scrollable root layer.
-    EXPECT_EQ(root->implTransform(), newPageScaleMatrix);
-    EXPECT_EQ(child->implTransform(), defaultPageScaleMatrix);
+    EXPECT_EQ(root->implTransform(), defaultPageScaleMatrix);
+    EXPECT_EQ(child->implTransform(), newPageScaleMatrix);
     EXPECT_EQ(grandChild->implTransform(), defaultPageScaleMatrix);
 
     // Make sure all the layers are drawn with the page scale delta applied, i.e., the page scale
     // delta on the root layer is applied hierarchically.
     LayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
-    EXPECT_EQ(root->drawTransform().matrix().getDouble(0, 0), newPageScale);
-    EXPECT_EQ(root->drawTransform().matrix().getDouble(1, 1), newPageScale);
+    // The page scale (via implTransform) is always applied below the root layer.
+    EXPECT_EQ(1, root->drawTransform().matrix().getDouble(0, 0));
+    EXPECT_EQ(1, root->drawTransform().matrix().getDouble(1, 1));
     EXPECT_EQ(child->drawTransform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(child->drawTransform().matrix().getDouble(1, 1), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().matrix().getDouble(0, 0), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().matrix().getDouble(1, 1), newPageScale);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 1);
@@ skipping 24 matching lines @@
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled) {
         // The scale should apply to the scroll delta.
         expectedScrollDelta = gfx::ToFlooredVector2d(gfx::ScaleVector2d(expectedScrollDelta, pageScale));
     }
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), scrollLayerId, expectedScrollDelta);
 
     // The scroll range should not have changed.
     EXPECT_EQ(child->maxScrollOffset(), expectedMaxScroll);
 
-    // The page scale delta remains constant because the impl thread did not scale.
-    gfx::Transform identityTransform;
-    EXPECT_EQ(child->implTransform(), gfx::Transform());
+    gfx::Transform scaleTransform;
+    if (m_hostImpl->settings().pageScalePinchZoomEnabled)
+        scaleTransform.Scale(pageScale, pageScale);
+    EXPECT_EQ(child->implTransform(), scaleTransform);
 }
 
 TEST_P(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 surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
 
@@ skipping 2525 matching lines @@
 // Make sure that scrolls that only pan the pinch viewport, and not the document,
 // still force redraw/commit.
 void LayerTreeHostImplTest::pinchZoomPanViewportForcesCommitRedraw(const float deviceScaleFactor)
 {
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
-    scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
+    createRootWithScrollingChildLayer(layoutSurfaceSize);
+    LayerImpl* root = m_hostImpl->rootLayer();
+    LayerImpl* child = root->children()[0];
     // For this test we want to force scrolls to only pan the pinchZoomViewport
     // and not the document, we can verify commit/redraw are requested.
-    root->setMaxScrollOffset(gfx::Vector2d());
-    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+    child->setMaxScrollOffset(gfx::Vector2d());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     gfx::Transform expectedImplTransform;
     expectedImplTransform.Scale(pageScale, pageScale);
 
     // Verify the pinch zoom took place.
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 
     // The implTransform ignores the scroll if !pageScalePinchZoomEnabled,
     // so no point in continuing without it.
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     m_didRequestCommit = false;
     m_didRequestRedraw = false;
 
     // This scroll will force the viewport to pan horizontally.
@@ skipping 32 matching lines @@
 // The device scale factor directly affects computation of the implTransform, so
 // we test the two most common use cases.
 void LayerTreeHostImplTest::pinchZoomPanViewportTest(const float deviceScaleFactor)
 {
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
-    scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
+    createRootWithScrollingChildLayer(layoutSurfaceSize);
+    LayerImpl* root = m_hostImpl->rootLayer();
+    LayerImpl* child = root->children()[0];
     // For this test we want to force scrolls to move the pinchZoomViewport so
     // we can see the scroll component on the implTransform.
-    root->setMaxScrollOffset(gfx::Vector2d());
-    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+    child->setMaxScrollOffset(gfx::Vector2d());
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     gfx::Transform expectedImplTransform;
     expectedImplTransform.Scale(pageScale, pageScale);
 
-    EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedImplTransform);
+    EXPECT_EQ(child->implTransform(), expectedImplTransform);
 
     // The implTransform ignores the scroll if !pageScalePinchZoomEnabled,
     // so no point in continuing without it.
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     gfx::Vector2d scrollDelta(5, 0);
     // TODO(wjmaclean): Fix the math here so that the expectedTranslation is
     // scaled instead of the scroll input.
     gfx::Vector2d scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     gfx::Vector2dF expectedTranslation = gfx::ScaleVector2d(scrollDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
     // No change expected.
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
     // None of the scroll delta should have been used for document scroll.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectNone(*scrollInfo.get(), m_hostImpl->rootLayer()->id());
 
     // Test scroll in y-direction also.
     scrollDelta = gfx::Vector2d(0, 5);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     expectedTranslation = gfx::ScaleVector2d(scrollDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
     // No change expected.
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
     // None of the scroll delta should have been used for document scroll.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectNone(*scrollInfo.get(), m_hostImpl->rootLayer()->id());
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportWithDeviceScaleFactor1)
 {
     pinchZoomPanViewportTest(1);
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportWithDeviceScaleFactor2)
 {
     pinchZoomPanViewportTest(2);
 }
 
 // This test verifies the correct behaviour of the document-then-pinchZoomViewport
 // scrolling model, in both x- and y-directions.
 void LayerTreeHostImplTest::pinchZoomPanViewportAndScrollTest(const float deviceScaleFactor)
 {
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
-    scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
+    createRootWithScrollingChildLayer(layoutSurfaceSize);
+    LayerImpl* root = m_hostImpl->rootLayer();
+    LayerImpl* child = root->children()[0];
     // For this test we want to scrolls to move both the document and the
     // pinchZoomViewport so we can see some scroll component on the implTransform.
-    root->setMaxScrollOffset(gfx::Vector2d(3, 4));
-    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+    child->setMaxScrollOffset(gfx::Vector2d(3, 4));
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     gfx::Transform expectedImplTransform;
     expectedImplTransform.Scale(pageScale, pageScale);
 
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 
     // The implTransform ignores the scroll if !pageScalePinchZoomEnabled,
     // so no point in continuing without it.
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     // Scroll document only: scrollDelta chosen to move document horizontally
     // to its max scroll offset.
     gfx::Vector2d scrollDelta(3, 0);
     gfx::Vector2d scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     // Verify we did not change the implTransform this time.
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 
     // Further scrolling should move the pinchZoomViewport only.
     scrollDelta = gfx::Vector2d(2, 0);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     gfx::Vector2d expectedPanDelta(scrollDelta);
     gfx::Vector2dF expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
-    EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedImplTransform);
+    EXPECT_EQ(child->implTransform(), expectedImplTransform);
 
     // The scroll delta on the main thread should not have been affected by this.
     scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     // Perform same test sequence in y-direction also.
     // Document only scroll.
     scrollDelta = gfx::Vector2d(0, 4);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     expectedScrollDelta += scrollDelta;
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     // Verify we did not change the implTransform this time.
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 
     // pinchZoomViewport scroll only.
     scrollDelta = gfx::Vector2d(0, 1);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     expectedPanDelta = scrollDelta;
     expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 
     // The scroll delta on the main thread should not have been affected by this.
     scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportAndScrollWithDeviceScaleFactor)
 {
     pinchZoomPanViewportAndScrollTest(1);
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportAndScrollWithDeviceScaleFactor2)
 {
     pinchZoomPanViewportAndScrollTest(2);
 }
 
 // This test verifies the correct behaviour of the document-then-pinchZoomViewport
 // scrolling model, in both x- and y-directions, but this time using a single scroll
 // that crosses the 'boundary' of what will cause document-only scroll and what will
 // cause both document-scroll and zoomViewport panning.
 void LayerTreeHostImplTest::pinchZoomPanViewportAndScrollBoundaryTest(const float deviceScaleFactor)
 {
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
 
     gfx::Size layoutSurfaceSize(10, 20);
     gfx::Size deviceSurfaceSize(layoutSurfaceSize.width() * static_cast<int>(deviceScaleFactor),
                                 layoutSurfaceSize.height() * static_cast<int>(deviceScaleFactor));
     float pageScale = 2;
-    scoped_ptr<LayerImpl> root = createScrollableLayer(1, layoutSurfaceSize);
+    createRootWithScrollingChildLayer(layoutSurfaceSize);
+    LayerImpl* root = m_hostImpl->rootLayer();
+    LayerImpl* child = root->children()[0];
     // For this test we want to scrolls to move both the document and the
     // pinchZoomViewport so we can see some scroll component on the implTransform.
-    root->setMaxScrollOffset(gfx::Vector2d(3, 4));
-    m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+    child->setMaxScrollOffset(gfx::Vector2d(3, 4));
     m_hostImpl->setViewportSize(layoutSurfaceSize, deviceSurfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     gfx::Transform expectedImplTransform;
     expectedImplTransform.Scale(pageScale, pageScale);
 
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 
     // The implTransform ignores the scroll if !pageScalePinchZoomEnabled,
     // so no point in continuing without it.
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     // Scroll document and pann zoomViewport in one scroll-delta.
     gfx::Vector2d scrollDelta(5, 0);
     gfx::Vector2d scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     gfx::Vector2d expectedScrollDelta(gfx::Vector2d(3, 0)); // This component gets handled by document scroll.
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
 
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     gfx::Vector2d expectedPanDelta(2, 0); // This component gets handled by zoomViewport pan.
     gfx::Vector2dF expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
-    EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedImplTransform);
+    EXPECT_EQ(child->implTransform(), expectedImplTransform);
 
     // Perform same test sequence in y-direction also.
     scrollDelta = gfx::Vector2d(0, 5);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     expectedScrollDelta += gfx::Vector2d(0, 4); // This component gets handled by document scroll.
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
     m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scrollInfo = m_hostImpl->processScrollDeltas(); // This component gets handled by zoomViewport pan.
-    expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+    expectContains(*scrollInfo.get(), m_hostImpl->rootScrollLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     expectedPanDelta = gfx::Vector2d(0, 1);
     expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
-    EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
+    EXPECT_EQ(expectedImplTransform, child->implTransform());
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportAndScrollBoundaryWithDeviceScaleFactor)
 {
     pinchZoomPanViewportAndScrollBoundaryTest(1);
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportAndScrollBoundaryWithDeviceScaleFactor2)
 {
     pinchZoomPanViewportAndScrollBoundaryTest(2);
@@ skipping 37 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc