Allow proper highlighting on universal overflow scroll.

Source/core/rendering/RenderLayer.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@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 3128 matching lines @@
             }
 
             if (hitLayer)
                 return hitLayer;
         }
     }
 
     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()
 {
     m_blockSelectionGapsBounds = IntRect();
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->clearBlockSelectionGapsBounds();
+    blockSelectionGapsBoundsChanged();
 }
 
 void RenderLayer::repaintBlockSelectionGaps()
 {
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->repaintBlockSelectionGaps();
 
     if (m_blockSelectionGapsBounds.isEmpty())
         return;
 
     LayoutRect rect = m_blockSelectionGapsBounds;
     if (renderer()->hasOverflowClip()) {
         RenderBox* box = renderBox();
         rect.move(-box->scrolledContentOffset());
         if (!scrollableArea()->usesCompositedScrolling())
             rect.intersect(box->overflowClipRect(LayoutPoint()));
     }
     if (renderer()->hasClip())
         rect.intersect(toRenderBox(renderer())->clipRect(LayoutPoint()));
     if (!rect.isEmpty())
         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
 {
     // Always examine the canvas and the root.
     // FIXME: Could eliminate the isDocumentElement() check if we fix background painting so that the RenderView
     // paints the root's background.
     if (isRootLayer() || renderer()->isDocumentElement())
         return true;
 
@@ skipping 635 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif