Use float for scroll offset.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1091 matching lines @@
       // The controls are in the same 2D space as the compositing container, so
       // we can map them into the space of the container.
       TransformState transformState(TransformState::ApplyTransformDirection,
                                     FloatPoint());
       m_owningLayer.layoutObject()->mapLocalToAncestor(
           compositingStackingContext->layoutObject(), transformState,
           ApplyContainerFlip);
       transformState.flatten();
       hostLayerPosition = LayoutPoint(transformState.lastPlanarPoint());
       if (PaintLayerScrollableArea* scrollableArea =
-              compositingStackingContext->getScrollableArea())
+              compositingStackingContext->getScrollableArea()) {
         hostLayerPosition.move(
-            LayoutSize(scrollableArea->adjustedScrollOffset()));
+            LayoutSize(toFloatSize(scrollableArea->scrollPosition())));
+      }
       hostLayerPosition.move(-stackingOffsetFromLayoutObject);
     }
   } else {
     hostLayerPosition.move(-m_graphicsLayer->offsetFromLayoutObject());
   }
 
   m_overflowControlsHostLayer->setPosition(FloatPoint(hostLayerPosition));
 
   const IntRect borderBox =
       toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
@@ skipping 89 matching lines @@
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(
     const IntRect& localCompositingBounds) {
   if (!m_scrollingLayer)
     return;
 
   ASSERT(m_scrollingContentsLayer);
   LayoutBox* layoutBox = toLayoutBox(layoutObject());
   IntRect overflowClipRect =
       enclosingIntRect(layoutBox->overflowClipRect(LayoutPoint()));
-  DoubleSize adjustedScrollOffset =
-      m_owningLayer.getScrollableArea()->adjustedScrollOffset();
+  FloatPoint scrollPosition =
+      m_owningLayer.getScrollableArea()->scrollPosition();
   m_scrollingLayer->setPosition(FloatPoint(
       overflowClipRect.location() - localCompositingBounds.location() +
       roundedIntSize(m_owningLayer.subpixelAccumulation())));
   m_scrollingLayer->setSize(FloatSize(overflowClipRect.size()));
 
   IntSize oldScrollingLayerOffset = m_scrollingLayer->offsetFromLayoutObject();
   m_scrollingLayer->setOffsetFromLayoutObject(
       -toIntSize(overflowClipRect.location()));
 
   if (m_childClippingMaskLayer && !layoutObject()->style()->clipPath()) {
     m_childClippingMaskLayer->setPosition(m_scrollingLayer->position());
     m_childClippingMaskLayer->setSize(m_scrollingLayer->size());
     m_childClippingMaskLayer->setOffsetFromLayoutObject(
         toIntSize(overflowClipRect.location()));
   }
 
   bool overflowClipRectOffsetChanged =
       oldScrollingLayerOffset != m_scrollingLayer->offsetFromLayoutObject();
 
   IntSize scrollSize(layoutBox->scrollWidth().toInt(),
                      layoutBox->scrollHeight().toInt());
   if (scrollSize != m_scrollingContentsLayer->size() ||
       overflowClipRectOffsetChanged)
     m_scrollingContentsLayer->setNeedsDisplay();
 
   DoubleSize scrollingContentsOffset(
-      overflowClipRect.location().x() - adjustedScrollOffset.width(),
-      overflowClipRect.location().y() - adjustedScrollOffset.height());
+      overflowClipRect.location().x() - scrollPosition.x(),
+      overflowClipRect.location().y() - scrollPosition.y());
   // The scroll offset change is compared using floating point so that
   // fractional scroll offset change can be propagated to compositor.
   if (scrollingContentsOffset != m_scrollingContentsOffset ||
       scrollSize != m_scrollingContentsLayer->size()) {
     bool coordinatorHandlesOffset =
         compositor()->scrollingLayerDidChange(&m_owningLayer);
     m_scrollingContentsLayer->setPosition(
-        coordinatorHandlesOffset
-            ? FloatPoint()
-            : FloatPoint(-toFloatSize(adjustedScrollOffset)));
+        coordinatorHandlesOffset ? FloatPoint()
+                                 : FloatPoint(-toFloatSize(scrollPosition)));
   }
   m_scrollingContentsOffset = scrollingContentsOffset;
 
   m_scrollingContentsLayer->setSize(FloatSize(scrollSize));
 
   IntPoint scrollingContentsLayerOffsetFromLayoutObject;
   if (PaintLayerScrollableArea* scrollableArea =
           m_owningLayer.getScrollableArea()) {
     scrollingContentsLayerOffsetFromLayoutObject =
         -scrollableArea->scrollOrigin();
@@ skipping 1612 matching lines @@
 }
 
 void CompositedLayerMapping::adjustForCompositedScrolling(
     const GraphicsLayer* graphicsLayer,
     IntSize& offset) const {
   if (graphicsLayer == m_scrollingContentsLayer.get() ||
       graphicsLayer == m_foregroundLayer.get()) {
     if (PaintLayerScrollableArea* scrollableArea =
             m_owningLayer.getScrollableArea()) {
       if (scrollableArea->usesCompositedScrolling()) {
-        // Note: this is just the scroll offset, *not* the "adjusted scroll
-        // offset". Scroll offset does not include the origin adjustment. That
-        // is instead baked already into offsetFromLayoutObject.
-        DoubleSize scrollOffset = scrollableArea->scrollOffset();
+        // Note: this is the offset from the beginning of flow of the block, not
+        // the offset from the top/left of the overflow rect.
+        // offsetFromLayoutObject adds the origin offset from top/left to the
+        // beginning of flow.
+        ScrollOffset scrollOffset = scrollableArea->scrollOffset();
         offset.expand(-scrollOffset.width(), -scrollOffset.height());
       }
     }
   }
 }
 
 void CompositedLayerMapping::paintContents(
     const GraphicsLayer* graphicsLayer,
     GraphicsContext& context,
     GraphicsLayerPaintingPhase graphicsLayerPaintingPhase,
@@ skipping 325 matching lines @@
   } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
     name = "Scrolling Contents Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink