Chromium compositor change implementing page-scale driven pinch-zoom.

cc/CCLayerTreeHostImplTest.cpp

 // 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 "config.h"
 
 #include "CCLayerTreeHostImpl.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCDelegatedRendererLayerImpl.h"
@@ skipping 32 matching lines @@
 using namespace WebKitTests;
 
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::_;
 
 namespace {
 
-class CCLayerTreeHostImplTest : public testing::Test, public CCLayerTreeHostImplClient {
+class CCLayerTreeHostImplTest : public testing::TestWithParam<bool>,
+                                /*                                public ::testing::WithParamInterface<bool>,*/

[jamesr, 2012/10/03 19:48:57]

hm, what's this? leftovers?

[Jeff Timanus, 2012/10/03 20:56:04]

Yes.  Old cruft.  Removed.

+                                public CCLayerTreeHostImplClient {
 public:
     CCLayerTreeHostImplTest()
         : m_onCanDrawStateChangedCalled(false)
         , m_didRequestCommit(false)
         , m_didRequestRedraw(false)
     {
+    }
+
+    virtual void SetUp()
+    {
+
+        CCSettings::setPageScalePinchZoomEnabled(GetParam());
         CCLayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = IntSize();
 
         m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
         m_hostImpl->initializeRenderer(createContext());
         m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
     }
 
+    virtual void TearDown()
+    {
+        CCSettings::reset();
+    }
+
     virtual void didLoseContextOnImplThread() OVERRIDE { }
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
     virtual void onVSyncParametersChanged(double, double) OVERRIDE { }
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
     virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE { }
     virtual void releaseContentsTexturesOnImplThread() OVERRIDE { }
 
     PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, PassOwnPtr<CCGraphicsContext> graphicsContext, PassOwnPtr<CCLayerImpl> rootPtr)
@@ skipping 97 matching lines @@
     bool m_didRequestCommit;
     bool m_didRequestRedraw;
     CCScopedSettings m_scopedSettings;
 };
 
 class FakeWebGraphicsContext3DMakeCurrentFails : public FakeWebGraphicsContext3D {
 public:
     virtual bool makeContextCurrent() { return false; }
 };
 
-TEST_F(CCLayerTreeHostImplTest, notifyIfCanDrawChanged)
+TEST_P(CCLayerTreeHostImplTest, notifyIfCanDrawChanged)
 {
     // Note: It is not possible to disable the renderer once it has been set,
     // so we do not need to test that disabling the renderer notifies us
     // that canDraw changed.
     EXPECT_FALSE(m_hostImpl->canDraw());
     m_onCanDrawStateChangedCalled = false;
 
     setupScrollAndContentsLayers(IntSize(100, 100));
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
@@ skipping 26 matching lines @@
     EXPECT_FALSE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 
     m_hostImpl->resetContentsTexturesPurged();
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollDeltaNoLayers)
+TEST_P(CCLayerTreeHostImplTest, scrollDeltaNoLayers)
 {
     ASSERT_FALSE(m_hostImpl->rootLayer());
 
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
+TEST_P(CCLayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
 {
     {
         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->addChild(CCLayerImpl::create(2));
         root->addChild(CCLayerImpl::create(3));
         root->children()[1]->addChild(CCLayerImpl::create(4));
         root->children()[1]->addChild(CCLayerImpl::create(5));
         root->children()[1]->children()[0]->addChild(CCLayerImpl::create(6));
         m_hostImpl->setRootLayer(root.release());
     }
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     expectClearedScrollDeltasRecursive(root);
 
     OwnPtr<CCScrollAndScaleSet> scrollInfo;
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
+TEST_P(CCLayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
 {
     IntPoint scrollPosition(20, 30);
     IntSize scrollDelta(11, -15);
     {
         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setScrollPosition(scrollPosition);
         root->setScrollable(true);
         root->setMaxScrollPosition(IntSize(100, 100));
         root->scrollBy(scrollDelta);
         m_hostImpl->setRootLayer(root.release());
@@ skipping 12 matching lines @@
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
     expectContains(*scrollInfo, root->id(), scrollDelta + scrollDelta2);
 
     root->scrollBy(IntSize());
     scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
+TEST_P(CCLayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollWithoutRootLayer)
+TEST_P(CCLayerTreeHostImplTest, scrollWithoutRootLayer)
 {
     // We should not crash when trying to scroll an empty layer tree.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollWithoutRenderer)
+TEST_P(CCLayerTreeHostImplTest, scrollWithoutRenderer)
 {
     CCLayerTreeSettings settings;
     m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Initialization will fail here.
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFails)));
     m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
 
     setupScrollAndContentsLayers(IntSize(100, 100));
 
     // We should not crash when trying to scroll after the renderer initialization fails.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
 }
 
-TEST_F(CCLayerTreeHostImplTest, replaceTreeWhileScrolling)
+TEST_P(CCLayerTreeHostImplTest, replaceTreeWhileScrolling)
 {
     const int scrollLayerId = 1;
 
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     // We should not crash if the tree is replaced while we are scrolling.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->detachLayerTree();
 
     setupScrollAndContentsLayers(IntSize(100, 100));
 
     // We should still be scrolling, because the scrolled layer also exists in the new tree.
     IntSize scrollDelta(0, 10);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo, scrollLayerId, scrollDelta);
 }
 
-TEST_F(CCLayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
+TEST_P(CCLayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     // We should be able to scroll even if the root layer loses its render surface after the most
     // recent render.
     m_hostImpl->rootLayer()->clearRenderSurface();
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
 }
 
-TEST_F(CCLayerTreeHostImplTest, wheelEventHandlers)
+TEST_P(CCLayerTreeHostImplTest, wheelEventHandlers)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     root->setHaveWheelEventHandlers(true);
 
     // With registered event handlers, wheel scrolls have to go to the main thread.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollOnMainThread);
 
     // But gesture scrolls can still be handled.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted);
 }
 
-TEST_F(CCLayerTreeHostImplTest, shouldScrollOnMainThread)
+TEST_P(CCLayerTreeHostImplTest, shouldScrollOnMainThread)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     root->setShouldScrollOnMainThread(true);
 
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollOnMainThread);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollOnMainThread);
 }
 
-TEST_F(CCLayerTreeHostImplTest, nonFastScrollableRegionBasic)
+TEST_P(CCLayerTreeHostImplTest, nonFastScrollableRegionBasic)
 {
     setupScrollAndContentsLayers(IntSize(200, 200));
     m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
     initializeRendererAndDrawFrame();
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
 
     // All scroll types inside the non-fast scrollable region should fail.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollOnMainThread);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollOnMainThread);
 
     // All scroll types outside this region should succeed.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(75, 75), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(75, 75), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
 }
 
-TEST_F(CCLayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
+TEST_P(CCLayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
 {
     setupScrollAndContentsLayers(IntSize(200, 200));
     m_hostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     root->setNonFastScrollableRegion(IntRect(0, 0, 50, 50));
     root->setPosition(FloatPoint(-25, 0));
     initializeRendererAndDrawFrame();
 
     // This point would fall into the non-fast scrollable region except that we've moved the layer down by 25 pixels.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(40, 10), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 1));
     m_hostImpl->scrollEnd();
 
     // This point is still inside the non-fast region.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(10, 10), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollOnMainThread);
 }
 
-TEST_F(CCLayerTreeHostImplTest, maxScrollPositionChangedByDeviceScaleFactor)
+TEST_P(CCLayerTreeHostImplTest, maxScrollPositionChangedByDeviceScaleFactor)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
 
     float deviceScaleFactor = 2;
     IntSize layoutViewport(25, 25);
     IntSize deviceViewport(layoutViewport);
     deviceViewport.scale(deviceScaleFactor);
     m_hostImpl->setViewportSize(layoutViewport, deviceViewport);
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(25, 25));
 
     deviceScaleFactor = 1;
     m_hostImpl->setViewportSize(layoutViewport, layoutViewport);
     m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(75, 75));
 }
 
