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

cc/CCLayerTreeHostImpl.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 "base/basictypes.h"
 #include "CCAppendQuadsData.h"
@@ skipping 33 matching lines @@
         return;
     }
 
     TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id);
 }
 
 } // namespace
 
 namespace cc {
 
+CCPinchZoomViewport::CCPinchZoomViewport()
+    : m_pageScaleFactor(1)
+    , m_pageScaleDelta(1)
+    , m_sentPageScaleDelta(1)
+    , m_minPageScaleFactor(0)
+    , m_maxPageScaleFactor(0)
+{
+}
+
+float CCPinchZoomViewport::totalPageScaleFactor() const
+{
+    return m_pageScaleFactor * m_pageScaleDelta;
+}
+
+void CCPinchZoomViewport::setPageScaleDelta(float delta)
+{
+    // Clamp to the current min/max limits.
+    float totalPageScaleFactor = m_pageScaleFactor * delta;
+    if (m_minPageScaleFactor && totalPageScaleFactor < m_minPageScaleFactor)
+        delta = m_minPageScaleFactor / m_pageScaleFactor;
+    else if (m_maxPageScaleFactor && totalPageScaleFactor > m_maxPageScaleFactor)
+        delta = m_maxPageScaleFactor / m_pageScaleFactor;
+
+    if (delta == m_pageScaleDelta)
+        return;
+
+    m_pageScaleDelta = delta;
+}
+
+bool CCPinchZoomViewport::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
+{
+    ASSERT(pageScaleFactor);
+
+    if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && minPageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleFactor)
+        return false;
+
+    m_minPageScaleFactor = minPageScaleFactor;
+    m_maxPageScaleFactor = maxPageScaleFactor;
+
+    m_pageScaleFactor = pageScaleFactor;
+    return true;
+}
+
+FloatRect CCPinchZoomViewport::bounds() const
+{
+    FloatSize scaledViewportSize = m_layoutViewportSize;
+    scaledViewportSize.scale(1 / totalPageScaleFactor());
+
+    FloatRect bounds(FloatPoint(0, 0), scaledViewportSize);
+    bounds.setLocation(m_pinchViewportScrollDelta);
+
+    return bounds;
+}
+
+FloatSize CCPinchZoomViewport::applyScroll(FloatSize& delta)
+{
+    FloatSize overflow;
+    FloatRect pinchedBounds = bounds();
+
+    pinchedBounds.move(delta);
+    if (pinchedBounds.x() < 0) {
+        overflow.setWidth(pinchedBounds.x());
+        pinchedBounds.setX(0);
+    }
+
+    if (pinchedBounds.y() < 0) {
+        overflow.setHeight(pinchedBounds.y());
+        pinchedBounds.setY(0);
+    }
+
+    if (pinchedBounds.maxX() > m_layoutViewportSize.width()) {
+        overflow.setWidth(
+            pinchedBounds.maxX() - m_layoutViewportSize.width());
+        pinchedBounds.move(
+            m_layoutViewportSize.width() - pinchedBounds.maxX(), 0);
+    }
+
+    if (pinchedBounds.maxY() > m_layoutViewportSize.height()) {
+        overflow.setHeight(
+            pinchedBounds.maxY() - m_layoutViewportSize.height());
+        pinchedBounds.move(
+            0, m_layoutViewportSize.height() - pinchedBounds.maxY());
+    }
+    m_pinchViewportScrollDelta = pinchedBounds.location();
+
+    return overflow;
+}
+
+WebTransformationMatrix CCPinchZoomViewport::implTransform() const
+{
+    WebTransformationMatrix transform;
+    transform.scale(m_pageScaleDelta);
+
+    // If the pinch state is applied in the impl, then push it to the
+    // impl transform, otherwise the scale is handled by WebCore.
+    if (CCSettings::pageScalePinchZoomEnabled()) {
+        transform.scale(m_pageScaleFactor);
+        transform.translate(-m_pinchViewportScrollDelta.x(),
+                            -m_pinchViewportScrollDelta.y());
+    }
+
+    return transform;
+}
+
 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient {
 public:
     static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHostImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource)
     {
         return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostImpl, timeSource));
     }
     virtual ~CCLayerTreeHostImplTimeSourceAdapter()
     {
         m_timeSource->setClient(0);
         m_timeSource->setActive(false);
@@ skipping 48 matching lines @@
     , m_rootScrollLayerImpl(0)
     , m_currentlyScrollingLayerImpl(0)
     , m_hudLayerImpl(0)
     , m_scrollingLayerIdFromPreviousTree(-1)
     , m_scrollDeltaIsInScreenSpace(false)
     , m_settings(settings)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAllocationLimit())
