Overlay scrollbars must respect ancestor clip

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 72 matching lines @@
 // but this is likely to evolve soon.
 class CompositedLayerMapping FINAL : public GraphicsLayerClient {
     WTF_MAKE_NONCOPYABLE(CompositedLayerMapping); WTF_MAKE_FAST_ALLOCATED;
 public:
     explicit CompositedLayerMapping(RenderLayer&);
     virtual ~CompositedLayerMapping();
 
     RenderLayer& owningLayer() const { return m_owningLayer; }
 
     bool updateGraphicsLayerConfiguration();
-    void updateGraphicsLayerGeometry(const RenderLayer* compositingContainer, Vector<RenderLayer*>& layersNeedingPaintInvalidation);
+    void updateGraphicsLayerGeometry(const RenderLayer* compositingContainer, const RenderLayer* compositingStackingContext, Vector<RenderLayer*>& layersNeedingPaintInvalidation);
 
     // Update whether layer needs blending.
     void updateContentsOpaque();
 
     GraphicsLayer* mainGraphicsLayer() const { return m_graphicsLayer.get(); }
 
     // Layer to clip children
     bool hasClippingLayer() const { return m_childContainmentLayer; }
     GraphicsLayer* clippingLayer() const { return m_childContainmentLayer.get(); }
 
@@ skipping 115 matching lines @@
     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, Vector<RenderLayer*>& layersNeedingPaintInvalidation);
     void updateMainGraphicsLayerGeometry(const IntRect& relativeCompositingBounds, const IntRect& localCompositingBounds, IntPoint& graphicsLayerParentLocation);
     void updateAncestorClippingLayerGeometry(const RenderLayer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation);
+    void updateOverflowControlsHostLayerGeometry(const RenderLayer* compositingStackingContext);
     void updateChildContainmentLayerGeometry(const IntRect& clippingBox, const IntRect& localCompositingBounds);
     void updateChildTransformLayerGeometry();
     void updateMaskLayerGeometry();
     void updateTransformGeometry(const IntPoint& snappedOffsetFromCompositedAncestor, const IntRect& relativeCompositingBounds);
     void updateForegroundLayerGeometry(const FloatSize& relativeCompositingBoundsSize, const IntRect& clippingBox);
     void updateBackgroundLayerGeometry(const FloatSize& relativeCompositingBoundsSize);
     void updateReflectionLayerGeometry(Vector<RenderLayer*>& layersNeedingPaintInvalidation);
     void updateScrollingLayerGeometry(const IntRect& localCompositingBounds);
     void updateChildClippingMaskLayerGeometry();
 
     void createPrimaryGraphicsLayer();
     void destroyGraphicsLayers();
 
     PassOwnPtr<GraphicsLayer> createGraphicsLayer(CompositingReasons);
     bool toggleScrollbarLayerIfNeeded(OwnPtr<GraphicsLayer>&, bool needsLayer, CompositingReasons);
 
     RenderLayerModelObject* renderer() const { return m_owningLayer.renderer(); }
     RenderLayerCompositor* compositor() const { return m_owningLayer.compositor(); }
 
     void updateInternalHierarchy();
     void updatePaintingPhases();
     bool updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip);
     bool updateChildTransformLayer(bool needsChildTransformLayer);
-    bool updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer);
+    bool updateOverflowControlsLayers(bool needsHorizontalScrollbarLayer, bool needsVerticalScrollbarLayer, bool needsScrollCornerLayer, bool needsAncestorClip);
     bool updateForegroundLayer(bool needsForegroundLayer);
     bool updateBackgroundLayer(bool needsBackgroundLayer);
     bool updateMaskLayer(bool needsMaskLayer);
     bool updateClippingMaskLayers(bool needsChildClippingMaskLayer);
     bool requiresHorizontalScrollbarLayer() const { return m_owningLayer.scrollableArea() && m_owningLayer.scrollableArea()->horizontalScrollbar(); }
     bool requiresVerticalScrollbarLayer() const { return m_owningLayer.scrollableArea() && m_owningLayer.scrollableArea()->verticalScrollbar(); }
     bool requiresScrollCornerLayer() const { return m_owningLayer.scrollableArea() && !m_owningLayer.scrollableArea()->scrollCornerAndResizerRect().isEmpty(); }
     bool updateScrollingLayers(bool scrollingLayers);
     void updateScrollParent(RenderLayer*);
     void updateClipParent();
@@ skipping 50 matching lines @@
     // clipping container for |m_owningLayer|.
     bool owningLayerClippedByLayerNotAboveCompositedAncestor();
 
     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]