-TEST_F(CCLayerTreeHostImplTest, pinchGesture)
+TEST_P(CCLayerTreeHostImplTest, implPinchZoom)
 {
+    // This test is specific to the page-scale based pinch zoom.
+    if (!CCSettings::pageScalePinchZoomEnabled())

[jamesr, 2012/10/03 19:48:57]

not sure I grok this with line 474 - it looks like it's testing if the setting
is false and returning if so, then setting the value to true. hm?

[Jeff Timanus, 2012/10/03 20:56:04]

This is a good catch.  Previous patches (before I added the parametrization)
assigned the setting explicitly.  I can remove the explicit assignment of the
state.  However, the early out is still required, because these new tests are
only relevant in the new-pinch-world. 

+        return;
+
+    CCSettings::setPageScalePinchZoomEnabled(true);
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     ASSERT(scrollLayer);
 
-    const float minPageScale = 0.5, maxPageScale = 4;
+    const float minPageScale = 1, maxPageScale = 4;
+    const WebTransformationMatrix identityScaleTransform;
+
+    // The impl-based pinch zoome should not adjust the max scroll position.
+    {
+        m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+        scrollLayer->setImplTransform(identityScaleTransform);
+        scrollLayer->setScrollDelta(IntSize());
+
+        float pageScaleDelta = 2;
+        m_hostImpl->pinchGestureBegin();
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
+        m_hostImpl->pinchGestureEnd();
+        EXPECT_TRUE(m_didRequestRedraw);
+        EXPECT_TRUE(m_didRequestCommit);
+
+        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
+
+        EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(50, 50));
+    }
+
+    // Scrolling after a pinch gesture should always be in local space.  The scroll deltas do not
+    // have the page scale factor applied.
+    {
+        m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+        scrollLayer->setImplTransform(identityScaleTransform);
+        scrollLayer->setScrollDelta(IntSize());
+
+        float pageScaleDelta = 2;
+        m_hostImpl->pinchGestureBegin();
+        m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(0, 0));
+        m_hostImpl->pinchGestureEnd();
+
+        IntSize scrollDelta(0, 10);
+        EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
+        m_hostImpl->scrollBy(IntPoint(), scrollDelta);
+        m_hostImpl->scrollEnd();
+
+        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
+    }
+}
+
+TEST_P(CCLayerTreeHostImplTest, pinchGesture)
+{
+    setupScrollAndContentsLayers(IntSize(100, 100));
+    m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
+    initializeRendererAndDrawFrame();
+
+    CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
+    ASSERT(scrollLayer);
+
+    const float minPageScale = CCSettings::pageScalePinchZoomEnabled() ? 1 : 0.5;
+    const float maxPageScale = 4;
+    const WebTransformationMatrix identityScaleTransform;
 
     // Basic pinch zoom in gesture
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-        scrollLayer->setPageScaleDelta(1);
+        scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
         m_hostImpl->pinchGestureEnd();
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
     }
 
     // Zoom-in clamping
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-        scrollLayer->setPageScaleDelta(1);
+        scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
         float pageScaleDelta = 10;
 
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
         m_hostImpl->pinchGestureEnd();
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, maxPageScale);
     }
 
     // Zoom-out clamping
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-        scrollLayer->setPageScaleDelta(1);
+        scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
         scrollLayer->setScrollPosition(IntPoint(50, 50));
 
         float pageScaleDelta = 0.1f;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(0, 0));
         m_hostImpl->pinchGestureEnd();
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
 
-        // Pushed to (0,0) via clamping against contents layer size.
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
+        if (!CCSettings::pageScalePinchZoomEnabled()) {
+            // Pushed to (0,0) via clamping against contents layer size.
+            expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
+        } else {
+            EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
+        }
     }
 
     // Two-finger panning
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-        scrollLayer->setPageScaleDelta(1);
+        scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
         scrollLayer->setScrollPosition(IntPoint(20, 20));
 
         float pageScaleDelta = 1;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(10, 10));
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(20, 20));
         m_hostImpl->pinchGestureEnd();
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-10, -10));
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, pageScaleAnimation)
+TEST_P(CCLayerTreeHostImplTest, pageScaleAnimation)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     ASSERT(scrollLayer);
 
-    const float minPageScale = 0.5, maxPageScale = 4;
+    const float minPageScale = CCSettings::pageScalePinchZoomEnabled() ? 1 : 0.5;
+    const float maxPageScale = 4;
     const double startTime = 1;
     const double duration = 0.1;
     const double halfwayThroughAnimation = startTime + duration / 2;
     const double endTime = startTime + duration;
