Fix border radius on composited children.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * 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 183 matching lines @@
     for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
         PaintLayer* oldSquashedLayer = m_squashedLayers[i].paintLayer;
         // Assert on incorrect mappings between layers and groups
         ASSERT(oldSquashedLayer->groupedMapping() == this);
         if (oldSquashedLayer->groupedMapping() == this) {
             oldSquashedLayer->setGroupedMapping(0, PaintLayer::DoNotInvalidateLayerAndRemoveFromMapping);
             oldSquashedLayer->setLostGroupedMapping(true);
         }
     }
 
-    updateClippingLayers(false, false);
+    updateClippingLayers(false, false, false);
     updateOverflowControlsLayers(false, false, false, false);
     updateChildTransformLayer(false);
     updateForegroundLayer(false);
     updateBackgroundLayer(false);
     updateMaskLayer(false);
     updateChildClippingMaskLayer(false);
     updateScrollingLayers(false);
     updateSquashingLayers(false);
     destroyGraphicsLayers();
 }
@@ skipping 21 matching lines @@
     updateLayerBlendMode(layoutObject()->styleRef());
     updateIsRootForIsolatedGroup();
 }
 
 void CompositedLayerMapping::destroyGraphicsLayers()
 {
     if (m_graphicsLayer)
         m_graphicsLayer->removeFromParent();
 
     m_ancestorClippingLayer = nullptr;
+    m_ancestorClippingMaskLayer = nullptr;
     m_graphicsLayer = nullptr;
     m_foregroundLayer = nullptr;
     m_backgroundLayer = nullptr;
     m_childContainmentLayer = nullptr;
     m_childTransformLayer = nullptr;
     m_maskLayer = nullptr;
     m_childClippingMaskLayer = nullptr;
 
     m_scrollingLayer = nullptr;
     m_scrollingContentsLayer = nullptr;
@@ skipping 151 matching lines @@
     // updateAncestorClippingLayerGeometry will fail as the clip rect will be
     // infinite.
     // FIXME: this should use cached clip rects, but this sometimes give
     // inaccurate results (and trips the ASSERTS in PaintLayerClipper).
     ClipRectsContext clipRectsContext(compositingAncestor, UncachedClipRects, IgnoreOverlayScrollbarSize);
     clipRectsContext.setIgnoreOverflowClip();
     IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer.clipper().backgroundClipRect(clipRectsContext).rect());
     return parentClipRect != LayoutRect::infiniteIntRect();
 }
 
+bool CompositedLayerMapping::owningLayerMaskedByLayerNotAboveCompositedAncestor(const PaintLayer* scrollParent)
+{
+    if (!m_owningLayer.parent())
+        return false;
+
+    const PaintLayer* compositingAncestor = m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
+    if (!compositingAncestor)
+        return false;
+
+    const LayoutObject* clippingContainer = m_owningLayer.clippingContainer();
+    if (!clippingContainer)
+        return false;
+
+    if (clippingContainer->enclosingLayer() == scrollParent)
+        return false;
+
+    if (compositingAncestor->layoutObject()->isDescendantOf(clippingContainer))
+        return false;
+
+    DCHECK(clippingContainer->style());
+    return clippingContainer->style()->clipPath() || clippingContainer->style()->hasBorderRadius();
+}
+
 const PaintLayer* CompositedLayerMapping::scrollParent()
 {
     const PaintLayer* scrollParent = m_owningLayer.scrollParent();
     if (scrollParent && !scrollParent->needsCompositedScrolling())
         return nullptr;
     return scrollParent;
 }
 
 bool CompositedLayerMapping::updateGraphicsLayerConfiguration()
 {
@@ skipping 36 matching lines @@
 
     const PaintLayer* scrollParent = this->scrollParent();
 
     // This is required because compositing layers are parented according to the z-order hierarchy, yet
     // clipping goes down the layoutObject hierarchy. Thus, a PaintLayer can be clipped by a
     // PaintLayer that is an ancestor in the layoutObject hierarchy, but a sibling in the z-order
     // hierarchy. Further, that sibling need not be composited at all. In such scenarios, an ancestor
     // clipping layer is necessary to apply the composited clip for this layer.
     bool needsAncestorClip = owningLayerClippedByLayerNotAboveCompositedAncestor(scrollParent)
         && !m_owningLayer.clippingContainer()->enclosingLayer()->hasRootScrollerAsDescendant();
-
-    if (updateClippingLayers(needsAncestorClip, needsDescendantsClippingLayer))
+    bool needsAncestorClippingMask = needsAncestorClip && owningLayerMaskedByLayerNotAboveCompositedAncestor(scrollParent);
+    if (updateClippingLayers(needsAncestorClip, needsAncestorClippingMask, needsDescendantsClippingLayer))
         layerConfigChanged = true;
 
     bool scrollingConfigChanged = false;
     if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
         layerConfigChanged = true;
         scrollingConfigChanged = true;
     }
 
     if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer(), needsAncestorClip))
         layerConfigChanged = true;
