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

cc/CCLayerTreeHostImpl.h

 // 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.
 
 #ifndef CCLayerTreeHostImpl_h
 #define CCLayerTreeHostImpl_h
 
 #include "CCAnimationEvents.h"
 #include "CCInputHandler.h"
 #include "CCLayerSorter.h"
@@ skipping 24 matching lines @@
 public:
     virtual void didLoseContextOnImplThread() = 0;
     virtual void onSwapBuffersCompleteOnImplThread() = 0;
     virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) = 0;
     virtual void onCanDrawStateChanged(bool canDraw) = 0;
     virtual void setNeedsRedrawOnImplThread() = 0;
     virtual void setNeedsCommitOnImplThread() = 0;
     virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) = 0;
 };
 
+// CCPinchZoomViewport models the bounds and offset of the viewport that is used during a pinch-zoom operation.
+// It tracks the layout-space dimensions of the viewport before any applied scale, and then tracks the layout-space
+// coordinates of the viewport respecting the pinch settings.
+class CCPinchZoomViewport {
+public:
+    CCPinchZoomViewport() : m_pageScaleFactor(1) { }
+
+    void setTotalPageScaleFactor(float factor) { m_pageScaleFactor = factor; }
+
+    // Returns the bounds and offset of the scaled and translated viewport to use for pinch-zoom.
+    FloatRect bounds() const;
+    const FloatPoint& scrollDelta() const { return m_pinchViewportScrollDelta; }
+
+    const FloatSize& unpinchedBounds() const { return m_unpinchedBounds; }
+    void setUnpinchedBounds(const FloatSize& bounds) { m_unpinchedBounds = bounds; }
+
+    // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be
+    // scrolled outside of the unpinched bounds. Returns the component of the scroll that is un-applied due to
+    // this constraint.
+    FloatSize applyScroll(FloatSize&);
+
+private:
+    float m_pageScaleFactor;
+    FloatPoint m_pinchViewportScrollDelta;
+
+    FloatSize m_unpinchedBounds;
+};
+
 // CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state
 class CCLayerTreeHostImpl : public CCInputHandlerClient,
                             public CCRendererClient,
                             public WebKit::WebCompositorOutputSurfaceClient {
     WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImpl);
     typedef Vector<CCLayerImpl*> CCLayerList;
 
 public:
     static PassOwnPtr<CCLayerTreeHostImpl> create(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*);
     virtual ~CCLayerTreeHostImpl();
@@ skipping 84 matching lines @@
     bool contentsTexturesPurged() const { return m_contentsTexturesPurged; }
     void resetContentsTexturesPurged();
     size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }
 
     void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize);
     const IntSize& layoutViewportSize() const { return m_layoutViewportSize; }
 
     float deviceScaleFactor() const { return m_deviceScaleFactor; }
     void setDeviceScaleFactor(float);
 
-    float pageScale() const { return m_pageScale; }
-    void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
+    float pageScaleFactor() const { return m_pageScaleFactor; }
+    void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
 
     PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
 
     void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, double durationSec);
 
     SkColor backgroundColor() const { return m_backgroundColor; }
     void setBackgroundColor(SkColor color) { m_backgroundColor = color; }
 
     bool hasTransparentBackground() const { return m_hasTransparentBackground; }
     void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
@@ skipping 93 matching lines @@
     int m_scrollingLayerIdFromPreviousTree;
     bool m_scrollDeltaIsInScreenSpace;
     CCLayerTreeSettings m_settings;
     IntSize m_layoutViewportSize;
     IntSize m_deviceViewportSize;
     float m_deviceScaleFactor;
     bool m_visible;
     bool m_contentsTexturesPurged;
     size_t m_memoryAllocationLimitBytes;
 
-    float m_pageScale;
+    float m_pageScaleFactor;
     float m_pageScaleDelta;
     float m_sentPageScaleDelta;
-    float m_minPageScale, m_maxPageScale;
+    float m_minPageScaleFactor, m_maxPageScaleFactor;
 
     SkColor m_backgroundColor;
     bool m_hasTransparentBackground;
 
     // If this is true, it is necessary to traverse the layer tree ticking the animators.
     bool m_needsAnimateLayers;
     bool m_pinchGestureActive;
     IntPoint m_previousPinchAnchor;
 
     OwnPtr<CCPageScaleAnimation> m_pageScaleAnimation;
 
     // This is used for ticking animations slowly when hidden.
     OwnPtr<CCLayerTreeHostImplTimeSourceAdapter> m_timeSourceClientAdapter;
 
     CCLayerSorter m_layerSorter;
 
     // List of visible layers for the most recently prepared frame. Used for
     // rendering and input event hit testing.
     CCLayerList m_renderSurfaceLayerList;
 
+    CCPinchZoomViewport m_pinchZoomViewport;
+
     OwnPtr<CCFrameRateCounter> m_fpsCounter;
     OwnPtr<CCDebugRectHistory> m_debugRectHistory;
 };
 
 };
 
 #endif