Preserve fractional scroll offset for JS scrolling API

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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 391 matching lines @@
 
 void RenderBox::setScrollTop(LayoutUnit newTop)
 {
     // Hits in compositing/overflow/do-not-assert-on-invisible-composited-layers.html
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
         layer()->scrollableArea()->scrollToYOffset(newTop, ScrollOffsetClamped);
 }
 
-void RenderBox::scrollToOffset(const IntSize& offset)
+void RenderBox::scrollToOffset(const DoubleSize& offset)
 {
     ASSERT(hasOverflowClip());
 
     // This doesn't hit in any tests, but since the equivalent code in setScrollTop
     // does, presumably this code does as well.
     DisableCompositingQueryAsserts disabler;
     layer()->scrollableArea()->scrollToOffset(offset, ScrollOffsetClamped);
 }
 
 static inline bool frameElementAndViewPermitScroll(HTMLFrameElementBase* frameElementBase, FrameView* frameView)
@@ skipping 35 matching lines @@
     } else if (!parentBox && canBeProgramaticallyScrolled()) {
         if (FrameView* frameView = this->frameView()) {
             HTMLFrameOwnerElement* ownerElement = document().ownerElement();
 
             if (ownerElement && ownerElement->renderer()) {
                 HTMLFrameElementBase* frameElementBase = isHTMLFrameElementBase(*ownerElement) ? toHTMLFrameElementBase(ownerElement) : 0;
                 if (frameElementAndViewPermitScroll(frameElementBase, frameView)) {
                     LayoutRect viewRect = frameView->visibleContentRect();
                     LayoutRect exposeRect = ScrollAlignment::getRectToExpose(viewRect, rect, alignX, alignY);
 
-                    int xOffset = roundToInt(exposeRect.x());
-                    int yOffset = roundToInt(exposeRect.y());
+                    double xOffset = exposeRect.x();
+                    double yOffset = exposeRect.y();
                     // Adjust offsets if they're outside of the allowable range.
-                    xOffset = std::max(0, std::min(frameView->contentsWidth(), xOffset));
-                    yOffset = std::max(0, std::min(frameView->contentsHeight(), yOffset));
+                    xOffset = std::max(0.0, std::min(static_cast<double>(frameView->contentsWidth()), xOffset));

[Rick Byers, 2014/10/02 21:44:06]

Do you really need this static_cast here?  I would have expected implicit
conversion to work.  does std::min<double>(a,b) work instead of adding a cast?

[Yufeng Shen (Slow to review), 2014/10/02 23:34:34]

min<double>(a,b) works but not implicit conversion.

+                    yOffset = std::max(0.0, std::min(static_cast<double>(frameView->contentsHeight()), yOffset));
 
-                    frameView->setScrollPosition(IntPoint(xOffset, yOffset));
+                    frameView->setScrollPosition(DoublePoint(xOffset, yOffset));
                     if (frameView->safeToPropagateScrollToParent()) {
                         parentBox = ownerElement->renderer()->enclosingBox();
                         // FIXME: This doesn't correctly convert the rect to
                         // absolute coordinates in the parent.
                         newRect.setX(rect.x() - frameView->scrollX() + frameView->x());
                         newRect.setY(rect.y() - frameView->scrollY() + frameView->y());
                     } else {
                         parentBox = 0;
                     }
                 }
             } else {
                 if (frame()->settings()->pinchVirtualViewportEnabled()) {
                     PinchViewport& pinchViewport = frame()->page()->frameHost().pinchViewport();
                     LayoutRect r = ScrollAlignment::getRectToExpose(LayoutRect(pinchViewport.visibleRectInDocument()), rect, alignX, alignY);
                     pinchViewport.scrollIntoView(r);
                 } else {
                     LayoutRect viewRect = frameView->visibleContentRect();
                     LayoutRect r = ScrollAlignment::getRectToExpose(viewRect, rect, alignX, alignY);
-                    frameView->setScrollPosition(roundedIntPoint(r.location()));
+                    frameView->setScrollPosition(DoublePoint(r.location()));
                 }
             }
         }
     }
 
     if (frame()->page()->autoscrollController().autoscrollInProgress())
         parentBox = enclosingScrollableBox();
 
     if (parentBox)
         parentBox->scrollRectToVisible(newRect, alignX, alignY);