-    , m_pageScale(1)
-    , m_pageScaleDelta(1)
-    , m_sentPageScaleDelta(1)
-    , m_minPageScale(0)
-    , m_maxPageScale(0)
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
     , m_pinchGestureActive(false)
     , m_fpsCounter(CCFrameRateCounter::create())
     , m_debugRectHistory(CCDebugRectHistory::create())
 {
     ASSERT(CCProxy::isImplThread());
     didVisibilityChange(this, m_visible);
 }
@@ skipping 55 matching lines @@
     animateLayers(monotonicTime, wallClockTime);
     animateScrollbars(monotonicTime);
 }
 
 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
-    scrollTotal.scale(m_pageScaleDelta);
-    float scaleTotal = m_pageScale * m_pageScaleDelta;
+    scrollTotal.scale(m_pinchZoomViewport.pageScaleDelta());
+    float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();
     IntSize scaledContentSize = contentSize();
-    scaledContentSize.scale(m_pageScaleDelta);
+    scaledContentSize.scale(m_pinchZoomViewport.pageScaleDelta());
 
     m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime);
 
     if (anchorPoint) {
         IntSize windowAnchor(targetPosition);
         windowAnchor.scale(scaleTotal / pageScale);
         windowAnchor -= scrollTotal;
         m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration);
     } else
         m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration);
@@ skipping 14 matching lines @@
     // damage rect. The root damage rect is then used to scissor each surface.
 
     for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
         CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface();
         ASSERT(renderSurface);
         renderSurface->damageTracker()->updateDamageTrackingState(renderSurface->layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnlyFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer(), renderSurfaceLayer->filters());
     }
 }
 
+void CCLayerTreeHostImpl::updateRootScrollLayerImplTransform()
+{
+    if (m_rootScrollLayerImpl) {
+        m_rootScrollLayerImpl->setImplTransform(implTransform());
+    }
+}
+
 void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSurfaceLayerList)
 {
     ASSERT(renderSurfaceLayerList.isEmpty());
     ASSERT(m_rootLayerImpl);
     ASSERT(m_renderer); // For maxTextureSize.
 
     {
+        updateRootScrollLayerImplTransform();
+
         TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc");
         CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), deviceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
         CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
         trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList);
     }
 }
 
 void CCLayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<CCRenderPass> renderPass)
 {
@@ skipping 507 matching lines @@
 }
 
 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
+    m_pinchZoomViewport.setLayoutViewportSize(FloatSize(layoutViewportSize));
+
     updateMaxScrollPosition();
 
     if (m_renderer)
         m_renderer->viewportChanged();
 
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageScaleChange)
 {
@@ skipping 13 matching lines @@
 
 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor == m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
     updateMaxScrollPosition();
 }
 
+float CCLayerTreeHostImpl::pageScaleFactor() const
+{
+    return m_pinchZoomViewport.pageScaleFactor();
+}
 
-void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale)
+void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
-    if (!pageScale)
-        return;
+    if (!pageScaleFactor)
+      return;
 