+    //        |                                            + m_scrollingContentsLayer [Present iff m_scrollingLayer is present]
+    //        |                                               + m_scrollingBlockSelectionLayer [Present iff m_scrollingLayer is present]
+    //        |
+    //        + m_overflowControlsClippingLayer [OPTIONAL] // *The overflow controls may need to be repositioned in the

[chrishtr, 2014/07/25 18:00:33]

Is it positioned here, or is it a sibling of m_graphicsLayer? From reading the
CL description, I thought the whole reason for this CL was that
this layer can't be positioned below m_graphicsLayer.

Also: I can see how m_overflowControlsHostLayer can't be below m_graphicsLayer
because it needs to paint after everything, but why can't it
be a sibling of m_graphicsLayer? And if it is a sibling, won't
m_ancestorClippingLayer clip it correctly?

My understanding is that the ancestor clipper should clip both the contents of
the overflow-scroll layer and its scroll bars, so from the
point of view of what the ancestor should clip, scroll bars are not special.

[Ian Vollick, 2014/07/25 18:19:51]

If the overflow controls need to be reparented (and this CLM has an ancestor
clipping layer), they will not be a sibling of m_graphicsLayer, they will be a
sibling of m_ancestorClippingLayer.

Some more detail:

If the controls need to be reparented, that implies that the scroller does not
form a stacking context and that it has some scrolling content that succeeds it
in paint order. This scrolling content will have its own CLM which will be a
sibling of this CLM. In particular, this scrolling content will _not_ be below
the ancestor clipping (scroll parent magic will ensure that it gets clipped
correctly in the compositor). The reparented overflow controls will need to
stack above this scrolling content, so it will succeed the last bit of scrolling
content's CLM. Here's a diagram of the final arrangement after reparenting.

+ stacking context
  + ancestor-clipping-layer (of scroller)
     + graphics-layer (of scroller)
        + ...
  + graphics-layer (of scrolled content that stacks above the scroller)
  + overflow-control-clip-layer
     + overflow-control-host-layer

The overflow controls aren't below the ancestor clipping layer, so we can't rely
on it for clipping.

+    //          + m_overflowControlsHostLayer              //  graphics layer tree by the RLC to ensure that they stack
+    //            + m_layerForVerticalScrollbar            //  above scrolling content.
+    //            + m_layerForHorizontalScrollbar
+    //            + m_layerForScrollCorner
     //
     // 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
@@ skipping 43 matching lines @@
     //         + root content layer
     //
     // With the hierarchy set up like this, the root content layer is able to scroll without affecting
     // the background layer (or repainting).
     OwnPtr<GraphicsLayer> m_foregroundLayer; // Only used in cases where we need to draw the foreground separately.
     OwnPtr<GraphicsLayer> m_backgroundLayer; // Only used in cases where we need to draw the background separately.
 
     OwnPtr<GraphicsLayer> m_layerForHorizontalScrollbar;
     OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
     OwnPtr<GraphicsLayer> m_layerForScrollCorner;
+
+    // This layer exists to simplify the reparenting of overflow control that is occasionally required
+    // to ensure that scrollbars appear above scrolling content.
     OwnPtr<GraphicsLayer> m_overflowControlsHostLayer;
 
+    // The reparented overflow controls sometimes need to be clipped by a non-ancestor. In just the same
+    // way we need an ancestor clipping layer to clip this CLM's internal hierarchy, we add another layer
+    // to clip the overflow controls. It would be possible to make m_overflowControlsHostLayer be
+    // responsible for applying this clip, but that could require repositioning all of the overflow
+    // controls since the this clip may apply an offset. By using a separate layer, the overflow controls
+    // can remain ignorant of the layers above them and still work correctly.
+    OwnPtr<GraphicsLayer> m_overflowControlsClippingLayer;
+
     // A squashing CLM has two possible squashing-related structures.
     //
     // If m_ancestorClippingLayer is present:
     //
     // m_ancestorClippingLayer
     //   + m_graphicsLayer
     //   + m_squashingLayer
     //
     // If not:
     //
@@ skipping 14 matching lines @@
     unsigned m_isMainFrameRenderViewLayer : 1;
     unsigned m_requiresOwnBackingStoreForIntrinsicReasons : 1;
     unsigned m_requiresOwnBackingStoreForAncestorReasons : 1;
     unsigned m_backgroundLayerPaintsFixedRootBackground : 1;
     unsigned m_scrollingContentsAreEmpty : 1;
 };
 
 } // namespace blink
 
 #endif // CompositedLayerMapping_h