Allow proper highlighting on universal overflow scroll.

Source/core/rendering/RenderLayer.cpp

Index: Source/core/rendering/RenderLayer.cpp
diff --git a/Source/core/rendering/RenderLayer.cpp b/Source/core/rendering/RenderLayer.cpp
index f458c9f1012d87accf86ba99bc0cb4f3f5391235..1055b6091cf191b5313f42f8b3329c3121c872db 100644
--- a/Source/core/rendering/RenderLayer.cpp
+++ b/Source/core/rendering/RenderLayer.cpp
@@ -3146,9 +3146,16 @@ RenderLayer* RenderLayer::hitTestChildLayerColumns(RenderLayer* childLayer, Rend
     return 0;
 }
 
+void RenderLayer::blockSelectionGapsBoundsChanged()
+{
+    setNeedsCompositingInputsUpdate();
+    compositor()->setNeedsCompositingUpdate(CompositingUpdateOnCompositedScroll);

[abarth-chromium, 2014/06/13 18:17:50]

This compositing update type isn't sufficient.  You need to use
CompositingUpdateAfterCompositingInputChange otherwise the system won't notice
that you marked setNeedsCompositingInputsUpdate.

There are two levels of dirty bits:

1) RenderLayers have dirty bits for their compositing inputs.
2) CompositedLayerMappings have dirty bits for their geometry.

The CompositingInputsUpdater cleans out the dirty bits on RenderLayers and
transfers them to CompositedLayerMappings.  If you want to use
CompositingUpdateOnCompositedScroll (which should probably be renamed
CompositingUpdateAfterGeometryChange), you'll need to mark the geometry dirty
bit on CompositedLayerMappings directly.  If you use
setNeedsCompositingInputsUpdate to mark the RenderLayer, you need to use
CompositingUpdateAfterCompositingInputChange to tell the
CompositingInputsUpdater to copy the bits over for you.

I'd recommend just using CompositingUpdateAfterCompositingInputChange because
its easier and will be robust against any chicken/egg problems you have in
finding the CompositedLayerMappings to mark as dirty.

[hartmanng, 2014/06/13 18:42:58]

Makes sense, thanks for the explanation.

Done.

+}
+
 void RenderLayer::addBlockSelectionGapsBounds(const LayoutRect& bounds)
 {
     m_blockSelectionGapsBounds.unite(enclosingIntRect(bounds));
+    blockSelectionGapsBoundsChanged();
 }
 
 void RenderLayer::clearBlockSelectionGapsBounds()
@@ -3156,6 +3163,7 @@ void RenderLayer::clearBlockSelectionGapsBounds()
     m_blockSelectionGapsBounds = IntRect();
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->clearBlockSelectionGapsBounds();
+    blockSelectionGapsBoundsChanged();
 }
 
 void RenderLayer::repaintBlockSelectionGaps()
@@ -3179,9 +3187,26 @@ void RenderLayer::repaintBlockSelectionGaps()
         renderer()->invalidatePaintRectangle(rect);
 }
 
+IntRect RenderLayer::blockSelectionGapsBounds() const
+{
+    if (!renderer()->isRenderBlock())
+        return IntRect();
+
+    RenderBlock* renderBlock = toRenderBlock(renderer());
+    LayoutRect gapRects = renderBlock->selectionGapRectsForRepaint(renderBlock);
+
+    return pixelSnappedIntRect(gapRects);
+}
+
 bool RenderLayer::hasBlockSelectionGapBounds() const
 {
-    return !m_blockSelectionGapsBounds.isEmpty();
+    // FIXME: it would be more accurate to return !blockSelectionGapsBounds().isEmpty(), but this is impossible
+    // at the moment because it causes invalid queries to layout-dependent code (crbug.com/372802).
+
+    if (!renderer()->isRenderBlock())
+        return false;
+
+    return toRenderBlock(renderer())->shouldPaintSelectionGaps();
 }
 
 bool RenderLayer::intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutPoint* offsetFromRoot) const