-    if (m_sentPageScaleDelta == 1 && pageScale == m_pageScale && minPageScale == m_minPageScale && maxPageScale == m_maxPageScale)
-        return;
+    float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.pageScaleFactor();
+    m_pinchZoomViewport.setPageScaleFactorAndLimits(pageScaleFactor, minPageScaleFactor, maxPageScaleFactor);
 
-    m_minPageScale = minPageScale;
-    m_maxPageScale = maxPageScale;
-
-    float pageScaleChange = pageScale / m_pageScale;
-    m_pageScale = pageScale;
-
-    if (pageScaleChange != 1)
-        adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
+    if (!CCSettings::pageScalePinchZoomEnabled()) {
+        if (pageScaleChange != 1)
+            adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
+    }
 
     // Clamp delta to limits and refresh display matrix.
-    setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta);
-    m_sentPageScaleDelta = 1;
-    if (m_rootScrollLayerImpl)
-        m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta);
+    setPageScaleDelta(m_pinchZoomViewport.pageScaleDelta() / m_pinchZoomViewport.sentPageScaleDelta());
+    m_pinchZoomViewport.setSentPageScaleDelta(1);
 }
 
 void CCLayerTreeHostImpl::setPageScaleDelta(float delta)
 {
-    // Clamp to the current min/max limits.
-    float finalMagnifyScale = m_pageScale * delta;
-    if (m_minPageScale && finalMagnifyScale < m_minPageScale)
-        delta = m_minPageScale / m_pageScale;
-    else if (m_maxPageScale && finalMagnifyScale > m_maxPageScale)
-        delta = m_maxPageScale / m_pageScale;
-
-    if (delta == m_pageScaleDelta)
-        return;
-
-    m_pageScaleDelta = delta;
+    m_pinchZoomViewport.setPageScaleDelta(delta);
 
     updateMaxScrollPosition();
-    if (m_rootScrollLayerImpl)
-        m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta);
 }
 
 void CCLayerTreeHostImpl::updateMaxScrollPosition()
 {
     if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
         return;
 
     FloatSize viewBounds = m_deviceViewportSize;
     if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
         // Compensate for non-overlay scrollbars.
         if (clipLayer->masksToBounds()) {
             viewBounds = clipLayer->bounds();
             viewBounds.scale(m_deviceScaleFactor);
         }
     }
-    viewBounds.scale(1 / m_pageScaleDelta);
 
-    // maxScroll is computed in physical pixels, but scroll positions are in layout pixels.
-    IntSize maxScroll = contentSize() - expandedIntSize(viewBounds);
+    IntSize contentBounds = contentSize();
+    if (CCSettings::pageScalePinchZoomEnabled()) {
+        // Pinch with pageScale scrolls entirely in layout space.  contentSize
+        // returns the bounds including the page scale factor, so calculate the
+        // pre page-scale layout size here.
+        float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
+        contentBounds.setWidth(contentBounds.width() / pageScaleFactor);
+        contentBounds.setHeight(contentBounds.height() / pageScaleFactor);
+    } else {
+        viewBounds.scale(1 / m_pinchZoomViewport.pageScaleDelta());
+    }
+
+    IntSize maxScroll = contentBounds - expandedIntSize(viewBounds);
     maxScroll.scale(1 / m_deviceScaleFactor);
