Use float for scroll offset.

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

 /*
  * Copyright (C) 2008, 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ScrollableArea_h
 #define ScrollableArea_h
 
 #include "platform/PlatformExport.h"
 #include "platform/RuntimeEnabledFeatures.h"
-#include "platform/geometry/DoublePoint.h"
+#include "platform/geometry/LayoutRect.h"
 #include "platform/graphics/Color.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollAnimatorBase.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "platform/scroll/Scrollbar.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
-class DoubleRect;
-class FloatPoint;
 class GraphicsLayer;
 class HostWindow;
 class LayoutBox;
-class PlatformWheelEvent;
 class ProgrammaticScrollAnimator;
 struct ScrollAlignment;
 class ScrollAnchor;
 class ScrollAnimatorBase;
 class CompositorAnimationTimeline;
-class Widget;
 
 enum IncludeScrollbarsInRect {
   ExcludeScrollbars,
   IncludeScrollbars,
 };
 
 class PLATFORM_EXPORT ScrollableArea : public GarbageCollectedMixin {
   WTF_MAKE_NONCOPYABLE(ScrollableArea);
 
  public:
   static int pixelsPerLineStep(HostWindow*);
   static float minFractionToStepWhenPaging();
   static int maxOverlapBetweenPages();
 
   // Convert a non-finite scroll value (Infinity, -Infinity, NaN) to 0 as
   // per http://dev.w3.org/csswg/cssom-view/#normalize-non_finite-values.
-  static double normalizeNonFiniteScroll(double value) {
+  static float normalizeNonFiniteScroll(float value) {
     return std::isfinite(value) ? value : 0.0;
   }
 
   // The window that hosts the ScrollableArea. The ScrollableArea will communicate scrolls and repaints to the
   // host window in the window's coordinate space.
   virtual HostWindow* getHostWindow() const { return 0; }
 
-  virtual ScrollResult userScroll(ScrollGranularity, const FloatSize&);
+  virtual ScrollResult userScroll(ScrollGranularity, const ScrollOffset&);
 
-  virtual void setScrollPosition(const DoublePoint&,
+  virtual void setScrollOffset(const ScrollOffset&,
+                               ScrollType,
+                               ScrollBehavior = ScrollBehaviorInstant);
+  virtual void scrollBy(const ScrollOffset&,
+                        ScrollType,
+                        ScrollBehavior = ScrollBehaviorInstant);
+  void setScrollOffsetSingleAxis(ScrollbarOrientation,
+                                 float,
                                  ScrollType,
                                  ScrollBehavior = ScrollBehaviorInstant);
-  virtual void scrollBy(const DoubleSize&,
-                        ScrollType,
-                        ScrollBehavior = ScrollBehaviorInstant);
-  void setScrollPositionSingleAxis(ScrollbarOrientation,
-                                   double,
-                                   ScrollType,
-                                   ScrollBehavior = ScrollBehaviorInstant);
 
   // Scrolls the area so that the given rect, given in the document's content coordinates, such that it's
   // visible in the area. Returns the new location of the input rect relative once again to the document.
   // Note, in the case of a Document container, such as FrameView, the output will always be the input rect
   // since scrolling it can't change the location of content relative to the document, unlike an overflowing
   // element.
   virtual LayoutRect scrollIntoView(const LayoutRect& rectInContent,
                                     const ScrollAlignment& alignX,
                                     const ScrollAlignment& alignY,
                                     ScrollType = ProgrammaticScroll);
@@ skipping 46 matching lines @@
 
   // See Source/core/layout/README.md for an explanation of scroll origin.
   const IntPoint& scrollOrigin() const { return m_scrollOrigin; }
   bool scrollOriginChanged() const { return m_scrollOriginChanged; }
 
   // This is used to determine whether the incoming fractional scroll offset should
   // be truncated to integer. Current rule is that if preferCompositingToLCDTextEnabled()
   // is disabled (which is true on low-dpi device by default) we should do the truncation.
   // The justification is that non-composited elements using fractional scroll offsets
   // is causing too much nasty bugs but does not add too benefit on low-dpi devices.
+  // TODO(szager): Now that scroll offsets are floats everywhere, can we get rid of this?
   virtual bool shouldUseIntegerScrollOffset() const {
     return !RuntimeEnabledFeatures::fractionalScrollOffsetsEnabled();
   }
 
   virtual bool isActive() const = 0;
   virtual int scrollSize(ScrollbarOrientation) const = 0;
   void setScrollbarNeedsPaintInvalidation(ScrollbarOrientation);
   virtual bool isScrollCornerVisible() const = 0;
   virtual IntRect scrollCornerRect() const = 0;
   void setScrollCornerNeedsPaintInvalidation();
@@ skipping 19 matching lines @@
   }
   virtual IntPoint convertFromContainingWidgetToScrollbar(
       const Scrollbar& scrollbar,
       const IntPoint& parentPoint) const {
     return scrollbar.Widget::convertFromContainingWidget(parentPoint);
   }
 
   virtual Scrollbar* horizontalScrollbar() const { return nullptr; }
   virtual Scrollbar* verticalScrollbar() const { return nullptr; }
 
-  // scrollPosition is relative to the scrollOrigin. i.e. If the page is RTL
-  // then scrollPosition will be negative. By default, scrollPositionDouble()
-  // just call into scrollPosition(). Subclass can override scrollPositionDouble()
-  // to return floating point precision scrolloffset.
-  // FIXME: Remove scrollPosition(). crbug.com/414283.
-  virtual IntPoint scrollPosition() const = 0;
-  virtual DoublePoint scrollPositionDouble() const {
-    return DoublePoint(scrollPosition());
+  // scrollOffset is relative to the scrollOrigin. i.e. If the page is RTL
+  // then scrollOffset will be negative. By default, scrollOffset()
+  // just calls into scrollOffset(). Subclasses can override scrollOffset()
+  // to return floating point precision scroll offsets.
+  // FIXME: Remove scrollOffset(). crbug.com/414283.
+  virtual IntSize scrollOffsetInt() const = 0;

[bokan, 2016/10/02 19:47:51]

Is there a reason this Position->Offset renaming is in this patch rather than
the other one? (It's fine if it was just easier to split the patches, just
making sure I'm understanding)

[szager1, 2016/10/05 07:43:36]

The other patch had functional changes, and it was too confusing to combine
renames and functional changes in the same patch.

This patch enforces the convention that 'offset' is a distance from the scroll
origin and has type ScrollOffset; and 'position' is a point in the coordinate
system of the overflow rect and has type FloatPoint.  I think it's clearer to do
the renaming and type changes in a single patch, to demonstrate the new
convention.

[bokan, 2016/10/06 22:32:17]

Acknowledged.

+  virtual ScrollOffset scrollOffset() const {
+    return ScrollOffset(scrollOffsetInt());
   }
-  virtual IntPoint minimumScrollPosition() const = 0;
-  virtual DoublePoint minimumScrollPositionDouble() const {
-    return DoublePoint(minimumScrollPosition());
+  virtual IntSize minimumScrollOffsetInt() const = 0;
+  virtual ScrollOffset minimumScrollOffset() const {
+    return ScrollOffset(minimumScrollOffsetInt());
   }
-  virtual IntPoint maximumScrollPosition() const = 0;
-  virtual DoublePoint maximumScrollPositionDouble() const {
-    return DoublePoint(maximumScrollPosition());
+  virtual IntSize maximumScrollOffsetInt() const = 0;
+  virtual ScrollOffset maximumScrollOffset() const {
+    return ScrollOffset(maximumScrollOffsetInt());
   }
 
-  virtual DoubleRect visibleContentRectDouble(
-      IncludeScrollbarsInRect = ExcludeScrollbars) const;
   virtual IntRect visibleContentRect(
       IncludeScrollbarsInRect = ExcludeScrollbars) const;
   virtual int visibleHeight() const { return visibleContentRect().height(); }
   virtual int visibleWidth() const { return visibleContentRect().width(); }
   virtual IntSize contentsSize() const = 0;
   virtual IntPoint lastKnownMousePosition() const { return IntPoint(); }
 
   virtual bool shouldSuspendScrollAnimations() const { return true; }
   virtual void scrollbarStyleChanged() {}
   virtual void scrollbarVisibilityChanged() {}
   virtual bool scrollbarsCanBeActive() const = 0;
 
   // Returns the bounding box of this scrollable area, in the coordinate system of the enclosing scroll view.
   virtual IntRect scrollableAreaBoundingBox() const = 0;
 
   virtual bool scrollAnimatorEnabled() const { return false; }
 
   // NOTE: Only called from Internals for testing.
-  void updateScrollPositionFromInternals(const IntPoint&);
+  void updateScrollOffsetFromInternals(const IntSize&);
 
-  IntPoint clampScrollPosition(const IntPoint&) const;
-  DoublePoint clampScrollPosition(const DoublePoint&) const;
+  IntSize clampScrollOffset(const IntSize&) const;
+  ScrollOffset clampScrollOffset(const ScrollOffset&) const;
 
   // Let subclasses provide a way of asking for and servicing scroll
   // animations.
   virtual bool scheduleAnimation();
   virtual void serviceScrollAnimations(double monotonicTime);
   virtual void updateCompositorScrollAnimations();
   virtual void registerForAnimation() {}
   virtual void deregisterForAnimation() {}
 
   virtual bool usesCompositedScrolling() const { return false; }
   virtual bool shouldScrollOnMainThread() const;
 
   // Returns true if the GraphicsLayer tree needs to be rebuilt.
   virtual bool updateAfterCompositingChange() { return false; }
 
   virtual bool userInputScrollable(ScrollbarOrientation) const = 0;
   virtual bool shouldPlaceVerticalScrollbarOnLeft() const = 0;
 
   // Convenience functions
-  int scrollPosition(ScrollbarOrientation orientation) {
-    return orientation == HorizontalScrollbar ? scrollPosition().x()
-                                              : scrollPosition().y();
+  float scrollOffset(ScrollbarOrientation orientation) {
+    return orientation == HorizontalScrollbar ? scrollOffsetInt().width()
+                                              : scrollOffsetInt().height();
   }
-  int minimumScrollPosition(ScrollbarOrientation orientation) {
-    return orientation == HorizontalScrollbar ? minimumScrollPosition().x()
-                                              : minimumScrollPosition().y();
+  float minimumScrollOffset(ScrollbarOrientation orientation) {
+    return orientation == HorizontalScrollbar ? minimumScrollOffset().width()
+                                              : minimumScrollOffset().height();
   }
-  int maximumScrollPosition(ScrollbarOrientation orientation) {
-    return orientation == HorizontalScrollbar ? maximumScrollPosition().x()
-                                              : maximumScrollPosition().y();
+  float maximumScrollOffset(ScrollbarOrientation orientation) {
+    return orientation == HorizontalScrollbar ? maximumScrollOffset().width()
+                                              : maximumScrollOffset().height();
   }
-  int clampScrollPosition(ScrollbarOrientation orientation, int pos) {
-    return clampTo(pos, minimumScrollPosition(orientation),
-                   maximumScrollPosition(orientation));
+  float clampScrollOffset(ScrollbarOrientation orientation, float offset) {
+    return clampTo(offset, minimumScrollOffset(orientation),
+                   maximumScrollOffset(orientation));
   }
 
   virtual GraphicsLayer* layerForContainer() const;
   virtual GraphicsLayer* layerForScrolling() const { return 0; }
   virtual GraphicsLayer* layerForHorizontalScrollbar() const { return 0; }
   virtual GraphicsLayer* layerForVerticalScrollbar() const { return 0; }
   virtual GraphicsLayer* layerForScrollCorner() const { return 0; }
   bool hasLayerForHorizontalScrollbar() const;
   bool hasLayerForVerticalScrollbar() const;
   bool hasLayerForScrollCorner() const;
@@ skipping 14 matching lines @@
   virtual ScrollBehavior scrollBehaviorStyle() const {
     return ScrollBehaviorInstant;
   }
 
   // TODO(bokan): This is only used in FrameView to check scrollability but is
   // needed here to allow RootFrameViewport to preserve wheelHandler
   // semantics. Not sure why it's FrameView specific, it could probably be
   // generalized to other types of ScrollableAreas.
   virtual bool isScrollable() { return true; }
 
-  // TODO(bokan): FrameView::setScrollPosition uses updateScrollbars to scroll
+  // TODO(bokan): FrameView::setScrollOffset uses updateScrollbars to scroll
   // which bails out early if its already in updateScrollbars, the effect being
-  // that programmatic scrolls (i.e. setScrollPosition) are disabled when in
+  // that programmatic scrolls (i.e. setScrollOffset) are disabled when in
   // updateScrollbars. Expose this here to allow RootFrameViewport to match the
   // semantics for now but it should be cleaned up at the source.
   virtual bool isProgrammaticallyScrollable() { return true; }
 
   // Subtracts space occupied by this ScrollableArea's scrollbars.
   // Does nothing if overlay scrollbars are enabled.
   IntSize excludeScrollbars(const IntSize&) const;
 
   // Returns 0 if overlay scrollbars are enabled.
   int verticalScrollbarWidth() const;
   int horizontalScrollbarHeight() const;
 
   // Returns the widget associated with this ScrollableArea.
   virtual Widget* getWidget() { return nullptr; }
 
   virtual LayoutBox* layoutBox() const { return nullptr; }
 
   virtual bool isFrameView() const { return false; }
   virtual bool isPaintLayerScrollableArea() const { return false; }
   virtual bool isRootFrameViewport() const { return false; }
 
-  // Returns true if the scroller adjusts the scroll position to compensate
+  // Returns true if the scroller adjusts the scroll offset to compensate
   // for layout movements (bit.ly/scroll-anchoring).
   virtual bool shouldPerformScrollAnchoring() const { return false; }
 
   // Need to promptly let go of owned animator objects.
   EAGERLY_FINALIZE();
   DECLARE_VIRTUAL_TRACE();
 
   virtual void clearScrollAnimators();
 
   virtual ScrollAnchor* scrollAnchor() { return nullptr; }
 
  protected:
   ScrollableArea();
 
   ScrollbarOrientation scrollbarOrientationFromDirection(
       ScrollDirectionPhysical) const;
   float scrollStep(ScrollGranularity, ScrollbarOrientation) const;
 
   void setScrollOrigin(const IntPoint&);
   void resetScrollOriginChanged() { m_scrollOriginChanged = false; }
 
-  // Needed to let the animators call scrollPositionChanged.
+  // Needed to let the animators call scrollOffsetChanged.
   friend class ScrollAnimatorCompositorCoordinator;
-  void scrollPositionChanged(const DoublePoint&, ScrollType);
+  void scrollOffsetChanged(const ScrollOffset&, ScrollType);
 
   bool horizontalScrollbarNeedsPaintInvalidation() const {
     return m_horizontalScrollbarNeedsPaintInvalidation;
   }
   bool verticalScrollbarNeedsPaintInvalidation() const {
     return m_verticalScrollbarNeedsPaintInvalidation;
   }
   bool scrollCornerNeedsPaintInvalidation() const {
     return m_scrollCornerNeedsPaintInvalidation;
   }
   void clearNeedsPaintInvalidationForScrollControls() {
     m_horizontalScrollbarNeedsPaintInvalidation = false;
     m_verticalScrollbarNeedsPaintInvalidation = false;
     m_scrollCornerNeedsPaintInvalidation = false;
   }
 
  private:
-  void programmaticScrollHelper(const DoublePoint&, ScrollBehavior);
-  void userScrollHelper(const DoublePoint&, ScrollBehavior);
+  void programmaticScrollHelper(const ScrollOffset&, ScrollBehavior);
+  void userScrollHelper(const ScrollOffset&, ScrollBehavior);
 
   // This function should be overriden by subclasses to perform the actual scroll of the content.
-  virtual void updateScrollPosition(const DoublePoint&, ScrollType) = 0;
+  virtual void updateScrollOffset(const ScrollOffset&, ScrollType) = 0;
 
   virtual int lineStep(ScrollbarOrientation) const;
   virtual int pageStep(ScrollbarOrientation) const;
   virtual int documentStep(ScrollbarOrientation) const;
   virtual float pixelStep(ScrollbarOrientation) const;
 
   mutable Member<ScrollAnimatorBase> m_scrollAnimator;
   mutable Member<ProgrammaticScrollAnimator> m_programmaticScrollAnimator;
 
   unsigned m_scrollbarOverlayStyle : 2;  // ScrollbarOverlayStyle
@@ skipping 12 matching lines @@
   // vertical-lr / ltr            NO                      NO
   // vertical-lr / rtl            NO                      YES
   // vertical-rl / ltr            YES                     NO
   // vertical-rl / rtl            YES                     YES
   IntPoint m_scrollOrigin;
 };
 
 }  // namespace blink
 
 #endif  // ScrollableArea_h