Use float for scroll offset.

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

 /*
  * Copyright (c) 2011, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 49 matching lines @@
 }
 
 ScrollAnimator::ScrollAnimator(ScrollableArea* scrollableArea,
                                WTF::TimeFunction timeFunction)
     : ScrollAnimatorBase(scrollableArea),
       m_timeFunction(timeFunction),
       m_lastGranularity(ScrollByPixel) {}
 
 ScrollAnimator::~ScrollAnimator() {}
 
-FloatPoint ScrollAnimator::desiredTargetPosition() const {
+ScrollOffset ScrollAnimator::desiredTargetOffset() const {
   if (m_runState == RunState::WaitingToCancelOnCompositor)
-    return currentPosition();
+    return currentOffset();
   return (m_animationCurve || m_runState == RunState::WaitingToSendToCompositor)
              ? m_targetOffset
-             : currentPosition();
+             : currentOffset();
 }
 
 bool ScrollAnimator::hasRunningAnimation() const {
   return m_runState != RunState::PostAnimationCleanup &&
          (m_animationCurve ||
           m_runState == RunState::WaitingToSendToCompositor);
 }
 
-FloatSize ScrollAnimator::computeDeltaToConsume(const FloatSize& delta) const {
-  FloatPoint pos = desiredTargetPosition();
-  FloatPoint newPos =
-      toFloatPoint(m_scrollableArea->clampScrollPosition(pos + delta));
+ScrollOffset ScrollAnimator::computeDeltaToConsume(
+    const ScrollOffset& delta) const {
+  ScrollOffset pos = desiredTargetOffset();
+  ScrollOffset newPos = m_scrollableArea->clampScrollOffset(pos + delta);
   return newPos - pos;
 }
 
 void ScrollAnimator::resetAnimationState() {
   ScrollAnimatorCompositorCoordinator::resetAnimationState();
   if (m_animationCurve)
     m_animationCurve.reset();
   m_startTime = 0.0;
 }
 
 ScrollResult ScrollAnimator::userScroll(ScrollGranularity granularity,
-                                        const FloatSize& delta) {
+                                        const ScrollOffset& delta) {
   if (!m_scrollableArea->scrollAnimatorEnabled())
     return ScrollAnimatorBase::userScroll(granularity, delta);
 
   TRACE_EVENT0("blink", "ScrollAnimator::scroll");
 
   if (granularity == ScrollByPrecisePixel) {
     // Cancel scroll animation because asked to instant scroll.
     if (hasRunningAnimation())
       cancelAnimation();
     return ScrollAnimatorBase::userScroll(granularity, delta);
   }
 
   bool needsPostAnimationCleanup = m_runState == RunState::PostAnimationCleanup;
   if (m_runState == RunState::PostAnimationCleanup)
     resetAnimationState();
 
-  FloatSize consumedDelta = computeDeltaToConsume(delta);
-  FloatPoint targetPos = desiredTargetPosition();
-  targetPos.move(consumedDelta);
+  ScrollOffset consumedDelta = computeDeltaToConsume(delta);
+  ScrollOffset targetOffset = desiredTargetOffset();
+  targetOffset += consumedDelta;
 
-  if (willAnimateToOffset(targetPos)) {
+  if (willAnimateToOffset(targetOffset)) {
     m_lastGranularity = granularity;
     // Report unused delta only if there is no animation running. See
     // comment below regarding scroll latching.
     // TODO(bokan): Need to standardize how ScrollAnimators report
     // unusedDelta. This differs from ScrollAnimatorMac currently.
     return ScrollResult(true, true, 0, 0);
   }
 
   // If the run state when this method was called was PostAnimationCleanup and
   // we're not starting an animation, stay in PostAnimationCleanup state so
   // that the main thread scrolling reason can be removed.
   if (needsPostAnimationCleanup)
     m_runState = RunState::PostAnimationCleanup;
 
   // Report unused delta only if there is no animation and we are not
   // starting one. This ensures we latch for the duration of the
   // animation rather than animating multiple scrollers at the same time.
   return ScrollResult(false, false, delta.width(), delta.height());
 }
 
-bool ScrollAnimator::willAnimateToOffset(const FloatPoint& targetPos) {
+bool ScrollAnimator::willAnimateToOffset(const ScrollOffset& targetOffset) {
   if (m_runState == RunState::PostAnimationCleanup)
     resetAnimationState();
 
   if (m_runState == RunState::WaitingToCancelOnCompositor ||
       m_runState == RunState::WaitingToCancelOnCompositorButNewScroll) {
     ASSERT(m_animationCurve);
-    m_targetOffset = targetPos;
+    m_targetOffset = targetOffset;
     if (registerAndScheduleAnimation())
       m_runState = RunState::WaitingToCancelOnCompositorButNewScroll;
     return true;
   }
 
   if (m_animationCurve) {
-    if ((targetPos - m_targetOffset).isZero())
+    if ((targetOffset - m_targetOffset).isZero())
       return true;
 
-    m_targetOffset = targetPos;
+    m_targetOffset = targetOffset;
     ASSERT(m_runState == RunState::RunningOnMainThread ||
            m_runState == RunState::RunningOnCompositor ||
            m_runState == RunState::RunningOnCompositorButNeedsUpdate ||
            m_runState == RunState::RunningOnCompositorButNeedsTakeover);
 
     // Running on the main thread, simply update the target offset instead
     // of sending to the compositor.
     if (m_runState == RunState::RunningOnMainThread) {
       m_animationCurve->updateTarget(
           m_timeFunction() - m_startTime,
-          compositorOffsetFromBlinkOffset(targetPos));
+          compositorOffsetFromBlinkOffset(targetOffset));
       return true;
     }
 
     if (registerAndScheduleAnimation())
       m_runState = RunState::RunningOnCompositorButNeedsUpdate;
     return true;
   }
 
-  if ((targetPos - currentPosition()).isZero())
+  if ((targetOffset - currentOffset()).isZero())
     return false;
 
-  m_targetOffset = targetPos;
+  m_targetOffset = targetOffset;
   m_startTime = m_timeFunction();
 
   if (registerAndScheduleAnimation())
     m_runState = RunState::WaitingToSendToCompositor;
 
   return true;
 }
 
-void ScrollAnimator::adjustAnimationAndSetScrollPosition(
-    const DoublePoint& position,
+void ScrollAnimator::adjustAnimationAndSetScrollOffset(
+    const ScrollOffset& offset,
     ScrollType scrollType) {
   IntSize adjustment =
-      roundedIntPoint(position) -
-      roundedIntPoint(m_scrollableArea->scrollPositionDouble());
-
-  scrollPositionChanged(position, scrollType);
+      roundedIntSize(offset) - roundedIntSize(m_scrollableArea->scrollOffset());
+  scrollOffsetChanged(offset, scrollType);
 
   if (m_runState == RunState::Idle) {
     adjustImplOnlyScrollOffsetAnimation(adjustment);
   } else if (hasRunningAnimation()) {
-    m_targetOffset += toFloatSize(adjustment);
+    m_targetOffset += ScrollOffset(adjustment);
     if (m_animationCurve) {
       m_animationCurve->applyAdjustment(adjustment);
       if (m_runState != RunState::RunningOnMainThread &&
           registerAndScheduleAnimation())
         m_runState = RunState::RunningOnCompositorButNeedsAdjustment;
     }
   }
 }
 
-void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset) {
-  m_currentPos = offset;
+void ScrollAnimator::scrollToOffsetWithoutAnimation(
+    const ScrollOffset& offset) {
+  m_currentOffset = offset;
 
   resetAnimationState();
-  notifyPositionChanged();
+  notifyOffsetChanged();
 }
 
 void ScrollAnimator::tickAnimation(double monotonicTime) {
   if (m_runState != RunState::RunningOnMainThread)
     return;
 
   TRACE_EVENT0("blink", "ScrollAnimator::tickAnimation");
   double elapsedTime = monotonicTime - m_startTime;
 
   bool isFinished = (elapsedTime > m_animationCurve->duration());
-  FloatPoint offset = blinkOffsetFromCompositorOffset(
+  ScrollOffset offset = blinkOffsetFromCompositorOffset(
       isFinished ? m_animationCurve->targetValue()
                  : m_animationCurve->getValue(elapsedTime));
 
-  offset = FloatPoint(m_scrollableArea->clampScrollPosition(offset));
+  offset = m_scrollableArea->clampScrollOffset(offset);
 
-  m_currentPos = offset;
+  m_currentOffset = offset;
 
   if (isFinished)
     m_runState = RunState::PostAnimationCleanup;
   else
     getScrollableArea()->scheduleAnimation();
 
-  TRACE_EVENT0("blink", "ScrollAnimator::notifyPositionChanged");
-  notifyPositionChanged();
+  TRACE_EVENT0("blink", "ScrollAnimator::notifyOffsetChanged");
+  notifyOffsetChanged();
 }
 
 void ScrollAnimator::postAnimationCleanupAndReset() {
   // Remove the temporary main thread scrolling reason that was added while
   // main thread had scheduled an animation.
   removeMainThreadScrollingReason();
 
   resetAnimationState();
 }
 
@@ skipping 25 matching lines @@
 }
 
 void ScrollAnimator::createAnimationCurve() {
   DCHECK(!m_animationCurve);
   m_animationCurve = CompositorScrollOffsetAnimationCurve::create(
       compositorOffsetFromBlinkOffset(m_targetOffset),
       m_lastGranularity == ScrollByPixel
           ? CompositorScrollOffsetAnimationCurve::ScrollDurationInverseDelta
           : CompositorScrollOffsetAnimationCurve::ScrollDurationConstant);
   m_animationCurve->setInitialValue(
-      compositorOffsetFromBlinkOffset(currentPosition()));
+      compositorOffsetFromBlinkOffset(currentOffset()));
 }
 
 void ScrollAnimator::updateCompositorAnimations() {
   ScrollAnimatorCompositorCoordinator::updateCompositorAnimations();
 
   if (m_runState == RunState::PostAnimationCleanup) {
     postAnimationCleanupAndReset();
     return;
   }
 
@@ skipping 24 matching lines @@
 
     if (m_runState != RunState::RunningOnCompositorButNeedsAdjustment) {
       // When in RunningOnCompositorButNeedsAdjustment, the call to
       // ::adjustScrollOffsetAnimation should have made the necessary
       // adjustment to the curve.
       m_animationCurve->updateTarget(
           m_timeFunction() - m_startTime,
           compositorOffsetFromBlinkOffset(m_targetOffset));
     }
 
-    if (m_runState == RunState::WaitingToCancelOnCompositorButNewScroll)
+    if (m_runState == RunState::WaitingToCancelOnCompositorButNewScroll) {
       m_animationCurve->setInitialValue(
-          compositorOffsetFromBlinkOffset(currentPosition()));
+          compositorOffsetFromBlinkOffset(currentOffset()));
+    }
 
     m_runState = RunState::WaitingToSendToCompositor;
   }
 
   if (m_runState == RunState::WaitingToSendToCompositor) {
     if (!m_compositorAnimationAttachedToElementId)
       reattachCompositorPlayerIfNeeded(
           getScrollableArea()->compositorAnimationTimeline());
 
     if (!m_animationCurve)
@@ skipping 45 matching lines @@
     double monotonicTime,
     double animationStartTime,
     std::unique_ptr<cc::AnimationCurve> curve) {
   // If there is already an animation running and the compositor asks to take
   // over an animation, do nothing to avoid judder.
   if (hasRunningAnimation())
     return;
 
   cc::ScrollOffsetAnimationCurve* scrollOffsetAnimationCurve =
       curve->ToScrollOffsetAnimationCurve();
-  FloatPoint targetValue(scrollOffsetAnimationCurve->target_value().x(),
-                         scrollOffsetAnimationCurve->target_value().y());
+  ScrollOffset targetValue(scrollOffsetAnimationCurve->target_value().x(),
+                           scrollOffsetAnimationCurve->target_value().y());
   if (willAnimateToOffset(targetValue)) {
     m_animationCurve = CompositorScrollOffsetAnimationCurve::create(
         std::move(scrollOffsetAnimationCurve));
     m_startTime = animationStartTime;
   }
 }
 
 void ScrollAnimator::cancelAnimation() {
   ScrollAnimatorCompositorCoordinator::cancelAnimation();
 }
@@ skipping 20 matching lines @@
     return false;
   }
   return true;
 }
 
 DEFINE_TRACE(ScrollAnimator) {
   ScrollAnimatorBase::trace(visitor);
 }
 
 }  // namespace blink