@@ skipping 299 matching lines @@
         lastKnownMousePosition = previousMousePosition;
     else
         previousMousePosition = lastKnownMousePosition;
 
     IntSize delta = lastKnownMousePosition - sourcePoint;
 
     if (abs(delta.width()) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
         delta.setWidth(0);
     if (abs(delta.height()) <= ScrollView::noPanScrollRadius)
         delta.setHeight(0);
-
-    scrollByRecursively(adjustedScrollDelta(delta), ScrollOffsetClamped);
+    DoubleSize adjustedDelta = adjustedScrollDelta(delta);
+    scrollByRecursively(adjustedDelta, ScrollOffsetClamped);
 }
 
-void RenderBox::scrollByRecursively(const IntSize& delta, ScrollOffsetClamping clamp)
+void RenderBox::scrollByRecursively(const DoubleSize& delta, ScrollOffsetClamping clamp)
 {
     if (delta.isZero())
         return;
 
     bool restrictedByLineClamp = false;
     if (parent())
         restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
 
     if (hasOverflowClip() && !restrictedByLineClamp) {
-        IntSize newScrollOffset = layer()->scrollableArea()->adjustedScrollOffset() + delta;
+        DoubleSize newScrollOffset = layer()->scrollableArea()->adjustedScrollOffset() + delta;
         layer()->scrollableArea()->scrollToOffset(newScrollOffset, clamp);
 
         // If this layer can't do the scroll we ask the next layer up that can scroll to try
-        IntSize remainingScrollOffset = newScrollOffset - layer()->scrollableArea()->adjustedScrollOffset();
+        DoubleSize remainingScrollOffset = newScrollOffset - layer()->scrollableArea()->adjustedScrollOffset();
         if (!remainingScrollOffset.isZero() && parent()) {
             if (RenderBox* scrollableBox = enclosingScrollableBox())
                 scrollableBox->scrollByRecursively(remainingScrollOffset, clamp);
 
             LocalFrame* frame = this->frame();
             if (frame && frame->page())
                 frame->page()->autoscrollController().updateAutoscrollRenderer();
         }
     } else if (view()->frameView()) {
         // If we are here, we were called on a renderer that can be programmatically scrolled, but doesn't
         // have an overflow clip. Which means that it is a document node that can be scrolled.
-        view()->frameView()->scrollBy(delta);
+        // FIXME: Pass in DoubleSize. crbug.com/414283.
+        view()->frameView()->scrollBy(flooredIntSize(delta));
 
         // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement?
         // https://bugs.webkit.org/show_bug.cgi?id=28237
     }
 }
 
 bool RenderBox::needsPreferredWidthsRecalculation() const
 {
     return style()->paddingStart().isPercent() || style()->paddingEnd().isPercent();
 }
 
 IntSize RenderBox::scrolledContentOffset() const
 {
     ASSERT(hasOverflowClip());
     ASSERT(hasLayer());
-    return layer()->scrollableArea()->scrollOffset();
+    return flooredIntSize(layer()->scrollableArea()->scrollOffset());

[Rick Byers, 2014/10/02 21:44:05]

We need a FIXME here, right?

[Yufeng Shen (Slow to review), 2014/10/02 23:34:34]

Done.

 }
 
 void RenderBox::applyCachedClipAndScrollOffsetForPaintInvalidation(LayoutRect& paintRect) const
 {
     ASSERT(hasLayer());
     ASSERT(hasOverflowClip());
 
     flipForWritingMode(paintRect);
     paintRect.move(-scrolledContentOffset()); // For overflow:auto/scroll/hidden.
 
@@ skipping 3653 matching lines @@
     ASSERT(style()->hasBackground() || style()->hasBoxDecorations());
 
     if (m_rareData && m_rareData->m_previousBorderBoxSize.width() != -1)
         return m_rareData->m_previousBorderBoxSize;
 
     // We didn't save the old border box size because it was the same as the size of oldBounds.
     return previousBoundsSize;
 }
 
 } // namespace blink