Refactor ScrollableArea::setScrollPosition.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 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@gmail.com>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 96 matching lines @@
 #if ENABLE(ASSERT)
       ,
       m_hasBeenDisposed(false)
 #endif
 {
   Node* node = box().node();
   if (node && node->isElementNode()) {
     // We save and restore only the scrollOffset as the other scroll values are recalculated.
     Element* element = toElement(node);
     m_scrollOffset = element->savedLayerScrollOffset();
-    if (!m_scrollOffset.isZero())
+    if (!m_scrollOffset.isZero()) {
       scrollAnimator().setCurrentPosition(
           FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
+    }
     element->setSavedLayerScrollOffset(IntSize());
   }
   updateResizerAreaSet();
 }
 
 PaintLayerScrollableArea::~PaintLayerScrollableArea() {
   ASSERT(m_hasBeenDisposed);
 }
 
 void PaintLayerScrollableArea::dispose() {
@@ skipping 11 matching lines @@
 
   if (box().frame() && box().frame()->page()) {
     if (ScrollingCoordinator* scrollingCoordinator =
             box().frame()->page()->scrollingCoordinator())
       scrollingCoordinator->willDestroyScrollableArea(this);
   }
 
   if (!box().documentBeingDestroyed()) {
     Node* node = box().node();
     // FIXME: Make setSavedLayerScrollOffset take DoubleSize. crbug.com/414283.
-    if (node && node->isElementNode())
+    if (node && node->isElementNode()) {
       toElement(node)->setSavedLayerScrollOffset(
           flooredIntSize(m_scrollOffset));
+    }
   }
 
   if (LocalFrame* frame = box().frame()) {
     if (FrameView* frameView = frame->view())
       frameView->removeResizerArea(box());
   }
 
   if (RootScrollerController* controller =
           box().document().rootScrollerController())
     controller->didDisposePaintLayerScrollableArea(*this);
@@ skipping 327 matching lines @@
     verticalScrollbarWidth =
         (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
             ? verticalScrollbar()->scrollbarThickness()
             : 0;
     horizontalScrollbarHeight =
         (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
             ? horizontalScrollbar()->scrollbarThickness()
             : 0;
   }
 
+  // TODO(szager): Handle fractional scroll offsets correctly.
   return IntRect(
-      IntPoint(scrollXOffset(), scrollYOffset()),
+      IntPoint(flooredIntSize(adjustedScrollOffset())),
       IntSize(max(0, layer()->size().width() - verticalScrollbarWidth),
               max(0, layer()->size().height() - horizontalScrollbarHeight)));
 }
 
 int PaintLayerScrollableArea::visibleHeight() const {
   return layer()->size().height();
 }
 
 int PaintLayerScrollableArea::visibleWidth() const {
   return layer()->size().width();
@@ skipping 115 matching lines @@
   setScrollOrigin(flooredIntPoint(-scrollableOverflow) +
                   box().originAdjustmentForScrollbars());
 }
 
 void PaintLayerScrollableArea::updateScrollDimensions() {
   m_overflowRect = box().layoutOverflowRect();
   box().flipForWritingMode(m_overflowRect);
   updateScrollOrigin();
 }
 
-void PaintLayerScrollableArea::scrollToPosition(
-    const DoublePoint& scrollPosition,
-    ScrollOffsetClamping clamp,
-    ScrollBehavior scrollBehavior,
+void PaintLayerScrollableArea::setScrollPositionUnconditionally(
+    const DoublePoint& position,
     ScrollType scrollType) {
-  DoublePoint newScrollPosition = clamp == ScrollOffsetClamped
-                                      ? clampScrollPosition(scrollPosition)
-                                      : scrollPosition;
-  if (newScrollPosition != scrollPositionDouble())
-    ScrollableArea::setScrollPosition(newScrollPosition, scrollType,
-                                      scrollBehavior);
+  cancelScrollAnimation();
+  scrollPositionChanged(position, scrollType);
 }
 
 void PaintLayerScrollableArea::updateAfterLayout() {
   ASSERT(box().hasOverflowClip());
 
   bool relayoutIsPrevented = PreventRelayoutScope::relayoutIsPrevented();
   bool scrollbarsAreFrozen =
       m_inOverflowRelayout || FreezeScrollbarsScope::scrollbarsAreFrozen();
 
   if (needsScrollbarReconstruction()) {
@@ skipping 140 matching lines @@
 
   if (DelayScrollPositionClampScope::clampingIsDelayed()) {
     DelayScrollPositionClampScope::setNeedsClamp(this);
     return;
   }
 
   // Restore before clamping because clamping clears the scroll anchor.
   if (shouldPerformScrollAnchoring())
     m_scrollAnchor.restore();
 
-  DoublePoint clamped = clampScrollPosition(scrollPositionDouble());
-  if (clamped != scrollPositionDouble() || scrollOriginChanged())
-    ScrollableArea::setScrollPosition(clamped, ProgrammaticScroll);
+  if (scrollOriginChanged()) {
+    setScrollPositionUnconditionally(
+        clampScrollPosition(scrollPositionDouble()));
+  } else {
+    ScrollableArea::setScrollPosition(scrollPositionDouble(),
+                                      ProgrammaticScroll);
+  }
 
   setNeedsScrollPositionClamp(false);
   resetScrollOriginChanged();
   m_scrollbarManager.destroyDetachedScrollbars();
 }
 
 bool PaintLayerScrollableArea::shouldPerformScrollAnchoring() const {
   return RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
          m_scrollAnchor.hasScroller() &&
          layoutBox()->style()->overflowAnchor() != AnchorNone;
@@ skipping 734 matching lines @@
           .absoluteToLocalQuad(FloatQuad(FloatRect(rect)), UseTransforms)
           .boundingBox());
   localExposeRect.move(-box().borderLeft(), -box().borderTop());
   LayoutRect layerBounds(LayoutPoint(),
                          LayoutSize(box().clientWidth(), box().clientHeight()));
   LayoutRect r = ScrollAlignment::getRectToExpose(layerBounds, localExposeRect,
                                                   alignX, alignY);
 
   DoublePoint clampedScrollPosition = clampScrollPosition(
       scrollPositionDouble() + roundedIntSize(r.location()));
-  if (clampedScrollPosition == scrollPositionDouble())
+  if (clampedScrollPosition == scrollPositionDouble()) {
     return LayoutRect(
         box()
             .localToAbsoluteQuad(FloatQuad(FloatRect(intersection(
                                      layerBounds, localExposeRect))),
                                  UseTransforms)
             .boundingBox());
+  }
 
   DoubleSize oldScrollOffset = adjustedScrollOffset();
-  scrollToPosition(clampedScrollPosition, ScrollOffsetUnclamped,
-                   ScrollBehaviorInstant, scrollType);
+  setScrollPosition(clampedScrollPosition, scrollType, ScrollBehaviorInstant);
   DoubleSize scrollOffsetDifference = adjustedScrollOffset() - oldScrollOffset;
   localExposeRect.move(-LayoutSize(scrollOffsetDifference));
   return LayoutRect(
       box()
           .localToAbsoluteQuad(
               FloatQuad(FloatRect(intersection(layerBounds, localExposeRect))),
               UseTransforms)
           .boundingBox());
 }
 
@@ skipping 365 matching lines @@
 
 void PaintLayerScrollableArea::DelayScrollPositionClampScope::
     clampScrollableAreas() {
   for (auto& scrollableArea : *s_needsClamp)
     scrollableArea->clampScrollPositionsAfterLayout();
   delete s_needsClamp;
   s_needsClamp = nullptr;
 }
 
 }  // namespace blink