Use float for scroll offset.

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 196 matching lines @@
    public:
     FreezeScrollbarsScope() { s_count++; }
     ~FreezeScrollbarsScope() { s_count--; }
 
     static bool scrollbarsAreFrozen() { return s_count; }
 
    private:
     static int s_count;
   };
 
-  // If a DelayScrollPositionClampScope object is alive, updateAfterLayout() will not
-  // clamp scroll positions to ensure they are in the valid range.  When
-  // the last DelayScrollPositionClampScope object is destructed, all PaintLayerScrollableArea's
-  // that delayed clamping their positions will immediately clamp them.
-  class DelayScrollPositionClampScope {
+  // If a DelayScrollOffsetClampScope object is alive, updateAfterLayout() will not
+  // clamp scroll offsets to ensure they are in the valid range.  When
+  // the last DelayScrollOffsetClampScope object is destructed, all PaintLayerScrollableArea's
+  // that delayed clamping their offsets will immediately clamp them.
+  class DelayScrollOffsetClampScope {
     STACK_ALLOCATED();
 
    public:
-    DelayScrollPositionClampScope();
-    ~DelayScrollPositionClampScope();
+    DelayScrollOffsetClampScope();
+    ~DelayScrollOffsetClampScope();
 
     static bool clampingIsDelayed() { return s_count; }
     static void setNeedsClamp(PaintLayerScrollableArea*);
 
    private:
     static void clampScrollableAreas();
 
     static int s_count;
     static PersistentHeapVector<Member<PaintLayerScrollableArea>>* s_needsClamp;
   };
@@ skipping 43 matching lines @@
                                                  const IntRect&) const override;
   IntRect convertFromContainingWidgetToScrollbar(const Scrollbar&,
                                                  const IntRect&) const override;
   IntPoint convertFromScrollbarToContainingWidget(
       const Scrollbar&,
       const IntPoint&) const override;
   IntPoint convertFromContainingWidgetToScrollbar(
       const Scrollbar&,
       const IntPoint&) const override;
   int scrollSize(ScrollbarOrientation) const override;
-  IntPoint scrollPosition() const override;
-  DoublePoint scrollPositionDouble() const override;
-  IntPoint minimumScrollPosition() const override;
-  IntPoint maximumScrollPosition() const override;
+  IntSize scrollOffsetInt() const override;
+  ScrollOffset scrollOffset() const override;
+  IntSize minimumScrollOffsetInt() const override;
+  IntSize maximumScrollOffsetInt() const override;
   IntRect visibleContentRect(
       IncludeScrollbarsInRect = ExcludeScrollbars) const override;
   int visibleHeight() const override;
   int visibleWidth() const override;
   IntSize contentsSize() const override;
   IntPoint lastKnownMousePosition() const override;
   bool scrollAnimatorEnabled() const override;
   bool shouldSuspendScrollAnimations() const override;
   bool scrollbarsCanBeActive() const override;
   void scrollbarVisibilityChanged() override;
   IntRect scrollableAreaBoundingBox() const override;
   void registerForAnimation() override;
   void deregisterForAnimation() override;
   bool userInputScrollable(ScrollbarOrientation) const override;
   bool shouldPlaceVerticalScrollbarOnLeft() const override;
   int pageStep(ScrollbarOrientation) const override;
   ScrollBehavior scrollBehaviorStyle() const override;
   CompositorAnimationTimeline* compositorAnimationTimeline() const override;
 
   // FIXME: We shouldn't allow access to m_overflowRect outside this class.
   LayoutRect overflowRect() const { return m_overflowRect; }
 
