Use float for scroll offset.

third_party/WebKit/Source/platform/scroll/ProgrammaticScrollAnimator.cpp

 // Copyright 2014 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 "platform/scroll/ProgrammaticScrollAnimator.h"
 
 #include "platform/animation/CompositorAnimation.h"
 #include "platform/animation/CompositorScrollOffsetAnimationCurve.h"
-#include "platform/geometry/IntPoint.h"
+#include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 ProgrammaticScrollAnimator::ProgrammaticScrollAnimator(
     ScrollableArea* scrollableArea)
     : m_scrollableArea(scrollableArea), m_startTime(0.0) {}
 
 ProgrammaticScrollAnimator::~ProgrammaticScrollAnimator() {}
 
 void ProgrammaticScrollAnimator::resetAnimationState() {
   ScrollAnimatorCompositorCoordinator::resetAnimationState();
   m_animationCurve.reset();
   m_startTime = 0.0;
 }
 
-void ProgrammaticScrollAnimator::notifyPositionChanged(
-    const DoublePoint& offset) {
-  scrollPositionChanged(offset, ProgrammaticScroll);
+void ProgrammaticScrollAnimator::notifyOffsetChanged(
+    const ScrollOffset& offset) {
+  scrollOffsetChanged(offset, ProgrammaticScroll);
 }
 
 void ProgrammaticScrollAnimator::scrollToOffsetWithoutAnimation(
-    const FloatPoint& offset) {
+    const ScrollOffset& offset) {
   cancelAnimation();
-  notifyPositionChanged(offset);
+  notifyOffsetChanged(offset);
 }
 
-void ProgrammaticScrollAnimator::animateToOffset(FloatPoint offset) {
+void ProgrammaticScrollAnimator::animateToOffset(const ScrollOffset& offset) {
   if (m_runState == RunState::PostAnimationCleanup)
     resetAnimationState();
 
   m_startTime = 0.0;
   m_targetOffset = offset;
   m_animationCurve = CompositorScrollOffsetAnimationCurve::create(
       compositorOffsetFromBlinkOffset(m_targetOffset),
       CompositorScrollOffsetAnimationCurve::ScrollDurationDeltaBased);
 
   m_scrollableArea->registerForAnimation();
   if (!m_scrollableArea->scheduleAnimation()) {
     resetAnimationState();
-    notifyPositionChanged(IntPoint(offset.x(), offset.y()));
+    notifyOffsetChanged(offset);
   }
   m_runState = RunState::WaitingToSendToCompositor;
 }
 
 void ProgrammaticScrollAnimator::cancelAnimation() {
   ASSERT(m_runState != RunState::RunningOnCompositorButNeedsUpdate);
   ScrollAnimatorCompositorCoordinator::cancelAnimation();
 }
 
 void ProgrammaticScrollAnimator::tickAnimation(double monotonicTime) {
   if (m_runState != RunState::RunningOnMainThread)
     return;
 
   if (!m_startTime)
     m_startTime = monotonicTime;
   double elapsedTime = monotonicTime - m_startTime;
   bool isFinished = (elapsedTime > m_animationCurve->duration());
-  FloatPoint offset =
+  ScrollOffset offset =
       blinkOffsetFromCompositorOffset(m_animationCurve->getValue(elapsedTime));
-  notifyPositionChanged(IntPoint(offset.x(), offset.y()));
+  notifyOffsetChanged(offset);
 
   if (isFinished) {
     m_runState = RunState::PostAnimationCleanup;
   } else if (!m_scrollableArea->scheduleAnimation()) {
-    notifyPositionChanged(IntPoint(m_targetOffset.x(), m_targetOffset.y()));
+    notifyOffsetChanged(offset);
     resetAnimationState();
   }
 }
 
 void ProgrammaticScrollAnimator::updateCompositorAnimations() {
   if (m_runState == RunState::PostAnimationCleanup) {
     // No special cleanup, simply reset animation state. We have this state
     // here because the state machine is shared with ScrollAnimator which
     // has to do some cleanup that requires the compositing state to be clean.
     return resetAnimationState();
@@ skipping 35 matching lines @@
       if (addAnimation(std::move(animation))) {
         sentToCompositor = true;
         m_runState = RunState::RunningOnCompositor;
         m_compositorAnimationId = animationId;
         m_compositorAnimationGroupId = animationGroupId;
       }
     }
 
     if (!sentToCompositor) {
       m_runState = RunState::RunningOnMainThread;
-      m_animationCurve->setInitialValue(compositorOffsetFromBlinkOffset(
-          FloatPoint(m_scrollableArea->scrollPosition())));
+      m_animationCurve->setInitialValue(
+          compositorOffsetFromBlinkOffset(m_scrollableArea->scrollOffset()));
       if (!m_scrollableArea->scheduleAnimation()) {
-        notifyPositionChanged(IntPoint(m_targetOffset.x(), m_targetOffset.y()));
+        notifyOffsetChanged(m_targetOffset);
         resetAnimationState();
       }
     }
   }
 }
 
 void ProgrammaticScrollAnimator::layerForCompositedScrollingDidChange(
     CompositorAnimationTimeline* timeline) {
   reattachCompositorPlayerIfNeeded(timeline);
 
   // If the composited scrolling layer is lost during a composited animation,
   // continue the animation on the main thread.
   if (m_runState == RunState::RunningOnCompositor &&
       !m_scrollableArea->layerForScrolling()) {
     m_runState = RunState::RunningOnMainThread;
     m_compositorAnimationId = 0;
     m_compositorAnimationGroupId = 0;
-    m_animationCurve->setInitialValue(compositorOffsetFromBlinkOffset(
-        FloatPoint(m_scrollableArea->scrollPosition())));
+    m_animationCurve->setInitialValue(
+        compositorOffsetFromBlinkOffset(m_scrollableArea->scrollOffset()));
     m_scrollableArea->registerForAnimation();
     if (!m_scrollableArea->scheduleAnimation()) {
       resetAnimationState();
-      notifyPositionChanged(IntPoint(m_targetOffset.x(), m_targetOffset.y()));
+      notifyOffsetChanged(m_targetOffset);
     }
   }
 }
 
 void ProgrammaticScrollAnimator::notifyCompositorAnimationFinished(
     int groupId) {
   ASSERT(m_runState != RunState::RunningOnCompositorButNeedsUpdate);
   ScrollAnimatorCompositorCoordinator::compositorAnimationFinished(groupId);
 }
 
 DEFINE_TRACE(ProgrammaticScrollAnimator) {
   visitor->trace(m_scrollableArea);
   ScrollAnimatorCompositorCoordinator::trace(visitor);
 }
 
 }  // namespace blink