+
     // The viewport may be larger than the contents in some cases, such as
     // having a vertical scrollbar but no horizontal overflow.
     maxScroll.clampNegativeToZero();
 
     m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll);
 }
 
 void CCLayerTreeHostImpl::setNeedsRedraw()
 {
     m_client->setNeedsRedrawOnImplThread();
@@ skipping 62 matching lines @@
         m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl;
         // Gesture events need to be transformed from screen coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInScreenSpace = (type == Gesture);
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
-static FloatSize scrollLayerWithScreenSpaceDelta(CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta)
+static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport, CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     ASSERT(layerImpl.screenSpaceTransform().isInvertible());
     WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceTransform().inverse();
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
     bool startClipped, endClipped;
     FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
     FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
     FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
 
     // In general scroll point coordinates should not get clipped.
     ASSERT(!startClipped);
     ASSERT(!endClipped);
     if (startClipped || endClipped)
         return FloatSize();
 
     // Apply the scroll delta.
     FloatSize previousDelta(layerImpl.scrollDelta());
-    layerImpl.scrollBy(localEndPoint - localStartPoint);
+    FloatSize unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint);
+
+    if (viewport)
+        viewport->applyScroll(unscrolled);
 
     // Calculate the applied scroll delta in screen space coordinates.
     FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta;
     FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalEndPoint, endClipped);
     ASSERT(!endClipped);
     if (endClipped)
         return FloatSize();
     return actualScreenSpaceEndPoint - screenSpacePoint;
 }
 
@@ skipping 11 matching lines @@
         return;
 
     FloatSize pendingDelta(scrollDelta);
 
     pendingDelta.scale(m_deviceScaleFactor);
 
     for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
+        CCPinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_pinchZoomViewport : 0;
         FloatSize appliedDelta;
         if (m_scrollDeltaIsInScreenSpace)
-            appliedDelta = scrollLayerWithScreenSpaceDelta(*layerImpl, viewportPoint, pendingDelta);
+            appliedDelta = scrollLayerWithScreenSpaceDelta(viewport, *layerImpl, viewportPoint, pendingDelta);
         else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
         // If the layer wasn't able to move, try the next one in the hierarchy.
         float moveThresholdSquared = 0.1f * 0.1f;
         if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared)
             continue;
 
         // If the applied delta is within 45 degrees of the input delta, bail out to make it easier
         // to scroll just one layer in one direction without affecting any of its parents.
@@ skipping 44 matching lines @@
     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::pinchGestureUpdate");
 
     if (!m_rootScrollLayerImpl)
         return;
 
     if (m_previousPinchAnchor == IntPoint::zero())
         m_previousPinchAnchor = anchor;
 
     // Keep the center-of-pinch anchor specified by (x, y) in a stable
     // position over the course of the magnify.
-    FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / m_pageScaleDelta, m_previousPinchAnchor.y() / m_pageScaleDelta);
-    setPageScaleDelta(m_pageScaleDelta * magnifyDelta);
-    FloatPoint newScaleAnchor(anchor.x() / m_pageScaleDelta, anchor.y() / m_pageScaleDelta);
+    float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
+    FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / pageScaleDelta,
+                                   m_previousPinchAnchor.y() / pageScaleDelta);
+    setPageScaleDelta(pageScaleDelta * magnifyDelta);
+    pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
+    FloatPoint newScaleAnchor(anchor.x() / pageScaleDelta, anchor.y() / pageScaleDelta);
     FloatSize move = previousScaleAnchor - newScaleAnchor;
 
     m_previousPinchAnchor = anchor;
 
-    m_rootScrollLayerImpl->scrollBy(roundedIntSize(move));
+    if (CCSettings::pageScalePinchZoomEnabled()) {
+        // Compute the application of the delta with respect to the current page zoom of the page.
+        move.scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));
+    }
+
+    FloatSize scrollOverflow = CCSettings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;
+    m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow));
 
     if (m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
 }
 
 void CCLayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
     if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEnd();
 
     m_client->setNeedsCommitOnImplThread();
 }
 
 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scrollInfo)
 {
     float pageScale = m_pageScaleAnimation->finalPageScale();
     IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset();
-    scrollOffset.scale(m_pageScale / pageScale);
+    scrollOffset.scale(m_pinchZoomViewport.pageScaleFactor() / pageScale);
     makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale);
 }
 
 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     // Only send fake scroll/zoom deltas if we're pinch zooming out by a
     // significant amount. This also ensures only one fake delta set will be
     // sent.
     const float pinchZoomOutSensitivity = 0.95f;