+    const WebTransformationMatrix identityScaleTransform;
 
     // Non-anchor zoom-in
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-        scrollLayer->setPageScaleDelta(1);
+        scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollPosition(IntPoint(50, 50));
 
         m_hostImpl->startPageScaleAnimation(IntSize(0, 0), false, 2, startTime, duration);
         m_hostImpl->animate(halfwayThroughAnimation, halfwayThroughAnimation);
         EXPECT_TRUE(m_didRequestRedraw);
         m_hostImpl->animate(endTime, endTime);
         EXPECT_TRUE(m_didRequestCommit);
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, 2);
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
     }
 
     // Anchor zoom-out
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
-        scrollLayer->setPageScaleDelta(1);
+        scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollPosition(IntPoint(50, 50));
 
         m_hostImpl->startPageScaleAnimation(IntSize(25, 25), true, minPageScale, startTime, duration);
         m_hostImpl->animate(endTime, endTime);
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
         // Pushed to (0,0) via clamping against contents layer size.
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
+TEST_P(CCLayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     ASSERT(scrollLayer);
 
-    const float minPageScale = 0.5, maxPageScale = 4;
+    const float minPageScale = CCSettings::pageScalePinchZoomEnabled() ? 1 : 0.5;
+    const float maxPageScale = 4;
 
     // Pinch zoom in.
     {
         // Start a pinch in gesture at the bottom right corner of the viewport.
         const float zoomInDelta = 2;
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(zoomInDelta, IntPoint(50, 50));
 
         // Because we are pinch zooming in, we shouldn't get any scroll or page
         // scale deltas.
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
         EXPECT_EQ(scrollInfo->scrolls.size(), 0u);
 
         // Once the gesture ends, we get the final scroll and page scale values.
         m_hostImpl->pinchGestureEnd();
         scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, zoomInDelta);
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+        if (!CCSettings::pageScalePinchZoomEnabled()) {
+            expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+        } else {
+            EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
+        }
     }
 
     // Pinch zoom out.
     {
         // Start a pinch out gesture at the bottom right corner of the viewport.
         const float zoomOutDelta = 0.75;
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(zoomOutDelta, IntPoint(50, 50));
 
         // Since we are pinch zooming out, we should get an update to zoom all
         // the way out to the minimum page scale.
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-        EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(0, 0));
+        if (!CCSettings::pageScalePinchZoomEnabled()) {
+            EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
+            expectContains(*scrollInfo, scrollLayer->id(), IntSize(0, 0));
+        } else {
+            EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
+            EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
+        }
 
         // Once the gesture ends, we get the final scroll and page scale values.
         m_hostImpl->pinchGestureEnd();
         scrollInfo = m_hostImpl->processScrollDeltas();
-        EXPECT_EQ(scrollInfo->pageScaleDelta, zoomOutDelta);
-        expectContains(*scrollInfo, scrollLayer->id(), IntSize(8, 8));
+        if (CCSettings::pageScalePinchZoomEnabled()) {
+            EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
+            expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+        } else {
+            EXPECT_EQ(scrollInfo->pageScaleDelta, zoomOutDelta);
+            expectContains(*scrollInfo, scrollLayer->id(), IntSize(8, 8));
+        }
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPageScale)
+TEST_P(CCLayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhileAnimatingPageScale)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     ASSERT(scrollLayer);
 
-    const float minPageScale = 0.5, maxPageScale = 4;
+    const float minPageScale = CCSettings::pageScalePinchZoomEnabled() ? 1 : 0.5;
+    const float maxPageScale = 4;
     const double startTime = 1;
     const double duration = 0.1;
     const double halfwayThroughAnimation = startTime + duration / 2;
     const double endTime = startTime + duration;
 
     // Start a page scale animation.
     const float pageScaleDelta = 2;
     m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
     m_hostImpl->startPageScaleAnimation(IntSize(50, 50), false, pageScaleDelta, startTime, duration);
 
     // We should immediately get the final zoom and scroll values for the
     // animation.
     m_hostImpl->animate(halfwayThroughAnimation, halfwayThroughAnimation);
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
-    EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
-    expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+
+    if (!CCSettings::pageScalePinchZoomEnabled()) {
+        EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
+        expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
+    } else {
+        EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
+        EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
+    }
 
     // Scrolling during the animation is ignored.
     const IntSize scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(25, 25), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // The final page scale and scroll deltas should match what we got
     // earlier.
     m_hostImpl->animate(endTime, endTime);
@@ skipping 41 matching lines @@
         OwnPtr<CCLayerTilingData> tiler = CCLayerTilingData::create(IntSize(100, 100), CCLayerTilingData::HasBorderTexels);
         tiler->setBounds(contentBounds());
         setTilingData(*tiler.get());
     }
 
 private:
     bool m_didDrawCalled;
     bool m_willDrawCalled;
 };
 
-TEST_F(CCLayerTreeHostImplTest, didDrawNotCalledOnHiddenLayer)
+TEST_P(CCLayerTreeHostImplTest, didDrawNotCalledOnHiddenLayer)
 {
     // The root layer is always drawn, so run this test on a child layer that
     // will be masked out by the root layer's bounds.
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->setMasksToBounds(true);
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
     // Ensure visibleContentRect for layer is empty
@@ skipping 24 matching lines @@
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_TRUE(layer->willDrawCalled());
     EXPECT_TRUE(layer->didDrawCalled());
 
     EXPECT_FALSE(layer->visibleContentRect().isEmpty());
 }
 
-TEST_F(CCLayerTreeHostImplTest, willDrawNotCalledOnOccludedLayer)
+TEST_P(CCLayerTreeHostImplTest, willDrawNotCalledOnOccludedLayer)
 {
     IntSize bigSize(1000, 1000);
     m_hostImpl->setViewportSize(bigSize, bigSize);
 
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
@@ skipping 14 matching lines @@
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_FALSE(occludedLayer->willDrawCalled());
     EXPECT_FALSE(occludedLayer->didDrawCalled());
     EXPECT_TRUE(topLayer->willDrawCalled());
     EXPECT_TRUE(topLayer->didDrawCalled());
 }
 
