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 "base/basictypes.h"
 #include "base/time.h"
 #include "CCAnimationEvents.h"
@@ skipping 27 matching lines @@
     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;
     virtual void releaseContentsTexturesOnImplThread() = 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();
+
+    float totalPageScaleFactor() const;
+
+    void setPageScaleFactor(float factor) { m_pageScaleFactor = factor; }
+    float pageScaleFactor() const { return m_pageScaleFactor; }
+
+    void setPageScaleDelta(float delta);
+    float pageScaleDelta() const  { return m_pageScaleDelta; }
+
+    float minPageScaleFactor() const { return m_minPageScaleFactor; }
+    float maxPageScaleFactor() const { return m_maxPageScaleFactor; }
+
+    void setSentPageScaleDelta(float delta) { m_sentPageScaleDelta = delta; }
+    float sentPageScaleDelta() const { return m_sentPageScaleDelta; }
+
+    // Returns true if the passed parameters were different from those previously
+    // cached.
+    bool setPageScaleFactorAndLimits(float pageScaleFactor,
+                                     float minPageScaleFactor,
+                                     float maxPageScaleFactor);
+
+    // 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; }
+
+    void setLayoutViewportSize(const FloatSize& size) { m_layoutViewportSize = size; }
+
+    // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be
+    // scrolled outside of the layout viewport bounds. Returns the component of the scroll that is un-applied due to
+    // this constraint.
+    FloatSize applyScroll(FloatSize&);
+
+    WebKit::WebTransformationMatrix implTransform() const;
+
+private:
+    float m_pageScaleFactor;
+    float m_pageScaleDelta;
+    float m_sentPageScaleDelta;
+    float m_maxPageScaleFactor;
+    float m_minPageScaleFactor;
+
+    FloatPoint m_pinchViewportScrollDelta;
+    FloatSize m_layoutViewportSize;
+};
+
 // CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state
 class CCLayerTreeHostImpl : public CCInputHandlerClient,
                             public CCRendererClient,
                             public WebKit::WebCompositorOutputSurfaceClient {
     typedef Vector<CCLayerImpl*> CCLayerList;
 
 public:
     static PassOwnPtr<CCLayerTreeHostImpl> create(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*);
     virtual ~CCLayerTreeHostImpl();
 
@@ skipping 87 matching lines @@
     void setContentsTexturesPurged();
     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;
+    void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
 
     PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
+    WebKit::WebTransformationMatrix implTransform() const;
 
     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; }
 
     bool needsAnimateLayers() const { return m_needsAnimateLayers; }
     void setNeedsAnimateLayers() { m_needsAnimateLayers = true; }
 
     void setNeedsRedraw();
 
     void renderingStats(CCRenderingStats*) const;
 
+    void updateRootScrollLayerImplTransform();
+
     CCFrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); }
     CCDebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); }
     CCResourceProvider* resourceProvider() const { return m_resourceProvider.get(); }
 
     class CullRenderPassesWithCachedTextures {
     public:
         bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const;
 
         // Iterates from the root first, in order to remove the surfaces closest
         // to the root with cached textures, and all surfaces that draw into
@@ skipping 75 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_pageScaleDelta;
-    float m_sentPageScaleDelta;
-    float m_minPageScale, m_maxPageScale;
-
     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;
 
     size_t m_numImplThreadScrolls;
     size_t m_numMainThreadScrolls;
 
     DISALLOW_COPY_AND_ASSIGN(CCLayerTreeHostImpl);
 };
 
 };
 
 #endif