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 95 matching lines @@
       m_scrollAnchor(this)
 #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())
+    m_scrollPosition = element->savedLayerScrollOffset();
+    if (!m_scrollPosition.isZero()) {
       scrollAnimator().setCurrentPosition(
-          FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
+          FloatPoint(m_scrollPosition.width(), m_scrollPosition.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));
+          flooredIntSize(m_scrollPosition));
+    }
   }
 
   if (LocalFrame* frame = box().frame()) {
     if (FrameView* frameView = frame->view())
       frameView->removeResizerArea(box());
   }
 
   if (RootScrollerController* controller =
           box().document().rootScrollerController())
     controller->didDisposePaintLayerScrollableArea(*this);
@@ skipping 183 matching lines @@
   return point;
 }
 
 int PaintLayerScrollableArea::scrollSize(
     ScrollbarOrientation orientation) const {
   IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
   return (orientation == HorizontalScrollbar) ? scrollDimensions.width()
                                               : scrollDimensions.height();
 }
 
-void PaintLayerScrollableArea::setScrollOffset(
-    const DoublePoint& newScrollOffset,
+void PaintLayerScrollableArea::updateScrollPosition(
+    const DoublePoint& newPosition,
     ScrollType scrollType) {
-  if (scrollOffset() == toDoubleSize(newScrollOffset))
+  if (scrollPositionDouble() == newPosition)
     return;
 
-  DoubleSize scrollDelta = scrollOffset() - toDoubleSize(newScrollOffset);
-  m_scrollOffset = toDoubleSize(newScrollOffset);
+  DoubleSize scrollDelta = scrollPositionDouble() - newPosition;
+  m_scrollPosition = toDoubleSize(newPosition);
 
   LocalFrame* frame = box().frame();
   ASSERT(frame);
 
   FrameView* frameView = box().frameView();
 
   TRACE_EVENT1("devtools.timeline", "ScrollLayer", "data",
                InspectorScrollLayerEvent::data(&box()));
 
   // FIXME(420741): Resolve circular dependency between scroll offset and
@@ skipping 73 matching lines @@
   // All scrolls clear the fragment anchor.
   frameView->clearFragmentAnchor();
 
   // Clear the scroll anchor, unless it is the reason for this scroll.
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
       scrollType != AnchoringScroll)
     scrollAnchor()->clear();
 }
 
 IntPoint PaintLayerScrollableArea::scrollPosition() const {
-  return IntPoint(flooredIntSize(m_scrollOffset));
+  return IntPoint(flooredIntSize(m_scrollPosition));
 }
 
 DoublePoint PaintLayerScrollableArea::scrollPositionDouble() const {
-  return DoublePoint(m_scrollOffset);
+  return DoublePoint(m_scrollPosition);
 }
 
 IntPoint PaintLayerScrollableArea::minimumScrollPosition() const {
   return -scrollOrigin();
 }
 
 IntPoint PaintLayerScrollableArea::maximumScrollPosition() const {
   IntSize contentSize;
   IntSize visibleSize;
   if (box().hasOverflowClip()) {
@@ skipping 18 matching lines @@
     verticalScrollbarWidth =
         (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
             ? verticalScrollbar()->width()
             : 0;
     horizontalScrollbarHeight =
         (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
             ? horizontalScrollbar()->height()
             : 0;
   }
 
+  // TODO(szager): Handle fractional scroll offsets correctly.
   return IntRect(
-      IntPoint(scrollXOffset(), scrollYOffset()),
+      IntPoint(flooredIntSize(offsetFromOrigin())),
       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 141 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())
+  if (scrollOriginChanged())
+    setScrollPositionUnconditionally(clamped);
+  else if (clamped != scrollPositionDouble())
     ScrollableArea::setScrollPosition(clamped, ProgrammaticScroll);
 
   setNeedsScrollPositionClamp(false);
   resetScrollOriginChanged();
   m_scrollbarManager.destroyDetachedScrollbars();
 }
 
 bool PaintLayerScrollableArea::shouldPerformScrollAnchoring() const {
   return RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
          m_scrollAnchor.hasScroller() &&
@@ skipping 732 matching lines @@
   LayoutRect localExposeRect(
       box()
           .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())
+  DoublePoint oldScrollPosition = scrollPositionDouble();
+  DoublePoint newScrollPosition =
+      clampScrollPosition(oldScrollPosition + roundedIntSize(r.location()));
+  if (newScrollPosition == oldScrollPosition)
     return LayoutRect(
         box()
             .localToAbsoluteQuad(FloatQuad(FloatRect(intersection(
                                      layerBounds, localExposeRect))),
                                  UseTransforms)
             .boundingBox());
 
-  DoubleSize oldScrollOffset = adjustedScrollOffset();
-  scrollToPosition(clampedScrollPosition, ScrollOffsetUnclamped,
-                   ScrollBehaviorInstant, scrollType);
-  DoubleSize scrollOffsetDifference = adjustedScrollOffset() - oldScrollOffset;
+  setScrollPosition(newScrollPosition, scrollType, ScrollBehaviorInstant);
+  DoubleSize scrollOffsetDifference =
+      scrollPositionDouble() - oldScrollPosition;
   localExposeRect.move(-LayoutSize(scrollOffsetDifference));
   return LayoutRect(
       box()
           .localToAbsoluteQuad(
               FloatQuad(FloatRect(intersection(layerBounds, localExposeRect))),
               UseTransforms)
           .boundingBox());
 }
 
 void PaintLayerScrollableArea::updateScrollableAreaSet(bool hasOverflow) {
@@ skipping 364 matching lines @@
 
 void PaintLayerScrollableArea::DelayScrollPositionClampScope::
     clampScrollableAreas() {
   for (auto& scrollableArea : *s_needsClamp)
     scrollableArea->clampScrollPositionsAfterLayout();
   delete s_needsClamp;
   s_needsClamp = nullptr;
 }
 
 }  // namespace blink