cc: Rewrite PageScaleAnimation for new coordinate system.

- I moved PageScaleAnimation to work entirely at root content layer
  scale, to be consistent with the new pinch zoom code. This avoids the
  need for any scaling of scroll offsets. However, everything must now
  be in floating point, and the complexity is moved into viewport size
  calculation instead.

- I also took the opportunity to add support for two anchors instead of
  just one, introducing an additional level of interpolation. This
  makes the animation appear less jarring when we clamp it to document
  edge, and it also removes the need for special-casing translation-only
  animations.

BUG=152505


Review URL: https://chromiumcodereview.appspot.com/11090062

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@166855 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 40 insertions, 30 deletions

diff --git a/cc/page_scale_animation.h b/cc/page_scale_animation.h
index c4c2940..2d8f6d5 100644
--- a/cc/page_scale_animation.h
+++ b/cc/page_scale_animation.h
@@ -7,7 +7,7 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "ui/gfx/size.h"
-#include "ui/gfx/vector2d.h"
+#include "ui/gfx/vector2d_f.h"
 
 namespace cc {
 
@@ -15,30 +15,32 @@ namespace cc {
 // double-tap zoom. Initialize it with starting and ending scroll/page scale
 // positions and an animation length time, then call ...AtTime() at every frame
 // to obtain the current interpolated position.
+//
+// All sizes and vectors in this class's public methods are in the root scroll
+// layer's coordinate space.
 class PageScaleAnimation {
 public:
-    // Construct with the starting page scale and scroll offset (which is in
-    // pageScaleStart space). The window size is the user-viewable area
-    // in pixels.
-    static scoped_ptr<PageScaleAnimation> create(gfx::Vector2d scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime);
+    // Construct with the state at the beginning of the animation.
+    static scoped_ptr<PageScaleAnimation> create(const gfx::Vector2dF& startScrollOffset, float startPageScaleFactor, const gfx::SizeF& viewportSize, const gfx::SizeF& rootLayerSize, double startTime);
+
     ~PageScaleAnimation();
 
     // The following methods initialize the animation. Call one of them
     // immediately after construction to set the final scroll and page scale.
 
-    // Zoom while explicitly specifying the top-left scroll position. The
-    // scroll offset is in finalPageScale coordinates.
-    void zoomTo(gfx::Vector2d finalScroll, float finalPageScale, double duration);
+    // Zoom while explicitly specifying the top-left scroll position.
+    void zoomTo(const gfx::Vector2dF& targetScrollOffset, float targetPageScaleFactor, double duration);
 
-    // Zoom based on a specified onscreen anchor, which will remain at the same
-    // position on the screen throughout the animation. The anchor is in local
-    // space relative to scrollStart.
-    void zoomWithAnchor(gfx::Vector2d anchor, float finalPageScale, double duration);
+    // Zoom based on a specified anchor. The animator will attempt to keep it
+    // at the same position on the physical display throughout the animation,
+    // unless the edges of the root layer are hit. The anchor is specified
+    // as an offset from the content layer.
+    void zoomWithAnchor(const gfx::Vector2dF& anchor, float targetPageScaleFactor, double duration);
 
     // Call these functions while the animation is in progress to output the
     // current state.
-    gfx::Vector2d scrollOffsetAtTime(double time) const;
-    float pageScaleAtTime(double time) const;
+    gfx::Vector2dF scrollOffsetAtTime(double time) const;
+    float pageScaleFactorAtTime(double time) const;
     bool isAnimationCompleteAtTime(double time) const;
 
     // The following methods return state which is invariant throughout the
@@ -46,26 +48,34 @@ public:
     double startTime() const { return m_startTime; }
     double duration() const { return m_duration; }
     double endTime() const { return m_startTime + m_duration; }
-    gfx::Vector2d finalScrollOffset() const { return m_scrollEnd; }
-    float finalPageScale() const { return m_pageScaleEnd; }
+    const gfx::Vector2dF& targetScrollOffset() const { return m_targetScrollOffset; }
+    float targetPageScaleFactor() const { return m_targetPageScaleFactor; }
 
 protected:
-    PageScaleAnimation(gfx::Vector2d scrollStart, float pageScaleStart, const gfx::Size& windowSize, const gfx::Size& contentSize, double startTime);
+    PageScaleAnimation(const gfx::Vector2dF& startScrollOffset, float startPageScaleFactor, const gfx::SizeF& viewportSize, const gfx::SizeF& rootLayerSize, double startTime);
 
 private:
-    float progressRatioForTime(double time) const;
-    gfx::Vector2d scrollOffsetAtRatio(float ratio) const;
-    float pageScaleAtRatio(float ratio) const;
-
-    gfx::Vector2d m_scrollStart;
-    float m_pageScaleStart;
-    gfx::Size m_windowSize;
-    gfx::Size m_contentSize;
-
-    bool m_anchorMode;
-    gfx::Vector2d m_anchor;
-    gfx::Vector2d m_scrollEnd;
-    float m_pageScaleEnd;
+    void clampTargetScrollOffset();
+    void inferTargetScrollOffsetFromStartAnchor();
+    void inferTargetAnchorFromScrollOffsets();
+    gfx::SizeF viewportSizeAtScale(float pageScaleFactor) const;
+
+    float interpAtTime(double time) const;
+    gfx::Vector2dF scrollOffsetAt(float interp) const;
+    gfx::Vector2dF anchorAt(float interp) const;
+    gfx::Vector2dF viewportRelativeAnchorAt(float interp) const;
+    float pageScaleFactorAt(float interp) const;
+
+    float m_startPageScaleFactor;
+    float m_targetPageScaleFactor;
+    gfx::Vector2dF m_startScrollOffset;
+    gfx::Vector2dF m_targetScrollOffset;
+
+    gfx::Vector2dF m_startAnchor;
+    gfx::Vector2dF m_targetAnchor;
+
+    gfx::SizeF m_viewportSize;
+    gfx::SizeF m_rootLayerSize;
 
     double m_startTime;
     double m_duration;