-TEST_F(CCLayerTreeHostImplTest, didDrawCalledOnAllLayers)
+TEST_P(CCLayerTreeHostImplTest, didDrawCalledOnAllLayers)
 {
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
     layer1->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
@@ skipping 31 matching lines @@
         setSkipsDraw(skipsDraw);
         if (!tileMissing) {
             CCResourceProvider::ResourceId resource = resourceProvider->createResource(CCRenderer::ContentPool, IntSize(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny);
             pushTileProperties(0, 0, resource, IntRect());
         }
         if (animating)
             addAnimatedTransformToLayer(*this, 10, 3, 0);
     }
 };
 
-TEST_F(CCLayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
+TEST_P(CCLayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
 {
     // When the texture is not missing, we draw as usual.
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(2, false, false, true, m_hostImpl->resourceProvider()));
 
     CCLayerTreeHostImpl::FrameData frame;
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
@@ skipping 20 matching lines @@
     // When the layer skips draw and we're animating, we still draw the frame.
     m_hostImpl->setRootLayer(DidDrawCheckLayer::create(1));
     root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
     root->addChild(MissingTextureAnimatingLayer::create(2, false, true, true, m_hostImpl->resourceProvider()));
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollRootIgnored)
+TEST_P(CCLayerTreeHostImplTest, scrollRootIgnored)
 {
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     root->setScrollable(false);
     m_hostImpl->setRootLayer(root.release());
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because layer is not scrollable.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollNonCompositedRoot)
+TEST_P(CCLayerTreeHostImplTest, scrollNonCompositedRoot)
 {
     // Test the configuration where a non-composited root layer is embedded in a
     // scrollable outer layer.
     IntSize surfaceSize(10, 10);
 
     OwnPtr<CCLayerImpl> contentLayer = CCLayerImpl::create(1);
     contentLayer->setUseLCDText(true);
     contentLayer->setDrawsContent(true);
     contentLayer->setPosition(FloatPoint(0, 0));
     contentLayer->setAnchorPoint(FloatPoint(0, 0));
@@ skipping 13 matching lines @@
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
+TEST_P(CCLayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
 {
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), IntSize(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollMissesChild)
+TEST_P(CCLayerTreeHostImplTest, scrollMissesChild)
 {
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because the input coordinate is outside the layer boundaries.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(15, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollMissesBackfacingChild)
+TEST_P(CCLayerTreeHostImplTest, scrollMissesBackfacingChild)
 {
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     OwnPtr<CCLayerImpl> child = createScrollableLayer(2, surfaceSize);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
 
     WebTransformationMatrix matrix;
     matrix.rotate3d(180, 0, 0);
     child->setTransform(matrix);
     child->setDoubleSided(false);
 
     root->addChild(child.release());
     m_hostImpl->setRootLayer(root.release());
     initializeRendererAndDrawFrame();
 
     // Scroll event is ignored because the scrollable layer is not facing the viewer and there is
     // nothing scrollable behind it.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollIgnored);
     EXPECT_FALSE(m_didRequestRedraw);
     EXPECT_FALSE(m_didRequestCommit);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollBlockedByContentLayer)
+TEST_P(CCLayerTreeHostImplTest, scrollBlockedByContentLayer)
 {
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> contentLayer = createScrollableLayer(1, surfaceSize);
     contentLayer->setShouldScrollOnMainThread(true);
     contentLayer->setScrollable(false);
 
     OwnPtr<CCLayerImpl> scrollLayer = createScrollableLayer(2, surfaceSize);
     scrollLayer->addChild(contentLayer.release());
 
     m_hostImpl->setRootLayer(scrollLayer.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scrolling fails because the content layer is asking to be scrolled on the main thread.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollOnMainThread);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
+TEST_P(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
 {
     IntSize surfaceSize(10, 10);
     float pageScale = 2;
     OwnPtr<CCLayerImpl> root = createScrollableLayer(1, surfaceSize);
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     IntSize scrollDelta(0, 10);
     IntSize expectedScrollDelta(scrollDelta);
     IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale from main thread.
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
 
-    // The scale should apply to the scroll delta.
-    expectedScrollDelta.scale(pageScale);
+    if (!CCSettings::pageScalePinchZoomEnabled()) {
+        // The scale should apply to the scroll delta.
+        expectedScrollDelta.scale(pageScale);
+    }
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
 
     // The page scale delta remains constant because the impl thread did not scale.
-    EXPECT_EQ(m_hostImpl->rootLayer()->pageScaleDelta(), 1);
+    EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), WebTransformationMatrix());
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
+TEST_P(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
 {
     IntSize surfaceSize(10, 10);
     float pageScale = 2;
     OwnPtr<CCLayerImpl> root = createScrollableLayer(1, surfaceSize);
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     IntSize scrollDelta(0, 10);
     IntSize expectedScrollDelta(scrollDelta);
     IntSize expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollPosition());
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, IntPoint());
     m_hostImpl->pinchGestureEnd();
+    m_hostImpl->updateRootScrollLayerImplTransform();
 
     // The scroll delta is not scaled because the main thread did not scale.
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
 
     // The page scale delta should match the new scale on the impl side.
-    EXPECT_EQ(m_hostImpl->rootLayer()->pageScaleDelta(), pageScale);
+    WebTransformationMatrix expectedScale;
+    expectedScale.scale(pageScale);
+    EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedScale);
 }
 
-TEST_F(CCLayerTreeHostImplTest, pageScaleDeltaAppliedToRootScrollLayerOnly)
+TEST_P(CCLayerTreeHostImplTest, pageScaleDeltaAppliedToRootScrollLayerOnly)
 {
     IntSize surfaceSize(10, 10);
     float defaultPageScale = 1;
+    WebTransformationMatrix defaultPageScaleMatrix;
+
     float newPageScale = 2;
+    WebTransformationMatrix newPageScaleMatrix;
+    newPageScaleMatrix.scale(newPageScale);
 
     // Create a normal scrollable root layer and another scrollable child layer.
     setupScrollAndContentsLayers(surfaceSize);
     CCLayerImpl* root = m_hostImpl->rootLayer();
     CCLayerImpl* child = root->children()[0];
 
     OwnPtr<CCLayerImpl> scrollableChild = createScrollableLayer(3, surfaceSize);
     child->addChild(scrollableChild.release());
     CCLayerImpl* grandChild = child->children()[0];
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(newPageScale, IntPoint());
     m_hostImpl->pinchGestureEnd();
+    m_hostImpl->updateRootScrollLayerImplTransform();
 
     // The page scale delta should only be applied to the scrollable root layer.
-    EXPECT_EQ(root->pageScaleDelta(), newPageScale);
-    EXPECT_EQ(child->pageScaleDelta(), defaultPageScale);
-    EXPECT_EQ(grandChild->pageScaleDelta(), defaultPageScale);
+    EXPECT_EQ(root->implTransform(), newPageScaleMatrix);
+    EXPECT_EQ(child->implTransform(), defaultPageScaleMatrix);
+    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.
     CCLayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     m_hostImpl->didDrawAllLayers(frame);
 
     EXPECT_EQ(root->drawTransform().m11(), newPageScale);
     EXPECT_EQ(root->drawTransform().m22(), newPageScale);
     EXPECT_EQ(child->drawTransform().m11(), newPageScale);
     EXPECT_EQ(child->drawTransform().m22(), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().m11(), newPageScale);
     EXPECT_EQ(grandChild->drawTransform().m22(), newPageScale);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
+TEST_P(CCLayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
 {
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     // Also mark the root scrollable so it becomes the root scroll layer.
     root->setScrollable(true);
     int scrollLayerId = 2;
     root->addChild(createScrollableLayer(scrollLayerId, surfaceSize));
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0];
 
     IntSize scrollDelta(0, 10);
     IntSize expectedScrollDelta(scrollDelta);
     IntSize expectedMaxScroll(child->maxScrollPosition());
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     float pageScale = 2;
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
 
-    // The scale should apply to the scroll delta.
-    expectedScrollDelta.scale(pageScale);
+    m_hostImpl->updateRootScrollLayerImplTransform();
+
+    if (!CCSettings::pageScalePinchZoomEnabled()) {
+        // The scale should apply to the scroll delta.
+        expectedScrollDelta.scale(pageScale);
+    }
     OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), scrollLayerId, expectedScrollDelta);
 
     // The scroll range should not have changed.
     EXPECT_EQ(child->maxScrollPosition(), expectedMaxScroll);
 
     // The page scale delta remains constant because the impl thread did not scale.
-    EXPECT_EQ(child->pageScaleDelta(), 1);
+    WebTransformationMatrix identityTransform;
+    EXPECT_EQ(child->implTransform(), WebTransformationMatrix());
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollChildBeyondLimit)
+TEST_P(CCLayerTreeHostImplTest, 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.
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> root = createScrollableLayer(1, surfaceSize);
 
     OwnPtr<CCLayerImpl> grandChild = createScrollableLayer(3, surfaceSize);
     grandChild->setScrollPosition(IntPoint(0, 5));
 
@@ skipping 16 matching lines @@
         // The grand child should have scrolled up to its limit.
         CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0];
         CCLayerImpl* grandChild = child->children()[0];
         expectContains(*scrollInfo.get(), grandChild->id(), IntSize(0, -5));
 
         // The child should have only scrolled on the other axis.
         expectContains(*scrollInfo.get(), child->id(), IntSize(-3, 0));
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollEventBubbling)
+TEST_P(CCLayerTreeHostImplTest, scrollEventBubbling)
 {
     // When we try to scroll a non-scrollable child layer, the scroll delta
     // should be applied to one of its ancestors if possible.
     IntSize surfaceSize(10, 10);
     OwnPtr<CCLayerImpl> root = createScrollableLayer(1, surfaceSize);
     OwnPtr<CCLayerImpl> child = createScrollableLayer(2, surfaceSize);
 
     child->setScrollable(false);
     root->addChild(child.release());
 
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         IntSize scrollDelta(0, 4);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // Only the root should have scrolled.
         ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollBeforeRedraw)
+TEST_P(CCLayerTreeHostImplTest, scrollBeforeRedraw)
 {
     IntSize surfaceSize(10, 10);
     m_hostImpl->setRootLayer(createScrollableLayer(1, surfaceSize));
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
 
     // Draw one frame and then immediately rebuild the layer tree to mimic a tree synchronization.
     initializeRendererAndDrawFrame();
     m_hostImpl->detachLayerTree();
     m_hostImpl->setRootLayer(createScrollableLayer(2, surfaceSize));
 
     // Scrolling should still work even though we did not draw yet.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollAxisAlignedRotatedLayer)
+TEST_P(CCLayerTreeHostImplTest, scrollAxisAlignedRotatedLayer)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
 
     // Rotate the root layer 90 degrees counter-clockwise about its center.
     WebTransformationMatrix rotateTransform;
     rotateTransform.rotate(-90);
     m_hostImpl->rootLayer()->setTransform(rotateTransform);
 
     IntSize surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
@@ skipping 14 matching lines @@
     IntSize wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
+TEST_P(CCLayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     int childLayerId = 3;
     float childLayerAngle = -20;
 
     // Create a child layer that is rotated to a non-axis-aligned angle.
     OwnPtr<CCLayerImpl> child = createScrollableLayer(childLayerId, m_hostImpl->rootLayer()->contentBounds());
     WebTransformationMatrix rotateTransform;
     rotateTransform.translate(-50, -50);
     rotateTransform.rotate(childLayerAngle);
@@ skipping 40 matching lines @@
         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
 
         // The root layer should have scrolled more, since the input scroll delta was mostly
         // orthogonal to the child layer's vertical scroll axis.
         IntSize expectedRootScrollDelta(gestureScrollDelta.width() * pow(cosf(deg2rad(childLayerAngle)), 2), 0);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedRootScrollDelta);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, scrollScaledLayer)
+TEST_P(CCLayerTreeHostImplTest, scrollScaledLayer)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
 
     // Scale the layer to twice its normal size.
     int scale = 2;
     WebTransformationMatrix scaleTransform;
     scaleTransform.scale(scale);
     m_hostImpl->rootLayer()->setTransform(scaleTransform);
 
     IntSize surfaceSize(50, 50);
@@ skipping 100 matching lines @@
     bool m_blend;
     bool m_hasRenderSurface;
     bool m_quadsAppended;
     bool m_opaqueContents;
     IntRect m_quadRect;
     IntRect m_opaqueContentRect;
     IntRect m_quadVisibleRect;
     CCResourceProvider::ResourceId m_resourceId;
 };
 
