cc: Rewrite PageScaleAnimation for new coordinate system.

cc/layer_tree_host_impl.cc

 // 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 "cc/layer_tree_host_impl.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 274 matching lines @@
     return m_context.get();
 }
 
 void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     animatePageScale(monotonicTime);
     animateLayers(monotonicTime, wallClockTime);
     animateScrollbars(monotonicTime);
 }
 
-void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
+void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetPosition, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)

[danakj, 2012/11/09 05:06:49]

call it targetOffset, or change the type to a Point.

Vector2d = offset
Point = position

 {
     if (!m_rootScrollLayerImpl)
         return;
 
     gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
-    scrollTotal.Scale(m_pinchZoomViewport.pageScaleDelta());
-    float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();
-    gfx::Size scaledContentSize = gfx::ToFlooredSize(contentSize().Scale(m_pinchZoomViewport.pageScaleDelta()));
+    gfx::SizeF scaledContentSize = contentSize();
+    if (!Settings::pageScalePinchZoomEnabled()) {
+        scrollTotal.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
+        scaledContentSize = scaledContentSize.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
+    }
+    gfx::SizeF viewportSize = m_deviceViewportSize;
+    viewportSize = viewportSize.Scale(1 / m_deviceScaleFactor);

[danakj, 2012/11/09 05:06:49]

Just use m_layoutViewportSize ?

 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
-    m_pageScaleAnimation = PageScaleAnimation::create(gfx::ToFlooredVector2d(scrollTotal), scaleTotal, m_deviceViewportSize, scaledContentSize, startTimeSeconds);
+    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, m_pinchZoomViewport.totalPageScaleFactor(), viewportSize, scaledContentSize, startTimeSeconds);
 
     if (anchorPoint) {
-        gfx::Vector2dF windowAnchor = targetOffset;
-        windowAnchor.Scale(scaleTotal / pageScale);
-        windowAnchor -= scrollTotal;
-        m_pageScaleAnimation->zoomWithAnchor(gfx::ToFlooredVector2d(windowAnchor), pageScale, duration.InSecondsF());
-    } else
-        m_pageScaleAnimation->zoomTo(targetOffset, pageScale, duration.InSecondsF());
+        gfx::Vector2dF anchor(targetPosition);
+        if (!Settings::pageScalePinchZoomEnabled())
+            anchor.Scale(1 / pageScale);
+        m_pageScaleAnimation->zoomWithAnchor(anchor, pageScale, duration.InSecondsF());
+    } else {
+        gfx::Vector2dF scaledTargetPosition = targetPosition;

[danakj, 2012/11/09 05:06:49]

scaledTargetOffset

+        if (!Settings::pageScalePinchZoomEnabled())
+            scaledTargetPosition.Scale(1 / pageScale);
+        m_pageScaleAnimation->zoomTo(scaledTargetPosition, pageScale, duration.InSecondsF());
+    }
 
     m_client->setNeedsRedrawOnImplThread();
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::scheduleAnimation()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
@@ skipping 914 matching lines @@
     m_pinchGestureActive = false;
 
     if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEnd();
 
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
-    float pageScale = m_pageScaleAnimation->finalPageScale();
-    gfx::Vector2dF scrollOffset = m_pageScaleAnimation->finalScrollOffset();
-    scrollOffset.Scale(m_pinchZoomViewport.pageScaleFactor() / pageScale);
-    makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollOffset), pageScale);
+    gfx::Vector2dF scaledScrollOffset = m_pageScaleAnimation->targetScrollOffset();
+    if (!Settings::pageScalePinchZoomEnabled())
+        scaledScrollOffset.Scale(m_pinchZoomViewport.pageScaleFactor());
+    makeScrollAndScaleSet(scrollInfo, ToFlooredVector2d(scaledScrollOffset), m_pageScaleAnimation->targetPageScaleFactor());
 }
 
 void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* 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.
@@ skipping 53 matching lines @@
         collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
 {
     scoped_ptr<ScrollAndScaleSet> scrollInfo(new ScrollAndScaleSet());
 
     if (m_pinchGestureActive || m_pageScaleAnimation) {
         scrollInfo->pageScaleDelta = 1;
         m_pinchZoomViewport.setSentPageScaleDelta(1);
-        // FIXME(aelias): Make these painting optimizations compatible with
+        // FIXME(aelias): Make pinch-zoom painting optimization compatible with
         // compositor-side scaling.
-        if (!Settings::pageScalePinchZoomEnabled()) {
-            if (m_pinchGestureActive)
-                computePinchZoomDeltas(scrollInfo.get());
-            else if (m_pageScaleAnimation.get())
-                computeDoubleTapZoomDeltas(scrollInfo.get());
-        }
+        if (!Settings::pageScalePinchZoomEnabled() && m_pinchGestureActive)
+            computePinchZoomDeltas(scrollInfo.get());
+        else if (m_pageScaleAnimation.get())
+            computeDoubleTapZoomDeltas(scrollInfo.get());
         return scrollInfo.Pass();
     }
 
     collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
     scrollInfo->pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 
     return scrollInfo.Pass();
 }
 
@@ skipping 12 matching lines @@
 }
 
 void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
 {
     if (!m_pageScaleAnimation || !m_rootScrollLayerImpl)
         return;
 
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
 
-    setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
+    setPageScaleDelta(m_pageScaleAnimation->pageScaleFactorAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
     gfx::Vector2dF nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
-    nextScroll.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
+
+    if (!Settings::pageScalePinchZoomEnabled())
+        nextScroll.Scale(m_pinchZoomViewport.pageScaleFactor());
     m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
@@ skipping 94 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc