Add a WebLayer:setScrollCompensationAdjustment between Blink and CC

Source/core/page/scrolling/ScrollingCoordinator.cpp

 /*
  * Copyright (C) 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 372 matching lines @@
 
     WebLayer* webLayer = toWebLayer(scrollableArea->layerForScrolling());
     WebLayer* containerLayer = toWebLayer(scrollableArea->layerForContainer());
     if (webLayer) {
         webLayer->setScrollClipLayer(containerLayer);
         // Non-layered Viewport constrained objects, e.g. fixed position elements, are
         // positioned in Blink using integer coordinates. In that case, we don't want
         // to set the WebLayer's scroll position at fractional precision otherwise the
         // WebLayer's position after snapping to device pixel can be off with regard to
         // fixed position elements.
-        if (m_lastMainThreadScrollingReasons & ScrollingCoordinator::HasNonLayerViewportConstrainedObjects)
+        if (m_lastMainThreadScrollingReasons & ScrollingCoordinator::HasNonLayerViewportConstrainedObjects) {
             webLayer->setScrollPositionDouble(DoublePoint(scrollableArea->scrollPosition() - scrollableArea->minimumScrollPosition()));
-        else
-            webLayer->setScrollPositionDouble(DoublePoint(scrollableArea->scrollPositionDouble() - scrollableArea->minimumScrollPosition()));
+        } else {
+            // Blink can only use the integer part of the scroll offset to position elements.
+            // So it sends the integer and fractional part of the scroll offset to CC
+            // separately to be clear that CC needs to take special care of the fractional
+            // part, e.g. compensating for fixed-position layer's position. Once Blink can
+            // fully position elements at fractional boundary, we can get rid of these separate
+            // calls.
+            DoublePoint scrollPosition(scrollableArea->scrollPositionDouble() - scrollableArea->minimumScrollPosition());
+            IntPoint flooredScrollPosition(flooredIntPoint(scrollPosition));
+            DoublePoint fractionalPart(scrollPosition.x() - flooredScrollPosition.x(), scrollPosition.y() - flooredScrollPosition.y());
+            webLayer->setScrollPositionDouble(DoublePoint(flooredScrollPosition));

[aelias_OOO_until_Jul13, 2015/01/28 22:31:34]

Let's send the full nonfloored position here.  The idea is that in CC we would
never need to reason about floored stuff in the normal scroll offset codepaths,
it can always assume scroll_offset_ contains the full offset from now on.

[Yufeng Shen (Slow to review), 2015/01/28 22:49:33]

Done.

[Rick Byers, 2015/01/29 20:55:07]

Just saw this - sorry.  Maybe I just need an concise API description in the
comments - clearly the semantics aren't as simple as "one API for the integer
portion, one API for the fractional portion".

+            webLayer->setScrollPositionFractionalPart(fractionalPart);
+        }
 
         webLayer->setBounds(scrollableArea->contentsSize());
         bool canScrollX = scrollableArea->userInputScrollable(HorizontalScrollbar);
         bool canScrollY = scrollableArea->userInputScrollable(VerticalScrollbar);
         webLayer->setUserScrollable(canScrollX, canScrollY);
     }
     if (WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, HorizontalScrollbar)) {
         GraphicsLayer* horizontalScrollbarLayer = scrollableArea->layerForHorizontalScrollbar();
         if (horizontalScrollbarLayer)
             setupScrollbarLayer(horizontalScrollbarLayer, scrollbarLayer, webLayer, containerLayer);
@@ skipping 627 matching lines @@
     bool frameIsScrollable = frameView && frameView->isScrollable();
     if (frameIsScrollable != m_wasFrameScrollable)
         return true;
 
     if (WebLayer* scrollLayer = frameView ? toWebLayer(frameView->layerForScrolling()) : nullptr)
         return blink::WebSize(frameView->contentsSize()) != scrollLayer->bounds();
     return false;
 }
 
 } // namespace blink