-TEST_F(CCLayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
+TEST_P(CCLayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
 {
     {
         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setAnchorPoint(FloatPoint(0, 0));
         root->setBounds(IntSize(10, 10));
         root->setContentBounds(root->bounds());
         root->setDrawsContent(false);
         m_hostImpl->setRootLayer(root.release());
     }
     CCLayerImpl* root = m_hostImpl->rootLayer();
@@ skipping 197 matching lines @@
     layer1->setOpaqueContents(false);
     layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
 }
 
-TEST_F(CCLayerTreeHostImplTest, viewportCovered)
+TEST_P(CCLayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->initializeRenderer(createContext());
     m_hostImpl->setBackgroundColor(SK_ColorGRAY);
 
     IntSize viewportSize(1000, 1000);
     m_hostImpl->setViewportSize(viewportSize, viewportSize);
 
     m_hostImpl->setRootLayer(BlendStateCheckLayer::create(1, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* root = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer());
     root->setExpectation(false, true);
@@ skipping 88 matching lines @@
 };
 
 class FakeDrawableCCLayerImpl: public CCLayerImpl {
 public:
     explicit FakeDrawableCCLayerImpl(int id) : CCLayerImpl(id) { }
 };
 
 // Only reshape when we know we are going to draw. Otherwise, the reshape
 // can leave the window at the wrong size if we never draw and the proper
 // viewport size is never set.
-TEST_F(CCLayerTreeHostImplTest, reshapeNotCalledUntilDraw)
+TEST_P(CCLayerTreeHostImplTest, reshapeNotCalledUntilDraw)
 {
     OwnPtr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new ReshapeTrackerContext));
     ReshapeTrackerContext* reshapeTracker = static_cast<ReshapeTrackerContext*>(ccContext->context3D());
     m_hostImpl->initializeRenderer(ccContext.release());
 
     CCLayerImpl* root = new FakeDrawableCCLayerImpl(1);
     root->setAnchorPoint(FloatPoint(0, 0));
     root->setBounds(IntSize(10, 10));
     root->setDrawsContent(true);
     m_hostImpl->setRootLayer(adoptPtr(root));
@@ skipping 22 matching lines @@
     }
 
     IntRect partialSwapRect() const { return m_partialSwapRect; }
 
 private:
     IntRect m_partialSwapRect;
 };
 
 // Make sure damage tracking propagates all the way to the graphics context,
 // where it should request to swap only the subBuffer that is damaged.
