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 182 matching lines @@
     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 23 matching lines @@
   updateStickyConstraints(layoutObject()->styleRef());
   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 190 matching lines @@
 }
 
 void CompositedLayerMapping::updateCompositingReasons() {
   // All other layers owned by this mapping will have the same compositing
   // reason for their lifetime, so they are initialized only when created.
   m_graphicsLayer->setCompositingReasons(m_owningLayer.getCompositingReasons());
   m_graphicsLayer->setSquashingDisallowedReasons(
       m_owningLayer.getSquashingDisallowedReasons());
 }
 
-bool CompositedLayerMapping::
-    owningLayerClippedByLayerNotAboveCompositedAncestor(
-        const PaintLayer* scrollParent) {
+void CompositedLayerMapping::
+    owningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
+        const PaintLayer* scrollParent,
+        bool& owningLayerIsClipped,
+        bool& owningLayerIsMasked) {
+  owningLayerIsClipped = false;
+  owningLayerIsMasked = false;
+
   if (!m_owningLayer.parent())
-    return false;
+    return;
 
   const PaintLayer* compositingAncestor =
       m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
   if (!compositingAncestor)
-    return false;
+    return;
 
   const LayoutObject* clippingContainer = m_owningLayer.clippingContainer();
   if (!clippingContainer)
-    return false;
+    return;
 
   if (clippingContainer->enclosingLayer() == scrollParent)
-    return false;
+    return;
 
   if (clippingContainer->enclosingLayer()->hasRootScrollerAsDescendant())
-    return false;
+    return;
 
   if (compositingAncestor->layoutObject()->isDescendantOf(clippingContainer))
-    return false;
+    return;
+
+  if (clippingContainer->enclosingLayer()->hasRootScrollerAsDescendant())
+    return;

[Stephen Chennney, 2016/11/08 21:42:51]

flackr@ told me we need this, and I agree.

 
   // We ignore overflow clip here; we want composited overflow content to
   // behave as if it lives in an unclipped universe so it can prepaint, etc.
   // This means that we need to check if we are actually clipped before
   // setting up m_ancestorClippingLayer otherwise
   // 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();
+  owningLayerIsClipped = parentClipRect != LayoutRect::infiniteIntRect();
+
+  DCHECK(clippingContainer->style());
+  owningLayerIsMasked =
+      owningLayerIsClipped && 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 35 matching lines @@
     needsDescendantsClippingLayer = false;
 
   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);
 
-  if (updateClippingLayers(needsAncestorClip, needsDescendantsClippingLayer))
+  // TODO(schenney): Can we apply a border radius clip with this ancestor clip
+  // layer? Why do we need a mask for border radius, rather than modifying the
+  // clip rects applied to the ancestor clip?

[Stephen Chennney, 2016/11/08 21:42:51]

This comment should be removed. I know why we have to do it this way.

+  bool needsAncestorClip = false;
+  bool needsAncestorClippingMask = false;
+  owningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
+      scrollParent, needsAncestorClip, needsAncestorClippingMask);
+  fprintf(stderr, "needsAnsectorClip %s, needsAncestorClippingMask %s\n",
+      needsAncestorClip ? "true" : "false",
+      needsAncestorClippingMask ? "true" : "false");
+  if (updateClippingLayers(needsAncestorClip, needsAncestorClippingMask,
+                           needsDescendantsClippingLayer))
     layerConfigChanged = true;
 
   bool scrollingConfigChanged = false;
   if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
     layerConfigChanged = true;
     scrollingConfigChanged = true;
   }
 
   if (updateOverflowControlsLayers(
           requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(),
@@ skipping 487 matching lines @@
   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?

[Stephen Chennney, 2016/11/08 21:42:51]

Looks like we do not need this, but more testing is required.

+    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,
     IntPoint graphicsLayerParentLocation) {
   if (!m_overflowControlsHostLayer)
@@ skipping 494 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;
 
   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());
+      } else if (!needsAncestorClippingMask) {
+        if (m_ancestorClippingMaskLayer) {
+          m_ancestorClippingMaskLayer = nullptr;
+          m_ancestorClippingLayer->setMaskLayer(nullptr);
+        }
+      }
       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) {
@@ skipping 521 matching lines @@
   // Only the topmost layer has a scroll parent. All other layers have a null
   // scroll parent.
   if (layer != topmostLayer)
     clipParent = 0;
 
   scrollingCoordinator->updateClipParentForGraphicsLayer(layer, clipParent);
 }
 
 void CompositedLayerMapping::updateClipParent(const PaintLayer* scrollParent) {
   const PaintLayer* clipParent = nullptr;
-  if (!owningLayerClippedByLayerNotAboveCompositedAncestor(scrollParent)) {
+  bool haveAncestorClipLayer = false;
+  bool haveAncestorMaskLayer = false;
+  owningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
+      scrollParent, haveAncestorClipLayer, haveAncestorMaskLayer);
+  if (!haveAncestorClipLayer) {
     clipParent = m_owningLayer.clipParent();
     if (clipParent)
       clipParent =
           clipParent->enclosingLayerWithCompositedLayerMapping(IncludeSelf);
   }
 
   if (ScrollingCoordinator* scrollingCoordinator =
           scrollingCoordinatorFromLayer(m_owningLayer)) {
     GraphicsLayer* topmostLayer = childForSuperlayers();
     updateClipParentForGraphicsLayer(m_squashingContainmentLayer.get(),
@@ skipping 789 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_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;
     }
@@ skipping 234 matching lines @@
   } 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