@@ skipping 379 matching lines @@
 
     ClipRectsContext clipRectsContext(compositingContainer, PaintingClipRectsIgnoringOverflowClip, IgnoreOverlayScrollbarSize);
     IntRect parentClipRect = pixelSnappedIntRect(m_owningLayer.clipper().backgroundClipRect(clipRectsContext).rect());
     ASSERT(parentClipRect != LayoutRect::infiniteIntRect());
     m_ancestorClippingLayer->setPosition(FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
     m_ancestorClippingLayer->setSize(FloatSize(parentClipRect.size()));
 
     // backgroundRect is relative to compositingContainer, so subtract snappedOffsetFromCompositedAncestor.X/snappedOffsetFromCompositedAncestor.Y to get back to local coords.
     m_ancestorClippingLayer->setOffsetFromLayoutObject(parentClipRect.location() - snappedOffsetFromCompositedAncestor);
 
+    if (m_ancestorClippingMaskLayer) {
+        m_ancestorClippingMaskLayer->setPosition(m_ancestorClippingLayer->position()); // TODO(schenney) Don't need this?
+        m_ancestorClippingMaskLayer->setSize(m_ancestorClippingLayer->size());
+        m_ancestorClippingMaskLayer->setNeedsDisplay();
+    }
+
     // The primary layer is then parented in, and positioned relative to this clipping layer.
     graphicsLayerParentLocation = parentClipRect.location();
 }
 
 void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(const PaintLayer* compositingStackingContext, const PaintLayer* compositingContainer)
 {
     if (!m_overflowControlsHostLayer)
         return;
 
     LayoutPoint hostLayerPosition;
@@ skipping 404 matching lines @@
         }
     }
 
     // FIXME: we could refine this to only allocate backings for one of these layers if possible.
     if (m_foregroundLayer)
         m_foregroundLayer->setDrawsContent(hasPaintedContent);
 
     if (m_backgroundLayer)
         m_backgroundLayer->setDrawsContent(hasPaintedContent);
 
+    if (m_ancestorClippingMaskLayer)
+        m_ancestorClippingMaskLayer->setDrawsContent(true);
+
     if (m_maskLayer)
         m_maskLayer->setDrawsContent(true);
 
     if (m_childClippingMaskLayer)
         m_childClippingMaskLayer->setDrawsContent(true);
 }
 
 void CompositedLayerMapping::updateChildrenTransform()
 {
     if (GraphicsLayer* childTransformLayer = this->childTransformLayer()) {
         childTransformLayer->setTransform(owningLayer().perspectiveTransform());
         childTransformLayer->setTransformOrigin(owningLayer().perspectiveOrigin());
     }
 
     updateShouldFlattenTransform();
 }
 
 // Return true if the layers changed.