-TEST_F(CCLayerTreeHostImplTest, partialSwapReceivesDamageRect)
+TEST_P(CCLayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
     OwnPtr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapTrackerContext));
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(ccContext->context3D());
 
     // This test creates its own CCLayerTreeHostImpl, so
     // that we can force partial swap enabled.
     CCLayerTreeSettings settings;
     CCSettings::setPartialSwapEnabled(true);
     OwnPtr<CCLayerTreeHostImpl> layerTreeHostImpl = CCLayerTreeHostImpl::create(settings, this);
     layerTreeHostImpl->initializeRenderer(ccContext.release());
@@ skipping 53 matching lines @@
     m_hostImpl->didDrawAllLayers(frame);
     layerTreeHostImpl->swapBuffers();
     actualSwapRect = partialSwapTracker->partialSwapRect();
     expectedSwapRect = IntRect(IntPoint::zero(), IntSize(10, 10));
     EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
     EXPECT_EQ(expectedSwapRect.y(), actualSwapRect.y());
     EXPECT_EQ(expectedSwapRect.width(), actualSwapRect.width());
     EXPECT_EQ(expectedSwapRect.height(), actualSwapRect.height());
 }
 
-TEST_F(CCLayerTreeHostImplTest, rootLayerDoesntCreateExtraSurface)
+TEST_P(CCLayerTreeHostImplTest, rootLayerDoesntCreateExtraSurface)
 {
     CCLayerImpl* root = new FakeDrawableCCLayerImpl(1);
     CCLayerImpl* child = new FakeDrawableCCLayerImpl(2);
     child->setAnchorPoint(FloatPoint(0, 0));
     child->setBounds(IntSize(10, 10));
     child->setContentBounds(IntSize(10, 10));
     child->setDrawsContent(true);
     root->setAnchorPoint(FloatPoint(0, 0));
     root->setBounds(IntSize(10, 10));
     root->setContentBounds(IntSize(10, 10));
@@ skipping 119 matching lines @@
             .WillRepeatedly(Return());
 
         EXPECT_CALL(*m_context, enable(GraphicsContext3D::SCISSOR_TEST))
             .Times(0);
 
         EXPECT_CALL(*m_context, scissor(_, _, _, _))
             .Times(0);
     }
 };
 
-TEST_F(CCLayerTreeHostImplTest, noPartialSwap)
+TEST_P(CCLayerTreeHostImplTest, noPartialSwap)
 {
     OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext));
     MockContext* mockContext = static_cast<MockContext*>(context->context3D());
     MockContextHarness harness(mockContext);
 
     harness.mustDrawSolidQuad();
     harness.mustSetScissor(0, 0, 10, 10);
 
     // Run test case
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.release(), FakeLayerWithQuads::create(1));
 
     CCLayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
     myHostImpl->drawLayers(frame);
     myHostImpl->didDrawAllLayers(frame);
     Mock::VerifyAndClearExpectations(&mockContext);
 }
 
-TEST_F(CCLayerTreeHostImplTest, partialSwap)
+TEST_P(CCLayerTreeHostImplTest, partialSwap)
 {
     OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext));
     MockContext* mockContext = static_cast<MockContext*>(context->context3D());
     MockContextHarness harness(mockContext);
 
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(true, context.release(), FakeLayerWithQuads::create(1));
 
     // The first frame is not a partially-swapped one.
     harness.mustSetScissor(0, 0, 10, 10);
     harness.mustDrawSolidQuad();
@@ skipping 103 matching lines @@
     grandChild->setVisibleContentRect(grandChildRect);
     grandChild->setDrawsContent(true);
 
     child->addChild(grandChild.release());
     root->addChild(child.release());
 
     myHostImpl->setRootLayer(root.release());
     return myHostImpl.release();
 }
 
