Allow proper highlighting on universal overflow scroll.

Source/core/rendering/compositing/CompositedLayerMapping.h

 /*
  * 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 89 matching lines @@
 
     bool hasContentsLayer() const { return m_foregroundLayer; }
     GraphicsLayer* foregroundLayer() const { return m_foregroundLayer.get(); }
 
     GraphicsLayer* backgroundLayer() const { return m_backgroundLayer.get(); }
     bool backgroundLayerPaintsFixedRootBackground() const { return m_backgroundLayerPaintsFixedRootBackground; }
 
     bool hasScrollingLayer() const { return m_scrollingLayer; }
     GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
     GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
+    GraphicsLayer* scrollingBlockSelectionLayer() const { return m_scrollingBlockSelectionLayer.get(); }
 
     bool hasMaskLayer() const { return m_maskLayer; }
     GraphicsLayer* maskLayer() const { return m_maskLayer.get(); }
 
     bool hasChildClippingMaskLayer() const { return m_childClippingMaskLayer; }
     GraphicsLayer* childClippingMaskLayer() const { return m_childClippingMaskLayer.get(); }
 
     GraphicsLayer* parentForSublayers() const;
     GraphicsLayer* childForSuperlayers() const;
     // localRootForOwningLayer does not include the m_squashingContainmentLayer, which is technically not associated with this CLM's owning layer.
@@ skipping 77 matching lines @@
     LayoutSize contentOffsetInCompositingLayer() const;
 
     LayoutPoint squashingOffsetFromTransformedAncestor()
     {
         return m_squashingLayerOffsetFromTransformedAncestor;
     }
 
     // If there is a squashed layer painting into this CLM that is an ancestor of the given RenderObject, return it. Otherwise return 0.
     const GraphicsLayerPaintInfo* containingSquashedLayer(const RenderObject*);
 
+    void updateScrollingBlockSelection();
+
 private:
     static const GraphicsLayerPaintInfo* containingSquashedLayer(const RenderObject*,  const Vector<GraphicsLayerPaintInfo>& layers);
 
     // Helper methods to updateGraphicsLayerGeometry:
     void computeGraphicsLayerParentLocation(const RenderLayer* compositingContainer, const IntRect& ancestorCompositingBounds, IntPoint& graphicsLayerParentLocation);
     void updateSquashingLayerGeometry(const LayoutPoint& offsetFromCompositedAncestor, const IntPoint& graphicsLayerParentLocation, const RenderLayer& referenceLayer, Vector<GraphicsLayerPaintInfo>& layers, GraphicsLayer*, LayoutPoint* offsetFromTransformedAncestor);
     void updateMainGraphicsLayerGeometry(const IntRect& relativeCompositingBounds, const IntRect& localCompositingBounds, IntPoint& graphicsLayerParentLocation);
     void updateAncestorClippingLayerGeometry(const RenderLayer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation);
     void updateChildContainmentLayerGeometry(const IntRect& clippingBox, const IntRect& localCompositingBounds);
     void updateChildTransformLayerGeometry();
@@ skipping 81 matching lines @@
     static IntRect localClipRectForSquashedLayer(const RenderLayer& referenceLayer, const GraphicsLayerPaintInfo&,  const Vector<GraphicsLayerPaintInfo>& layers);
 
     RenderLayer& m_owningLayer;
 
     // The hierarchy of layers that is maintained by the CompositedLayerMapping looks like this:
     //
     //  + m_ancestorClippingLayer [OPTIONAL]
     //     + m_graphicsLayer
     //        + m_childContainmentLayer [OPTIONAL] <-OR-> m_scrollingLayer [OPTIONAL] <-OR-> m_childTransformLayer
     //                                                     + m_scrollingContentsLayer [Present iff m_scrollingLayer is present]
+    //                                                        + m_scrollingBlockSelectionLayer [Present iff m_scrollingLayer is present]
     //
     // We need an ancestor clipping layer if our clipping ancestor is not our ancestor in the
     // clipping tree. Here's what that might look like.
     //
     // Let A = the clipping ancestor,
     //     B = the clip descendant, and
     //     SC = the stacking context that is the ancestor of A and B in the stacking tree.
     //
     // SC
     //  + A = m_graphicsLayer
     //  |  + m_childContainmentLayer
     //  |     + ...
     //  ...
     //  |
     //  + B = m_ancestorClippingLayer [+]
     //     + m_graphicsLayer
     //        + ...
     //
     // In this case B is clipped by another layer that doesn't happen to be its ancestor: A.
     // So we create an ancestor clipping layer for B, [+], which ensures that B is clipped
     // as if it had been A's descendant.
     OwnPtr<GraphicsLayer> m_ancestorClippingLayer; // Only used if we are clipped by an ancestor which is not a stacking context.
     OwnPtr<GraphicsLayer> m_graphicsLayer;
     OwnPtr<GraphicsLayer> m_childContainmentLayer; // Only used if we have clipping on a stacking context with compositing children.
     OwnPtr<GraphicsLayer> m_childTransformLayer; // Only used if we have perspective and no m_childContainmentLayer.
     OwnPtr<GraphicsLayer> m_scrollingLayer; // Only used if the layer is using composited scrolling.
     OwnPtr<GraphicsLayer> m_scrollingContentsLayer; // Only used if the layer is using composited scrolling.
+    OwnPtr<GraphicsLayer> m_scrollingBlockSelectionLayer; // Only used if the layer is using composited scrolling, but has no scrolling contents apart from block selection gaps.
 
     // This layer is also added to the hierarchy by the RLB, but in a different way than
     // the layers above. It's added to m_graphicsLayer as its mask layer (naturally) if
     // we have a mask, and isn't part of the typical hierarchy (it has no children).
     OwnPtr<GraphicsLayer> m_maskLayer; // Only used if we have a mask.
     OwnPtr<GraphicsLayer> m_childClippingMaskLayer; // Only used if we have to clip child layers or accelerated contents with border radius or clip-path.
 
     // There are two other (optional) layers whose painting is managed by the CompositedLayerMapping,
     // but whose position in the hierarchy is maintained by the RenderLayerCompositor. These
     // are the foreground and background layers. The foreground layer exists if we have composited
@@ skipping 43 matching lines @@
 
     LayoutRect m_compositedBounds;
 
     bool m_isMainFrameRenderViewLayer : 1;
     bool m_requiresOwnBackingStoreForIntrinsicReasons : 1;
     bool m_requiresOwnBackingStoreForAncestorReasons : 1;
     bool m_canCompositeFilters : 1;
     bool m_backgroundLayerPaintsFixedRootBackground : 1;
     bool m_needToUpdateGraphicsLayer : 1;
     bool m_needToUpdateGraphicsLayerOfAllDecendants : 1;
+    bool m_scrollingContentsAreEmpty : 1;
 };
 
 } // namespace WebCore
 
 #endif // CompositedLayerMapping_h