-bool CompositedLayerMapping::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip)
+bool CompositedLayerMapping::updateClippingLayers(
+    bool needsAncestorClip,
+    bool needsAncestorClippingMask,
+    bool needsDescendantClip)
 {
     bool layersChanged = false;
 
+    // TODO(schenney) correctly handle change to border radius while still needing ancestor clip
     if (needsAncestorClip) {
         if (!m_ancestorClippingLayer) {
             m_ancestorClippingLayer = createGraphicsLayer(CompositingReasonLayerForAncestorClip);
             m_ancestorClippingLayer->setMasksToBounds(true);
             m_ancestorClippingLayer->setShouldFlattenTransform(false);
+            if (needsAncestorClippingMask) {
+                m_ancestorClippingMaskLayer =
+                    createGraphicsLayer(CompositingReasonLayerForAncestorClippingMask);
+                m_ancestorClippingMaskLayer->setPaintingPhase(GraphicsLayerPaintAncestorClippingMask);
+                m_ancestorClippingLayer->setMaskLayer(m_ancestorClippingMaskLayer.get());
+            }
             layersChanged = true;
         }
     } else if (m_ancestorClippingLayer) {
+        if (m_ancestorClippingMaskLayer) {
+            m_ancestorClippingMaskLayer->removeFromParent();
+            m_ancestorClippingMaskLayer = nullptr;
+        }
         m_ancestorClippingLayer->removeFromParent();
         m_ancestorClippingLayer = nullptr;
         layersChanged = true;
     }
 
     if (needsDescendantClip) {
         // We don't need a child containment layer if we're the main frame layout view
         // layer. It's redundant as the frame clip above us will handle this clipping.
         if (!m_childContainmentLayer && !m_isMainFrameLayoutViewLayer) {
             m_childContainmentLayer = createGraphicsLayer(CompositingReasonLayerForDescendantClip);
@@ skipping 1132 matching lines @@
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintBackground)
         paintLayerFlags |= PaintLayerPaintingCompositingBackgroundPhase;
     else
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintForeground)
         paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
         paintLayerFlags |= PaintLayerPaintingCompositingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintChildClippingMask)
         paintLayerFlags |= PaintLayerPaintingChildClippingMaskPhase;
+    if (graphicsLayerPaintingPhase & GraphicsLayerPaintAncestorClippingMask)
+        paintLayerFlags |= PaintLayerPaintingAncestorClippingMaskPhase;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintOverflowContents)
         paintLayerFlags |= PaintLayerPaintingOverflowContents;
     if (graphicsLayerPaintingPhase & GraphicsLayerPaintCompositedScroll)
         paintLayerFlags |= PaintLayerPaintingCompositingScrollingPhase;
 
     if (graphicsLayer == m_backgroundLayer.get())
         paintLayerFlags |= PaintLayerPaintingRootBackgroundOnly;
     else if (compositor()->fixedRootBackgroundLayer() && m_owningLayer.isRootLayer())
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
 
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
         || graphicsLayer == m_maskLayer.get()
         || graphicsLayer == m_childClippingMaskLayer.get()
-        || graphicsLayer == m_scrollingContentsLayer.get()) {
+        || graphicsLayer == m_scrollingContentsLayer.get()
+        || graphicsLayer == m_ancestorClippingMaskLayer.get()) {
 
         bool paintRootBackgroundOntoScrollingContentsLayer = m_backgroundPaintsOntoScrollingContentsLayer;
         DCHECK(!paintRootBackgroundOntoScrollingContentsLayer || (!m_backgroundLayer && !m_foregroundLayer));
         if (paintRootBackgroundOntoScrollingContentsLayer) {
             if (graphicsLayer == m_scrollingContentsLayer.get())
                 paintLayerFlags &= ~PaintLayerPaintingSkipRootBackground;
             else
                 paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
         }
         GraphicsLayerPaintInfo paintInfo;
@@ skipping 174 matching lines @@
 {
     String name;
     if (graphicsLayer == m_graphicsLayer.get()) {
         name = m_owningLayer.debugName();
     } else if (graphicsLayer == m_squashingContainmentLayer.get()) {
         name = "Squashing Containment Layer";
     } else if (graphicsLayer == m_squashingLayer.get()) {
         name = "Squashing Layer (first squashed layer: " + (m_squashedLayers.size() > 0 ? m_squashedLayers[0].paintLayer->debugName() : "") + ")";
     } else if (graphicsLayer == m_ancestorClippingLayer.get()) {
         name = "Ancestor Clipping Layer";
+    } else if (graphicsLayer == m_ancestorClippingMaskLayer.get()) {
+        name = "Ancestor Clipping Mask Layer";
     } else if (graphicsLayer == m_foregroundLayer.get()) {
         name = m_owningLayer.debugName() + " (foreground) Layer";
     } else if (graphicsLayer == m_backgroundLayer.get()) {
         name = m_owningLayer.debugName() + " (background) Layer";
     } else if (graphicsLayer == m_childContainmentLayer.get()) {
         name = "Child Containment Layer";
     } else if (graphicsLayer == m_childTransformLayer.get()) {
         name = "Child Transform Layer";
     } else if (graphicsLayer == m_maskLayer.get()) {
         name = "Mask Layer";
@@ skipping 14 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink