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 184 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 202 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())

[chrishtr, 2016/12/02 19:21:47]

This looks identical to 495-496.

[Stephen Chennney, 2016/12/07 21:39:38]

Done.

+    return;
 
   // 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))
+  bool needsAncestorClip = false;
+  bool needsAncestorClippingMask = false;
+  owningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
+      scrollParent, needsAncestorClip, needsAncestorClippingMask);
+  if (updateClippingLayers(needsAncestorClip, needsAncestorClippingMask,
+                           needsDescendantsClippingLayer))
     layerConfigChanged = true;
 
   bool scrollingConfigChanged = false;
   if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
     layerConfigChanged = true;
     scrollingConfigChanged = true;
   }
 
   // If the outline needs to draw over the composited scrolling contents layer
   // or scrollbar layers it needs to be drawn into a separate layer.
@@ skipping 511 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->setOffsetFromLayoutObject(
+        IntSize(parentClipRect.location().x(), parentClipRect.location().y()));
+    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 531 matching lines @@
   // layer (i.e. if there is nothing actually drawn into the
   // background anymore.)
   // "hasPaintedContent" should be calculated in a way that does not take the
   // outline into consideration.
   if (m_backgroundLayer)
     m_backgroundLayer->setDrawsContent(hasPaintedContent);
 
   if (m_decorationOutlineLayer)
     m_decorationOutlineLayer->setDrawsContent(true);
 
+  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);
       layersChanged = true;
     }
   } else if (m_ancestorClippingLayer) {
+    if (m_ancestorClippingMaskLayer) {
+      m_ancestorClippingMaskLayer->removeFromParent();
+      m_ancestorClippingMaskLayer = nullptr;
+    }
     m_ancestorClippingLayer->removeFromParent();
     m_ancestorClippingLayer = nullptr;
     layersChanged = true;
   }
 
+  if (needsAncestorClippingMask) {
+    DCHECK(m_ancestorClippingLayer);
+    if (!m_ancestorClippingMaskLayer) {
+      m_ancestorClippingMaskLayer =
+          createGraphicsLayer(CompositingReasonLayerForAncestorClippingMask);
+      m_ancestorClippingMaskLayer->setPaintingPhase(
+          GraphicsLayerPaintAncestorClippingMask);
+      m_ancestorClippingLayer->setMaskLayer(
+          m_ancestorClippingMaskLayer.get());
+      layersChanged = true;
+    }
+  } else if (m_ancestorClippingLayer && m_ancestorClippingMaskLayer) {

[chrishtr, 2016/12/02 19:21:47]

Is it strictly necessary to check for m_ancestorClippingLayer here?

[Stephen Chennney, 2016/12/07 21:39:38]

No, it's not necessary, despite me thinking it was. We can only have a
m_ancestorClippingMaskLayer if we have a m_ancestorClippingLayer because if the
latter doesn't exist it's because it never existed (and hence no mask) or we
removed it just above, in which case we removed its mask. Either way the
m_ancestorClippingMaskLayer will be null.

+    m_ancestorClippingMaskLayer->removeFromParent();
+    m_ancestorClippingMaskLayer = nullptr;
+    m_ancestorClippingLayer->setMaskLayer(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);
       m_childContainmentLayer->setMasksToBounds(true);
       layersChanged = true;
     }
@@ skipping 202 matching lines @@
     f(mapping->squashingLayer());
 
   if (((mode & ApplyToMaskLayers) || (mode & ApplyToContentLayers) ||
        (mode & ApplyToNonScrollingContentLayers)) &&
       mapping->maskLayer())
     f(mapping->maskLayer());
   if (((mode & ApplyToMaskLayers) || (mode & ApplyToContentLayers) ||
        (mode & ApplyToNonScrollingContentLayers)) &&
       mapping->childClippingMaskLayer())
     f(mapping->childClippingMaskLayer());
+  if (((mode & ApplyToMaskLayers) || (mode & ApplyToContentLayers) ||
+       (mode & ApplyToNonScrollingContentLayers)) &&
+      mapping->ancestorClippingMaskLayer())
+    f(mapping->ancestorClippingMaskLayer());
 
   if (((mode & ApplyToBackgroundLayer) || (mode & ApplyToContentLayers) ||
        (mode & ApplyToNonScrollingContentLayers)) &&
       mapping->backgroundLayer())
     f(mapping->backgroundLayer());
 
   if ((mode & ApplyToScrollbarLayers) && mapping->layerForHorizontalScrollbar())
     f(mapping->layerForHorizontalScrollbar());
   if ((mode & ApplyToScrollbarLayers) && mapping->layerForVerticalScrollbar())
     f(mapping->layerForVerticalScrollbar());
@@ skipping 15 matching lines @@
 
 void CompositedLayerMapping::updateRenderingContext() {
   // All layers but the squashing layer (which contains 'alien' content) should
   // be included in this rendering context.
   int id = 0;
 
   // NB, it is illegal at this point to query an ancestor's compositing state.
   // Some compositing reasons depend on the compositing state of ancestors. So
   // if we want a rendering context id for the context root, we cannot ask for
   // the id of its associated WebLayer now; it may not have one yet. We could do
-  // a second past after doing the compositing updates to get these ids, but
+  // a second pass after doing the compositing updates to get these ids, but
   // this would actually be harmful. We do not want to attach any semantic
   // meaning to the context id other than the fact that they group a number of
   // layers together for the sake of 3d sorting. So instead we will ask the
   // compositor to vend us an arbitrary, but consistent id.
   if (PaintLayer* root = m_owningLayer.renderingContextRoot()) {
     if (Node* node = root->layoutObject()->node())
       id = static_cast<int>(PtrHash<Node>::hash(node));
   }
 
   UpdateRenderingContextFunctor functor = {id};
@@ skipping 283 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 519 matching lines @@
   translation.translate(-offset.width(), -offset.height());
   TransformRecorder transformRecorder(context, graphicsLayer, translation);
 
   // The dirtyRect is in the coords of the painting root.
   IntRect dirtyRect(clip);
   dirtyRect.move(offset);
 
   if (!(paintLayerFlags & PaintLayerPaintingOverflowContents)) {
     LayoutRect bounds = paintInfo.compositedBounds;
     bounds.move(paintInfo.paintLayer->subpixelAccumulation());
+    if (paintLayerFlags & PaintLayerPaintingAncestorClippingMaskPhase)
+      bounds.move(offset);
     dirtyRect.intersect(pixelSnappedIntRect(bounds));
   } else {
     dirtyRect.move(
         roundedIntSize(paintInfo.paintLayer->subpixelAccumulation()));
   }
 
 #if ENABLE(ASSERT)
   if (!layoutObject()->view()->frame() ||
       !layoutObject()->view()->frame()->shouldThrottleRendering())
     paintInfo.paintLayer->layoutObject()->assertSubtreeIsLaidOut();
@@ skipping 252 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 (graphicsLayerPaintingPhase & GraphicsLayerPaintDecoration)
     paintLayerFlags |= PaintLayerPaintingCompositingDecorationPhase;
 
   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_decorationOutlineLayer.get()) {
+      graphicsLayer == m_decorationOutlineLayer.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 if (!m_backgroundPaintsOntoGraphicsLayer)
         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 16 matching lines @@
   } else if (graphicsLayer == m_decorationOutlineLayer.get()) {
     name = "Decoration Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink