Use float for scroll offset.

third_party/WebKit/Source/platform/scroll/ScrollAnimatorCompositorCoordinator.h

 // Copyright 2015 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 ScrollAnimatorCompositorCoordinator_h
 #define ScrollAnimatorCompositorCoordinator_h
 
 #include "base/gtest_prod_util.h"
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/scroll_offset_animations.h"
 #include "platform/PlatformExport.h"
 #include "platform/animation/CompositorAnimationDelegate.h"
 #include "platform/animation/CompositorAnimationPlayerClient.h"
-#include "platform/geometry/FloatPoint.h"
 #include "platform/graphics/CompositorElementId.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 #include <memory>
 
 namespace blink {
 
 class ScrollableArea;
@@ skipping 37 matching lines @@
     PostAnimationCleanup,
 
     // Running an animation on the compositor but need to continue it
     // on the main thread. This could happen if a main thread scrolling
     // reason is added while animating the scroll offset.
     RunningOnCompositorButNeedsTakeover,
 
     // Waiting to cancel the animation currently running on the compositor
     // while another animation is requested. In this case, the currently
     // running animation is aborted and an animation to the new target
-    // from the current position is started.
+    // from the current offset is started.
     WaitingToCancelOnCompositorButNewScroll,
 
     // Running an animation on the compositor but an adjustment to the
-    // scroll position was made on the main thread and the animation must
+    // scroll offset was made on the main thread and the animation must
     // be updated.
     RunningOnCompositorButNeedsAdjustment,
   };
 
   virtual ~ScrollAnimatorCompositorCoordinator();
 
   bool hasAnimationThatRequiresService() const;
   void dispose();
   String runStateAsText() const;
 
   virtual bool hasRunningAnimation() const { return false; }
 
   virtual void resetAnimationState();
   virtual void cancelAnimation();
   // Aborts the currently running scroll offset animation on the compositor
   // and continues it on the main thread. This should only be called when in
   // DocumentLifecycle::LifecycleState::CompositingClean state.
   virtual void takeOverCompositorAnimation();
-  // Updates the scroll position of the animator's ScrollableArea by
+  // Updates the scroll offset of the animator's ScrollableArea by
   // adjustment and update the target of an ongoing scroll offset animation.
-  virtual void adjustAnimationAndSetScrollPosition(const DoublePoint& position,
-                                                   ScrollType);
+  virtual void adjustAnimationAndSetScrollOffset(const ScrollOffset&,
+                                                 ScrollType);
   virtual void updateCompositorAnimations();
 
   virtual ScrollableArea* getScrollableArea() const = 0;
   virtual void tickAnimation(double monotonicTime) = 0;
   virtual void notifyCompositorAnimationFinished(int groupId) = 0;
   virtual void notifyCompositorAnimationAborted(int groupId) = 0;
   virtual void layerForCompositedScrollingDidChange(
       CompositorAnimationTimeline*) = 0;
 
   RunState runStateForTesting() { return m_runState; }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {}
 
  protected:
   explicit ScrollAnimatorCompositorCoordinator();
 
-  void scrollPositionChanged(const DoublePoint& offset, ScrollType);
+  void scrollOffsetChanged(const ScrollOffset&, ScrollType);
 
   void adjustImplOnlyScrollOffsetAnimation(const IntSize& adjustment);
   IntSize implOnlyAnimationAdjustmentForTesting() {
     return m_implOnlyAnimationAdjustment;
   }
 
   void resetAnimationIds();
   bool addAnimation(std::unique_ptr<CompositorAnimation>);
   void removeAnimation();
   virtual void abortAnimation();
 
-  FloatPoint compositorOffsetFromBlinkOffset(FloatPoint);
-  FloatPoint blinkOffsetFromCompositorOffset(FloatPoint);
+  // "offset" in the cc scrolling code is analagous to "position" in the blink
+  // scrolling code:
+  // they both represent the distance from the top-left of the overflow rect to
+  // the top-left
+  // of the viewport.  In blink, "offset" refers to the distance of the viewport
+  // from the
+  // beginning of flow of the contents.  In left-to-right flows, blink "offset"
+  // and "position" are
+  // equivalent, but in right-to-left flows (including direction:rtl,
+  // writing-mode:vertical-rl,
+  // and flex-direction:row-reverse), they aren't.  See core/layout/README.md
+  // for more info.
+  FloatPoint compositorOffsetFromBlinkOffset(ScrollOffset);
+  ScrollOffset blinkOffsetFromCompositorOffset(FloatPoint);
 
   void compositorAnimationFinished(int groupId);
   // Returns true if the compositor player was attached to a new layer.
   bool reattachCompositorPlayerIfNeeded(CompositorAnimationTimeline*);
 
   // CompositorAnimationDelegate implementation.
   void notifyAnimationStarted(double monotonicTime, int group) override;
   void notifyAnimationFinished(double monotonicTime, int group) override;
   void notifyAnimationAborted(double monotonicTime, int group) override;
   void notifyAnimationTakeover(double monotonicTime,
@@ skipping 31 matching lines @@
   bool hasImplOnlyAnimationUpdate() const;
   void updateImplOnlyCompositorAnimations();
   // Accesses compositing state and should only be called when in or after
   // DocumentLifecycle::LifecycleState::CompositingClean.
   void takeOverImplOnlyScrollOffsetAnimation();
 };
 
 }  // namespace blink
 
 #endif  // ScrollAnimatorCompositorCoordinator_h