-    if (m_pageScaleDelta > pinchZoomOutSensitivity)
+    if (m_pinchZoomViewport.pageScaleDelta() > pinchZoomOutSensitivity)
         return;
 
     // Compute where the scroll offset/page scale would be if fully pinch-zoomed
     // out from the anchor point.
     IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
-    scrollBegin.scale(m_pageScaleDelta);
-    float scaleBegin = m_pageScale * m_pageScaleDelta;
-    float pageScaleDeltaToSend = m_minPageScale / m_pageScale;
+    scrollBegin.scale(m_pinchZoomViewport.pageScaleDelta());
+    float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();
+    float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();
     FloatSize scaledContentsSize = contentSize();
     scaledContentsSize.scale(pageScaleDeltaToSend);
 
     FloatSize anchor = toSize(m_previousPinchAnchor);
     FloatSize scrollEnd = scrollBegin + anchor;
-    scrollEnd.scale(m_minPageScale / scaleBegin);
+    scrollEnd.scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);
     scrollEnd -= anchor;
     scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceViewportSize)).expandedTo(FloatSize(0, 0));
     scrollEnd.scale(1 / pageScaleDeltaToSend);
     scrollEnd.scale(m_deviceScaleFactor);
 
-    makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale);
+    makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());
 }
 
 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layerId = m_rootScrollLayerImpl->id();
     scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosition());
     scrollInfo->scrolls.append(scroll);
     m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
-    m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale;
+    scrollInfo->pageScaleDelta = pageScale / m_pinchZoomViewport.pageScaleFactor();
+    m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 }
 
 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* layerImpl)
 {
     if (!layerImpl)
         return;
 
     if (!layerImpl->scrollDelta().isZero()) {
         IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta());
         CCLayerTreeHostCommon::ScrollUpdateInfo scroll;
         scroll.layerId = layerImpl->id();
         scroll.scrollDelta = scrollDelta;
         scrollInfo->scrolls.append(scroll);
         layerImpl->setSentScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
 }
 
 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas()
 {
     OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet());
 
     if (m_pinchGestureActive || m_pageScaleAnimation) {
-        m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1;
-        if (m_pinchGestureActive)
-            computePinchZoomDeltas(scrollInfo.get());
-        else if (m_pageScaleAnimation.get())
-            computeDoubleTapZoomDeltas(scrollInfo.get());
+        scrollInfo->pageScaleDelta = 1;
+        m_pinchZoomViewport.setSentPageScaleDelta(1);
+        // FIXME(aelias): Make these painting optimizations compatible with
+        // compositor-side scaling.
+        if (!CCSettings::pageScalePinchZoomEnabled()) {
+            if (m_pinchGestureActive)
+                computePinchZoomDeltas(scrollInfo.get());
+            else if (m_pageScaleAnimation.get())
+                computeDoubleTapZoomDeltas(scrollInfo.get());
+        }
         return scrollInfo.release();
     }
 
     collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
-    m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta;
+    scrollInfo->pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
+    m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 
     return scrollInfo.release();
 }
 
+WebTransformationMatrix CCLayerTreeHostImpl::implTransform() const
+{
+    return m_pinchZoomViewport.implTransform();
+}
+
 void CCLayerTreeHostImpl::setFullRootLayerDamage()
 {
     if (m_rootLayerImpl) {
         CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface();
         if (renderSurface)
             renderSurface->damageTracker()->forceFullDamageNextUpdate();
     }
 }
 
 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime)
 {
     if (!m_pageScaleAnimation || !m_rootScrollLayerImpl)
         return;
 
     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
 
-    setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pageScale);
+    setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
     IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
-    nextScroll.scale(1 / m_pageScaleDelta);
+    nextScroll.scale(1 / m_pinchZoomViewport.pageScaleDelta());
     m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.clear();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void CCLayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTime)
@@ skipping 91 matching lines @@
 
     CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 } // namespace cc