-  DoubleSize offsetFromOrigin() const {
-    return toDoubleSize(DoublePoint(scrollOrigin())) + m_scrollPosition;
+  FloatPoint absolutePosition() const {

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

Since scrollOrigin is a ScrollableArea concept, I think this method should be
declared there as well.

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

Done.

+    return FloatPoint(scrollOrigin()) + m_scrollOffset;
   }
-  void scrollToOffsetFromOrigin(
-      const DoubleSize& scrollOffset,
+  void scrollToAbsolutePosition(
+      const FloatPoint& position,
       ScrollBehavior scrollBehavior = ScrollBehaviorInstant,
       ScrollType scrollType = ProgrammaticScroll) {
-    setScrollPosition(-scrollOrigin() + scrollOffset, scrollType,
-                      scrollBehavior);
+    setScrollOffset(position - scrollOrigin(), scrollType, scrollBehavior);
   }
 
-  // This will set the scroll position without clamping, and it will do all post-update
-  // work even if the scroll position didn't change.
-  void setScrollPositionUnconditionally(const DoublePoint&,
-                                        ScrollType = ProgrammaticScroll);
+  // This will set the scroll offset without clamping, and it will do all post-update
+  // work even if the scroll offset didn't change.
+  void setScrollOffsetUnconditionally(const ScrollOffset&,
+                                      ScrollType = ProgrammaticScroll);
 
   // TODO(szager): Actually run these after all of layout is finished.  Currently, they
   // run at the end of box()'es layout (or after all flexbox layout has finished) but while
   // document layout is still happening.
   void updateAfterLayout();
-  void clampScrollPositionsAfterLayout();
+  void clampScrollOffsetsAfterLayout();
 
   void updateAfterStyleChange(const ComputedStyle*);
   void updateAfterOverflowRecalc();
 
   bool updateAfterCompositingChange() override;
 
   bool hasScrollbar() const {
     return hasHorizontalScrollbar() || hasVerticalScrollbar();
   }
   bool hasOverflowControls() const {
@@ skipping 26 matching lines @@
 
   // isPointInResizeControl() is used for testing if a pointer/touch position is in the resize control
   // area.
   bool isPointInResizeControl(const IntPoint& absolutePoint,
                               ResizerHitTestType) const;
   bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
 
   bool hitTestResizerInFragments(const PaintLayerFragments&,
                                  const HitTestLocation&) const;
 
-  // Returns the new position, after scrolling, of the given rect in absolute
+  // Returns the new offset, after scrolling, of the given rect in absolute
   // coordinates, clipped by the parent's client rect.
   LayoutRect scrollIntoView(const LayoutRect&,
                             const ScrollAlignment& alignX,
                             const ScrollAlignment& alignY,
                             ScrollType = ProgrammaticScroll) override;
 
   // Returns true if scrollable area is in the FrameView's collection of scrollable areas. This can
   // only happen if we're scrollable, visible to hit test, and do in fact overflow. This means that
   // 'overflow: hidden' or 'pointer-events: none' layers never get added to the FrameView's collection.
   bool scrollsOverflow() const { return m_scrollsOverflow; }
@@ skipping 40 matching lines @@
   LayoutBox* layoutBox() const override { return &box(); }
 
   bool shouldRebuildHorizontalScrollbarLayer() const {
     return m_rebuildHorizontalScrollbarLayer;
   }
   bool shouldRebuildVerticalScrollbarLayer() const {
     return m_rebuildVerticalScrollbarLayer;
   }
   void resetRebuildScrollbarLayerFlags();
 
-  // Did DelayScrollPositionClampScope prevent us from running clampScrollPositionsAfterLayout()
+  // Did DelayScrollOffsetClampScope prevent us from running clampScrollOffsetsAfterLayout()
   // in updateAfterLayout()?
-  bool needsScrollPositionClamp() const { return m_needsScrollPositionClamp; }
-  void setNeedsScrollPositionClamp(bool val) {
-    m_needsScrollPositionClamp = val;
-  }
+  bool needsScrollOffsetClamp() const { return m_needsScrollOffsetClamp; }
+  void setNeedsScrollOffsetClamp(bool val) { m_needsScrollOffsetClamp = val; }
 
   // Did PreventRelayoutScope prevent us from running re-layout due to adding/subtracting
   // scrollbars in updateAfterLayout()?
   bool needsRelayout() const { return m_needsRelayout; }
   void setNeedsRelayout(bool val) { m_needsRelayout = val; }
 
   // Were we laid out with a horizontal scrollbar at the time we were marked as
   // needing relayout by PreventRelayoutScope?
   bool hadHorizontalScrollbarBeforeRelayout() const {
     return m_hadHorizontalScrollbarBeforeRelayout;
@@ skipping 29 matching lines @@
   bool hasVerticalOverflow() const;
   bool hasScrollableHorizontalOverflow() const;
   bool hasScrollableVerticalOverflow() const;
   bool visualViewportSuppliesScrollbars() const;
 
   bool needsScrollbarReconstruction() const;
 
   void updateScrollOrigin();
   void updateScrollDimensions();
 
-  void updateScrollPosition(const DoublePoint&, ScrollType) override;
+  void updateScrollOffset(const ScrollOffset&, ScrollType) override;
 
   int verticalScrollbarStart(int minX, int maxX) const;
   int horizontalScrollbarStart(int minX) const;
   IntSize scrollbarOffset(const Scrollbar&) const;
 
   void setHasHorizontalScrollbar(bool hasScrollbar);
   void setHasVerticalScrollbar(bool hasScrollbar);
 
   void updateScrollCornerStyle();
 
@@ skipping 27 matching lines @@
   // FIXME: once cc can handle composited scrolling with clip paths, we will
   // no longer need this bit.
   unsigned m_needsCompositedScrolling : 1;
 
   // Set to indicate that a scrollbar layer, if present, needs to be rebuilt
   // in the next compositing update because the underlying blink::Scrollbar
   // instance has been reconstructed.
   unsigned m_rebuildHorizontalScrollbarLayer : 1;
   unsigned m_rebuildVerticalScrollbarLayer : 1;
 
-  unsigned m_needsScrollPositionClamp : 1;
+  unsigned m_needsScrollOffsetClamp : 1;
   unsigned m_needsRelayout : 1;
   unsigned m_hadHorizontalScrollbarBeforeRelayout : 1;
   unsigned m_hadVerticalScrollbarBeforeRelayout : 1;
 
   // The width/height of our scrolled area.
   // This is OverflowModel's layout overflow translated to physical
   // coordinates. See OverflowModel for the different overflow and
   // LayoutBoxModelObject for the coordinate systems.
   LayoutRect m_overflowRect;
 
   // ScrollbarManager holds the Scrollbar instances.
   ScrollbarManager m_scrollbarManager;
 
-  // This is the absolute scroll position, *not* relative to m_scrollOrigin.
-  DoubleSize m_scrollPosition;
+  // This is the offset from the beginning of content flow.
+  ScrollOffset m_scrollOffset;
 
   IntPoint m_cachedOverlayScrollbarOffset;
 
   // LayoutObject to hold our custom scroll corner.
   LayoutScrollbarPart* m_scrollCorner;
 
   // LayoutObject to hold our custom resizer.
   LayoutScrollbarPart* m_resizer;
 
   ScrollAnchor m_scrollAnchor;
 
   std::unique_ptr<PaintLayerScrollableAreaRareData> m_rareData;
 
 #if ENABLE(ASSERT)
   bool m_hasBeenDisposed;
 #endif
 };
 
 DEFINE_TYPE_CASTS(PaintLayerScrollableArea,
                   ScrollableArea,
                   scrollableArea,
                   scrollableArea->isPaintLayerScrollableArea(),
                   scrollableArea.isPaintLayerScrollableArea());
 
 }  // namespace blink
 
 #endif  // LayerScrollableArea_h