Use float for scroll offset.

third_party/WebKit/Source/core/frame/FrameView.h

 /*
    Copyright (C) 1997 Martin Jones (mjones@kde.org)
              (C) 1998 Waldo Bastian (bastian@kde.org)
              (C) 1998, 1999 Torben Weis (weis@kde.org)
              (C) 1999 Lars Knoll (knoll@kde.org)
              (C) 1999 Antti Koivisto (koivisto@kde.org)
    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
@@ skipping 176 matching lines @@
   void adjustViewSize();
   void adjustViewSizeAndLayout();
 
   // Scale used to convert incoming input events.
   float inputEventsScaleFactor() const;
 
   // Offset used to convert incoming input events while emulating device metics.
   IntSize inputEventsOffsetForEmulation() const;
   void setInputEventsTransformForEmulation(const IntSize&, float);
 
-  void setScrollPosition(const DoublePoint&,
-                         ScrollType,
-                         ScrollBehavior = ScrollBehaviorInstant) override;
   void didChangeScrollOffset();
-
   void didUpdateElasticOverscroll();
 
   void viewportSizeChanged(bool widthChanged, bool heightChanged);
 
   AtomicString mediaType() const;
   void setMediaType(const AtomicString&);
   void adjustMediaTypeForPrinting(bool printing);
 
   WebDisplayMode displayMode() { return m_displayMode; }
   void setDisplayMode(WebDisplayMode);
@@ skipping 73 matching lines @@
   void disableAutoSizeMode();
 
   void forceLayoutForPagination(const FloatSize& pageSize,
                                 const FloatSize& originalPageSize,
                                 float maximumShrinkFactor);
 
   enum UrlFragmentBehavior { UrlFragmentScroll, UrlFragmentDontScroll };
   // Updates the fragment anchor element based on URL's fragment identifier.
   // Updates corresponding ':target' CSS pseudo class on the anchor element.
   // If |UrlFragmentScroll| is passed in then makes the anchor element
-  // focused and also visible by scrolling to it. The scroll position is
+  // focused and also visible by scrolling to it. The scroll offset is
   // maintained during the frame loading process.
   void processUrlFragment(const KURL&, UrlFragmentBehavior = UrlFragmentScroll);
   void clearFragmentAnchor();
 
   // Methods to convert points and rects between the coordinate space of the layoutObject, and this view.
   IntRect convertFromLayoutObject(const LayoutObject&, const IntRect&) const;
   IntRect convertToLayoutObject(const LayoutObject&, const IntRect&) const;
   IntPoint convertFromLayoutObject(const LayoutObject&, const IntPoint&) const;
   IntPoint convertToLayoutObject(const LayoutObject&, const IntPoint&) const;
 
@@ skipping 88 matching lines @@
   void invalidatePaintForTickmarks();
 
   // Since the compositor can resize the viewport due to top controls and
   // commit scroll offsets before a WebView::resize occurs, we need to adjust
   // our scroll extents to prevent clamping the scroll offsets.
   void setTopControlsViewportAdjustment(float);
   IntSize topControlsSize() const {
     return IntSize(0, ceilf(m_topControlsViewportAdjustment));
   }
 
-  IntPoint maximumScrollPosition() const override;
+  IntSize maximumScrollOffsetInt() const override;
 
   // ScrollableArea interface
   void getTickmarks(Vector<IntRect>&) const override;
   IntRect scrollableAreaBoundingBox() const override;
   bool scrollAnimatorEnabled() const override;
   bool usesCompositedScrolling() const override;
   bool shouldScrollOnMainThread() const override;
   GraphicsLayer* layerForScrolling() const override;
   GraphicsLayer* layerForHorizontalScrollbar() const override;
   GraphicsLayer* layerForVerticalScrollbar() const override;
@@ skipping 90 matching lines @@
   // (e.g. DevTool's viewport override).
   void clipPaintRect(FloatRect*) const;
 
   // Functions for getting/setting the size of the document contained inside the FrameView (as an IntSize or as individual width and height
   // values).
   IntSize contentsSize() const
       override;  // Always at least as big as the visibleWidth()/visibleHeight().
   int contentsWidth() const { return contentsSize().width(); }
   int contentsHeight() const { return contentsSize().height(); }
 
-  // Functions for querying the current scrolled position (both as a point, a size, or as individual X and Y values).
-  // Be careful in using the Double version scrollPositionDouble() and scrollOffsetDouble(). They are meant to be
-  // used to communicate the fractional scroll position/offset with chromium compositor which can do sub-pixel positioning.
-  // Do not call these if the scroll position/offset is used in Blink for positioning. Use the Int version instead.
-  IntPoint scrollPosition() const override {
-    return visibleContentRect().location();
+  // Functions for querying the current scrolled offset (both as a point, a size, or as individual X and Y values).
+  // Be careful in using the Float version scrollOffset() and scrollOffset(). They are meant to be
+  // used to communicate the fractional scroll offset with chromium compositor which can do sub-pixel positioning.
+  // Do not call these if the scroll offset is used in Blink for positioning. Use the Int version instead.
+  IntSize scrollOffsetInt() const override {
+    return toIntSize(visibleContentRect().location());
   }
-  DoublePoint scrollPositionDouble() const override { return m_scrollPosition; }
-  IntSize scrollOffset() const {
-    return toIntSize(visibleContentRect().location());
-  }  // Gets the scrolled position as an IntSize. Convenient for adding to other sizes.
-  DoubleSize scrollOffsetDouble() const {
-    return DoubleSize(m_scrollPosition.x(), m_scrollPosition.y());
-  }
-  DoubleSize pendingScrollDelta() const { return m_pendingScrollDelta; }
-  IntPoint minimumScrollPosition()
-      const override;  // The minimum position we can be scrolled to.
-  int scrollX() const { return scrollPosition().x(); }
-  int scrollY() const { return scrollPosition().y(); }
+  ScrollOffset scrollOffset() const override { return m_scrollOffset; }
+  ScrollOffset pendingScrollDelta() const { return m_pendingScrollDelta; }
+  IntSize minimumScrollOffsetInt()
+      const override;  // The minimum offset we can be scrolled to.
+  int scrollX() const { return scrollOffsetInt().width(); }
+  int scrollY() const { return scrollOffsetInt().height(); }
 
   // Scroll the actual contents of the view (either blitting or invalidating as needed).
   void scrollContents(const IntSize& scrollDelta);
 
   // This gives us a means of blocking updating our scrollbars until the first layout has occurred.
   void setScrollbarsSuppressed(bool suppressed) {
     m_scrollbarsSuppressed = suppressed;
   }
   bool scrollbarsSuppressed() const { return m_scrollbarsSuppressed; }
 
@@ skipping 213 matching lines @@
    private:
     AutoReset<bool> m_scope;
   };
 
   // Only for LayoutPart to traverse into sub frames during paint invalidation.
   void invalidateTreeIfNeeded(const PaintInvalidationState&);
 
  private:
   explicit FrameView(LocalFrame*);
 
-  void updateScrollPosition(const DoublePoint&, ScrollType) override;
+  void updateScrollOffset(const ScrollOffset&, ScrollType) override;
 
   void updateLifecyclePhasesInternal(
       DocumentLifecycle::LifecycleState targetState);
 
   void invalidateTreeIfNeededRecursive();
   void scrollContentsIfNeededRecursive();
   void updateStyleAndLayoutIfNeededRecursive();
   void updatePaintProperties();
   void synchronizedPaint();
   void synchronizedPaintRecursively(GraphicsLayer*);
 
   void updateStyleAndLayoutIfNeededRecursiveInternal();
   void invalidateTreeIfNeededRecursiveInternal();
 
   void pushPaintArtifactToCompositor();
 
   void reset();
   void init();
 
   void clearLayoutSubtreeRootsAndMarkContainingBlocks();
 
-  // Called when our frame rect changes (or the rect/scroll position of an ancestor changes).
+  // Called when our frame rect changes (or the rect/scroll offset of an ancestor changes).
   void frameRectsChanged() override;
 
   bool contentsInCompositedLayer() const;
 
   void calculateScrollbarModesFromOverflowStyle(const ComputedStyle*,
                                                 ScrollbarMode& hMode,
                                                 ScrollbarMode& vMode);
 
   void updateCounters();
   void forceLayoutParentViewIfNeeded();
@@ skipping 24 matching lines @@
   void scheduleUpdateWidgetsIfNecessary();
   void updateWidgetsTimerFired(TimerBase*);
   bool updateWidgets();
 
   bool processUrlFragmentHelper(const String&, UrlFragmentBehavior);
   void setFragmentAnchor(Node*);
   void scrollToFragmentAnchor();
   void didScrollTimerFired(TimerBase*);
 
   void updateLayersAndCompositingAfterScrollIfNeeded(
-      const DoubleSize& scrollDelta);
+      const ScrollOffset& scrollDelta);
 
   static bool computeCompositedSelection(LocalFrame&, CompositedSelection&);
   void updateCompositedSelectionIfNeeded();
 
   // Returns true if the FrameView's own scrollbars overlay its content when visible.
   bool hasOverlayScrollbars() const;
 
   // Returns true if the frame should use custom scrollbars. If true, one of
   // either |customScrollbarElement| or |customScrollbarFrame| will be set to
   // the element or frame which owns the scrollbar with the other set to null.
   bool shouldUseCustomScrollbars(Element*& customScrollbarElement,
                                  LocalFrame*& customScrollbarFrame) const;
 
   // Returns true if a scrollbar needs to go from native -> custom or vice versa.
   bool needsScrollbarReconstruction() const;
 
   bool shouldIgnoreOverflowHidden() const;
 
   void updateScrollCorner();
 
   AXObjectCache* axObjectCache() const;
 
   void setLayoutSizeInternal(const IntSize&);
 
   bool adjustScrollbarExistence(ComputeScrollbarExistenceOption = FirstPass);
   void adjustScrollbarOpacity();
-  void adjustScrollPositionFromUpdateScrollbars();
+  void adjustScrollOffsetFromUpdateScrollbars();
   bool visualViewportSuppliesScrollbars() const;
 
   bool isFrameViewScrollbar(const Widget* child) const {
     return horizontalScrollbar() == child || verticalScrollbar() == child;
   }
 
   ScrollingCoordinator* scrollingCoordinator() const;
 
   void prepareLayoutAnalyzer();
   std::unique_ptr<TracedValue> analyzerCounters();
@@ skipping 109 matching lines @@
   Member<Scrollbar> m_horizontalScrollbar;
   Member<Scrollbar> m_verticalScrollbar;
   ScrollbarMode m_horizontalScrollbarMode;
   ScrollbarMode m_verticalScrollbarMode;
 
   bool m_horizontalScrollbarLock;
   bool m_verticalScrollbarLock;
 
   ChildrenWidgetSet m_children;
 
-  DoubleSize m_pendingScrollDelta;
-  DoublePoint m_scrollPosition;
+  ScrollOffset m_pendingScrollDelta;
+  ScrollOffset m_scrollOffset;
   IntSize m_contentsSize;
 
   int m_scrollbarsAvoidingResizer;
   bool m_scrollbarsSuppressed;
 
   bool m_inUpdateScrollbars;
 
   std::unique_ptr<LayoutAnalyzer> m_analyzer;
 
   // Mark if something has changed in the mapping from Frame to GraphicsLayer
@@ skipping 84 matching lines @@
                   widget.isFrameView());
 DEFINE_TYPE_CASTS(FrameView,
                   ScrollableArea,
                   scrollableArea,
                   scrollableArea->isFrameView(),
                   scrollableArea.isFrameView());
 
 }  // namespace blink
 
 #endif  // FrameView_h