-TEST_F(CCLayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
+TEST_P(CCLayerTreeHostImplTest, contributingLayerEmptyScissorPartialSwap)
 {
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = setupLayersForOpacity(true, this);
 
     {
         CCLayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Just for consistency, the most interesting stuff already happened
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
 
         // Verify all quads have been computed
         ASSERT_EQ(2U, frame.renderPasses.size());
         ASSERT_EQ(1U, frame.renderPasses[0]->quadList().size());
         ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
         EXPECT_EQ(CCDrawQuad::SolidColor, frame.renderPasses[0]->quadList()[0]->material());
         EXPECT_EQ(CCDrawQuad::RenderPass, frame.renderPasses[1]->quadList()[0]->material());
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, contributingLayerEmptyScissorNoPartialSwap)
+TEST_P(CCLayerTreeHostImplTest, contributingLayerEmptyScissorNoPartialSwap)
 {
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = setupLayersForOpacity(false, this);
 
     {
         CCLayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Just for consistency, the most interesting stuff already happened
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
@@ skipping 22 matching lines @@
 private:
     explicit ContextLostNotificationCheckLayer(int id)
         : CCLayerImpl(id)
         , m_didLoseContextCalled(false)
     {
     }
 
     bool m_didLoseContextCalled;
 };
 
-TEST_F(CCLayerTreeHostImplTest, contextLostAndRestoredNotificationSentToAllLayers)
+TEST_P(CCLayerTreeHostImplTest, contextLostAndRestoredNotificationSentToAllLayers)
 {
     m_hostImpl->setRootLayer(ContextLostNotificationCheckLayer::create(1));
     ContextLostNotificationCheckLayer* root = static_cast<ContextLostNotificationCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(ContextLostNotificationCheckLayer::create(1));
     ContextLostNotificationCheckLayer* layer1 = static_cast<ContextLostNotificationCheckLayer*>(root->children()[0]);
 
     layer1->addChild(ContextLostNotificationCheckLayer::create(2));
     ContextLostNotificationCheckLayer* layer2 = static_cast<ContextLostNotificationCheckLayer*>(layer1->children()[0]);
 
     EXPECT_FALSE(root->didLoseContextCalled());
     EXPECT_FALSE(layer1->didLoseContextCalled());
     EXPECT_FALSE(layer2->didLoseContextCalled());
 
     m_hostImpl->initializeRenderer(createContext());
 
     EXPECT_TRUE(root->didLoseContextCalled());
     EXPECT_TRUE(layer1->didLoseContextCalled());
     EXPECT_TRUE(layer2->didLoseContextCalled());
 }
 
-TEST_F(CCLayerTreeHostImplTest, finishAllRenderingAfterContextLost)
+TEST_P(CCLayerTreeHostImplTest, finishAllRenderingAfterContextLost)
 {
     CCLayerTreeSettings settings;
     m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // The context initialization will fail, but we should still be able to call finishAllRendering() without any ill effects.
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFails)));
     m_hostImpl->finishAllRendering();
 }
 
 class FakeWebGraphicsContext3DMakeCurrentFailsEventually : public FakeWebGraphicsContext3D {
 public:
     explicit FakeWebGraphicsContext3DMakeCurrentFailsEventually(unsigned succeedCount) : m_succeedCount(succeedCount) { }
     virtual bool makeContextCurrent() {
         if (!m_succeedCount)
             return false;
         --m_succeedCount;
         return true;
     }
 
 private:
     unsigned m_succeedCount;
 };
 
-TEST_F(CCLayerTreeHostImplTest, contextLostDuringInitialize)
+TEST_P(CCLayerTreeHostImplTest, contextLostDuringInitialize)
 {
     CCLayerTreeSettings settings;
     m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Initialize into a known successful state.
     EXPECT_TRUE(m_hostImpl->initializeRenderer(createContext()));
     EXPECT_TRUE(m_hostImpl->context());
     EXPECT_TRUE(m_hostImpl->renderer());
     EXPECT_TRUE(m_hostImpl->resourceProvider());
 
@@ skipping 229 matching lines @@
     scoped_ptr<CCRenderPass> pass = CCRenderPass::create(CCRenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
     scoped_ptr<CCSharedQuadState> sharedState = CCSharedQuadState::create(WebTransformationMatrix(), IntRect(0, 0, 1, 1), IntRect(0, 0, 1, 1), 1, false);
     scoped_ptr<CCTextureDrawQuad> quad = CCTextureDrawQuad::create(sharedState.get(), IntRect(0, 0, 1, 1), resourceId, false, FloatRect(0, 0, 1, 1), false);
 
     static_cast<CCTestRenderPass*>(pass.get())->appendSharedQuadState(sharedState.Pass());
     static_cast<CCTestRenderPass*>(pass.get())->appendQuad(quad.PassAs<CCDrawQuad>());
 
     return pass.Pass();
 }
 
-TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
+TEST_P(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
     int layerId = 1;
 
     OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(layerId++));
     rootLayer->setBounds(IntSize(10, 10));
     rootLayer->setAnchorPoint(FloatPoint(0, 0));
 
     OwnPtr<CCTiledLayerImpl> tileLayer = CCTiledLayerImpl::create(layerId++);
     tileLayer->setBounds(IntSize(10, 10));
     tileLayer->setAnchorPoint(FloatPoint(0, 0));
@@ skipping 166 matching lines @@
         return WebString();
     }
 
     unsigned numTextures() const { return m_numTextures; }
 
 private:
     HashMap<WebGLId, bool> m_textures;
     unsigned m_numTextures;
 };
 
-TEST_F(CCLayerTreeHostImplTest, layersFreeTextures)
+TEST_P(CCLayerTreeHostImplTest, layersFreeTextures)
 {
     OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(1));
     rootLayer->setBounds(IntSize(10, 10));
     rootLayer->setAnchorPoint(FloatPoint(0, 0));
 
     OwnPtr<CCTiledLayerImpl> tileLayer = CCTiledLayerImpl::create(2);
     tileLayer->setBounds(IntSize(10, 10));
     tileLayer->setAnchorPoint(FloatPoint(0, 0));
     tileLayer->setContentBounds(IntSize(10, 10));
     tileLayer->setDrawsContent(true);
@@ skipping 50 matching lines @@
     // There should be no textures left in use after.
     EXPECT_EQ(0u, trackingWebGraphicsContext->numTextures());
 }
 
 class MockDrawQuadsToFillScreenContext : public FakeWebGraphicsContext3D {
 public:
     MOCK_METHOD1(useProgram, void(WebGLId program));
     MOCK_METHOD4(drawElements, void(WGC3Denum mode, WGC3Dsizei count, WGC3Denum type, WGC3Dintptr offset));
 };
 
-TEST_F(CCLayerTreeHostImplTest, hasTransparentBackground)
+TEST_P(CCLayerTreeHostImplTest, hasTransparentBackground)
 {
     OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockDrawQuadsToFillScreenContext));
     MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(context->context3D());
 
     // Run test case
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.release(), CCLayerImpl::create(1));
     myHostImpl->setBackgroundColor(SK_ColorWHITE);
 
     // Verify one quad is drawn when transparent background set is not set.
     myHostImpl->setHasTransparentBackground(false);
@@ skipping 58 matching lines @@
 
     // Child of the surface layer will produce some quads
     addDrawingLayerTo(surfaceLayerPtr, 4, IntRect(5, 5, rootSize.width() - 25, rootSize.height() - 25), &childPtr);
 }
 
 class CCRendererGLWithReleaseTextures : public CCRendererGL {
 public:
     using CCRendererGL::releaseRenderPassTextures;
 };
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithClipping)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithClipping)
 {
     CCSettings::setPartialSwapEnabled(true);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     CCLayerImpl* rootPtr;
     CCLayerImpl* surfaceLayerPtr;
 
@@ skipping 76 matching lines @@
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
         ASSERT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusion)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusion)
 {
     CCSettings::setPartialSwapEnabled(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
@@ skipping 95 matching lines @@
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
 }
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
 {
     CCSettings::setPartialSwapEnabled(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning, non drawing)
@@ skipping 95 matching lines @@
         // Must receive 1 render pass - for the root.
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(2U, frame.renderPasses[0]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
 {
     CCSettings::setPartialSwapEnabled(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (owning, drawing)
@@ skipping 68 matching lines @@
         ASSERT_EQ(2U, frame.renderPasses.size());
 
         EXPECT_GT(frame.renderPasses[0]->quadList().size(), 0U);
         EXPECT_EQ(2U, frame.renderPasses[1]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
 {
     CCSettings::setPartialSwapEnabled(false);
 
     CCLayerTreeSettings settings;
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structured as follows:
     //
     //  R +-- S1 +- L10 (rotated, drawing)
     //           +- L11 (occupies half surface)
@@ skipping 53 matching lines @@
         // One render pass must be gone due to cached texture.
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
 {
     CCSettings::setPartialSwapEnabled(true);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Layers are structure as follows:
     //
     //  R +-- S1 +- L10 (owning)
@@ skipping 92 matching lines @@
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Root render pass only.
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, textureCachingWithScissor)
+TEST_P(CCLayerTreeHostImplTest, textureCachingWithScissor)
 {
     CCSettings::setPartialSwapEnabled(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     /*
       Layers are created as follows:
 
@@ skipping 86 matching lines @@
         CCLayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // We should have a cached texture for surface 2 again even though it was damaged.
     EXPECT_TRUE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(childPassId));
 }
 
-TEST_F(CCLayerTreeHostImplTest, surfaceTextureCaching)
+TEST_P(CCLayerTreeHostImplTest, surfaceTextureCaching)
 {
     CCSettings::setPartialSwapEnabled(true);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     CCLayerImpl* rootPtr;
     CCLayerImpl* intermediateLayerPtr;
     CCLayerImpl* surfaceLayerPtr;
@@ skipping 140 matching lines @@
         EXPECT_EQ(CCDrawQuad::RenderPass, frame.renderPasses[0]->quadList()[0]->material());
         CCRenderPassDrawQuad* quad = static_cast<CCRenderPassDrawQuad*>(frame.renderPasses[0]->quadList()[0]);
         CCRenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
         EXPECT_TRUE(targetPass->damageRect().isEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
+TEST_P(CCLayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
     CCSettings::setPartialSwapEnabled(false);
 
     CCLayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = IntSize();
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     CCLayerImpl* rootPtr;
     CCLayerImpl* intermediateLayerPtr;
     CCLayerImpl* surfaceLayerPtr;
@@ skipping 142 matching lines @@
         EXPECT_EQ(CCDrawQuad::RenderPass, frame.renderPasses[0]->quadList()[0]->material());
         CCRenderPassDrawQuad* quad = static_cast<CCRenderPassDrawQuad*>(frame.renderPasses[0]->quadList()[0]);
         CCRenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
         EXPECT_TRUE(targetPass->damageRect().isEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
-TEST_F(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
+TEST_P(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
 {
     m_hostImpl->releaseContentsTextures();
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 struct RenderPassRemovalTestData : public CCLayerTreeHostImpl::FrameData {
     ScopedPtrHashMap<CCRenderPass::Id, CCRenderPass> renderPassCache;
     scoped_ptr<CCSharedQuadState> sharedQuadState;
 };
 
@@ skipping 294 matching lines @@
         }
     };
 
 static void verifyRenderPassTestData(TestCase& testCase, RenderPassRemovalTestData& testData)
 {
     char actualResult[1024];
     dumpRenderPassTestData(testData, actualResult);
     EXPECT_STREQ(testCase.expectedResult, actualResult) << "In test case: " << testCase.name;
 }
 
-TEST_F(CCLayerTreeHostImplTest, testRemoveRenderPasses)
+TEST_P(CCLayerTreeHostImplTest, testRemoveRenderPasses)
 {
     OwnPtr<CCGraphicsContext> context(createContext());
     ASSERT_TRUE(context->context3D());
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
 
     OwnPtr<CCTestRenderer> renderer(CCTestRenderer::create(resourceProvider.get()));
 
     int testCaseIndex = 0;
     while (removeRenderPassesCases[testCaseIndex].name) {
         RenderPassRemovalTestData testData;
         configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData, renderer.get());
         CCLayerTreeHostImpl::removeRenderPasses(CCLayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer), testData);
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
+INSTANTIATE_TEST_CASE_P(CCLayerTreeHostImplTests,
+                        CCLayerTreeHostImplTest,
+                        ::testing::Values(false, true));
+
 } // namespace