Large canvas does not honor containing div's border radius

Source/core/rendering/RenderLayerBacking.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 64 matching lines @@
 static inline bool isAcceleratedCanvas(RenderObject* renderer)
 {
     if (renderer->isCanvas()) {
         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             return context->isAccelerated();
     }
     return false;
 }
 
+static inline bool shouldClipRoundedBorders(RenderObject* renderer)
+{
+    return renderer->style()->hasBorderRadius()
+        && (isAcceleratedCanvas(renderer)

[jamesr, 2013/07/03 21:34:01]

i'm not sure i understand the purpose of these checks. if an object has a border
radius, why does it matter what type of content it is for the purpose of
clipping? we should clip canvas, plugins, videos and any other sort of
composited content the same way, shouldn't we?

[rosca, 2013/07/04 07:51:51]

This is the first case, where the content being clipped is rendered from an
external accelerated source (m_graphicsLayer->setContentsTo[Canvas|Media]). The
mask is set up to the external WebLayer through m_graphicsLayer.
The second case is when we should clip regular compositing layers as described
in http://crbug.com/157218. We can use the same mask for this case, but it
should be set up on a different layer (I think it's m_childContainmentLayer).
I would prefer to create another review for this case.

+            || (renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->allowsAcceleratedCompositing())
+            || renderer->isVideo());
+}
+
 // Get the scrolling coordinator in a way that works inside RenderLayerBacking's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(RenderLayer* layer)
 {
     Page* page = layer->renderer()->frame()->page();
     if (!page)
         return 0;
 
     return page->scrollingCoordinator();
 }
 
@@ skipping 66 matching lines @@
     if (m_backgroundLayer) {
         m_backgroundLayer->setShowDebugBorder(showBorder);
         m_backgroundLayer->setShowRepaintCounter(showRepaintCounter);
     }
 
     if (m_maskLayer) {
         m_maskLayer->setShowDebugBorder(showBorder);
         m_maskLayer->setShowRepaintCounter(showRepaintCounter);
     }
 
+    if (m_borderRadiusLayer) {
+        m_borderRadiusLayer->setShowDebugBorder(showBorder);
+        m_borderRadiusLayer->setShowRepaintCounter(showRepaintCounter);
+    }
+
     if (m_layerForHorizontalScrollbar)
         m_layerForHorizontalScrollbar->setShowDebugBorder(showBorder);
 
     if (m_layerForVerticalScrollbar)
         m_layerForVerticalScrollbar->setShowDebugBorder(showBorder);
 
     if (m_layerForScrollCorner)
         m_layerForScrollCorner->setShowDebugBorder(showBorder);
 
     if (m_scrollingLayer)
@@ skipping 32 matching lines @@
     if (m_graphicsLayer)
         m_graphicsLayer->removeFromParent();
 
     m_ancestorClippingLayer = nullptr;
     m_contentsContainmentLayer = nullptr;
     m_graphicsLayer = nullptr;
     m_foregroundLayer = nullptr;
     m_backgroundLayer = nullptr;
     m_childContainmentLayer = nullptr;
     m_maskLayer = nullptr;
+    m_borderRadiusLayer = nullptr;
 
     m_scrollingLayer = nullptr;
     m_scrollingContentsLayer = nullptr;
 }
 
 void RenderLayerBacking::updateOpacity(const RenderStyle* style)
 {
     m_graphicsLayer->setOpacity(compositingOpacity(style->opacity()));
 }
 
@@ skipping 191 matching lines @@
 
     if (updateScrollingLayers(m_owningLayer->needsCompositedScrolling()))
         layerConfigChanged = true;
 
     if (layerConfigChanged)
         updateInternalHierarchy();
 
     if (updateMaskLayer(renderer->hasMask()))
         m_graphicsLayer->setMaskLayer(m_maskLayer.get());
 
+    if (updateBorderRadiusLayer(shouldClipRoundedBorders(renderer)))
+        m_graphicsLayer->setBorderRadiusLayer(m_borderRadiusLayer.get());
+
     if (m_owningLayer->hasReflection()) {
         if (m_owningLayer->reflectionLayer()->backing()) {
             GraphicsLayer* reflectionLayer = m_owningLayer->reflectionLayer()->backing()->graphicsLayer();
             m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
         }
     } else
         m_graphicsLayer->setReplicatedByLayer(0);
 
     updateBackgroundColor(isSimpleContainerCompositingLayer());
     updateRootLayerConfiguration();
@@ skipping 615 matching lines @@
         m_maskLayer = nullptr;
         layerChanged = true;
     }
 
     if (layerChanged)
         m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer());
 
     return layerChanged;
 }
 
+bool RenderLayerBacking::updateBorderRadiusLayer(bool needsBorderRadiusLayer)
+{
+    bool layerChanged = false;
+    if (needsBorderRadiusLayer) {
+        if (!m_borderRadiusLayer) {
+            m_borderRadiusLayer = createGraphicsLayer("BorderRadiusMask", CompositingReasonLayerForMask);
+            m_borderRadiusLayer->setDrawsContent(true);
+            m_borderRadiusLayer->setPaintingPhase(GraphicsLayerPaintBorderRadiusMask);
+            layerChanged = true;
+        }
+    } else if (m_borderRadiusLayer) {
+        m_borderRadiusLayer = nullptr;
+        layerChanged = true;
+    }
+    return layerChanged;
+}
+
 bool RenderLayerBacking::updateScrollingLayers(bool needsScrollingLayers)
 {
     ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(m_owningLayer);
 
     bool layerChanged = false;
     if (needsScrollingLayers) {
         if (!m_scrollingLayer) {
             // Outer layer which corresponds with the scroll view.
             m_scrollingLayer = createGraphicsLayer("Scrolling container", CompositingReasonLayerForClip);
             m_scrollingLayer->setDrawsContent(false);
@@ skipping 467 matching lines @@
     
     if (m_foregroundLayer && m_foregroundLayer->drawsContent())
         m_foregroundLayer->setNeedsDisplay();
 
     if (m_backgroundLayer && m_backgroundLayer->drawsContent())
         m_backgroundLayer->setNeedsDisplay();
 
     if (m_maskLayer && m_maskLayer->drawsContent())
         m_maskLayer->setNeedsDisplay();
 
+    if (m_borderRadiusLayer && m_borderRadiusLayer->drawsContent())
+        m_borderRadiusLayer->setNeedsDisplay();
+
     if (m_scrollingContentsLayer && m_scrollingContentsLayer->drawsContent())
         m_scrollingContentsLayer->setNeedsDisplay();
 }
 
 // r is in the coordinate space of the layer's render object
 void RenderLayerBacking::setContentsNeedDisplayInRect(const IntRect& r)
 {
     ASSERT(!paintsIntoCompositedAncestor());
 
     if (m_graphicsLayer && m_graphicsLayer->drawsContent()) {
@@ skipping 14 matching lines @@
         layerDirtyRect.move(-m_backgroundLayer->offsetFromRenderer());
         m_backgroundLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 
     if (m_maskLayer && m_maskLayer->drawsContent()) {
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_maskLayer->offsetFromRenderer());
         m_maskLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 
+    if (m_borderRadiusLayer && m_borderRadiusLayer->drawsContent()) {
+        IntRect layerDirtyRect = r;
+        layerDirtyRect.move(-m_borderRadiusLayer->offsetFromRenderer());
+        m_borderRadiusLayer->setNeedsDisplayInRect(layerDirtyRect);
+    }
+
     if (m_scrollingContentsLayer && m_scrollingContentsLayer->drawsContent()) {
         IntRect layerDirtyRect = r;
         layerDirtyRect.move(-m_scrollingContentsLayer->offsetFromRenderer());
         m_scrollingContentsLayer->setNeedsDisplayInRect(layerDirtyRect);
     }
 }
 
 void RenderLayerBacking::paintIntoLayer(const GraphicsLayer* graphicsLayer, GraphicsContext* context,
                     const IntRect& paintDirtyRect, // In the coords of rootLayer.
                     PaintBehavior paintBehavior, GraphicsLayerPaintingPhase paintingPhase)
 {
     if (paintsIntoCompositedAncestor()) {
         ASSERT_NOT_REACHED();
         return;
     }
 
     FontCachePurgePreventer fontCachePurgePreventer;
     
     RenderLayer::PaintLayerFlags paintFlags = 0;
     if (paintingPhase & GraphicsLayerPaintBackground)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingBackgroundPhase;
     if (paintingPhase & GraphicsLayerPaintForeground)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingForegroundPhase;
     if (paintingPhase & GraphicsLayerPaintMask)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingMaskPhase;
+    if (paintingPhase & GraphicsLayerPaintBorderRadiusMask)
+        paintFlags |= RenderLayer::PaintLayerPaintingCompositingBorderRadiusMaskPhase;
     if (paintingPhase & GraphicsLayerPaintOverflowContents)
         paintFlags |= RenderLayer::PaintLayerPaintingOverflowContents;
     if (paintingPhase & GraphicsLayerPaintCompositedScroll)
         paintFlags |= RenderLayer::PaintLayerPaintingCompositingScrollingPhase;
 
     if (graphicsLayer == m_backgroundLayer)
         paintFlags |= (RenderLayer::PaintLayerPaintingRootBackgroundOnly | RenderLayer::PaintLayerPaintingCompositingForegroundPhase); // Need PaintLayerPaintingCompositingForegroundPhase to walk child layers.
     else if (m_backgroundLayer)
         paintFlags |= RenderLayer::PaintLayerPaintingSkipRootBackground;
     
@@ skipping 26 matching lines @@
 {
 #ifndef NDEBUG
     if (Page* page = renderer()->frame()->page())
         page->setIsPainting(true);
 #endif
 
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
         || graphicsLayer == m_maskLayer.get()
+        || graphicsLayer == m_borderRadiusLayer.get()
         || graphicsLayer == m_scrollingContentsLayer.get()) {
         InspectorInstrumentation::willPaint(renderer());
 
         // The dirtyRect is in the coords of the painting root.
         IntRect dirtyRect = clip;
         if (!(paintingPhase & GraphicsLayerPaintOverflowContents))
             dirtyRect.intersect(compositedBounds());
 
         // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
         paintIntoLayer(graphicsLayer, &context, dirtyRect, PaintBehaviorNormal, paintingPhase);
@@ skipping 257 matching lines @@
     double backingMemory;
     
     // m_ancestorClippingLayer, m_contentsContainmentLayer and m_childContainmentLayer are just used for masking or containment, so have no backing.
     backingMemory = m_graphicsLayer->backingStoreMemoryEstimate();
     if (m_foregroundLayer)
         backingMemory += m_foregroundLayer->backingStoreMemoryEstimate();
     if (m_backgroundLayer)
         backingMemory += m_backgroundLayer->backingStoreMemoryEstimate();
     if (m_maskLayer)
         backingMemory += m_maskLayer->backingStoreMemoryEstimate();
+    if (m_borderRadiusLayer)
+        backingMemory += m_borderRadiusLayer->backingStoreMemoryEstimate();
 
     if (m_scrollingContentsLayer)
         backingMemory += m_scrollingContentsLayer->backingStoreMemoryEstimate();
 
     if (m_layerForHorizontalScrollbar)
         backingMemory += m_layerForHorizontalScrollbar->backingStoreMemoryEstimate();
 
     if (m_layerForVerticalScrollbar)
         backingMemory += m_layerForVerticalScrollbar->backingStoreMemoryEstimate();
 
     if (m_layerForScrollCorner)
         backingMemory += m_layerForScrollCorner->backingStoreMemoryEstimate();
     
     return backingMemory;
 }
 
 void RenderLayerBacking::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, PlatformMemoryTypes::Rendering);
     info.addWeakPointer(m_owningLayer);
     info.addMember(m_ancestorClippingLayer, "ancestorClippingLayer");
     info.addMember(m_contentsContainmentLayer, "contentsContainmentLayer");
     info.addMember(m_graphicsLayer, "graphicsLayer");
     info.addMember(m_foregroundLayer, "foregroundLayer");
     info.addMember(m_backgroundLayer, "backgroundLayer");
     info.addMember(m_childContainmentLayer, "childContainmentLayer");
     info.addMember(m_maskLayer, "maskLayer");
+    info.addMember(m_borderRadiusLayer, "borderRadiusLayer");
     info.addMember(m_layerForHorizontalScrollbar, "layerForHorizontalScrollbar");
     info.addMember(m_layerForVerticalScrollbar, "layerForVerticalScrollbar");
     info.addMember(m_layerForScrollCorner, "layerForScrollCorner");
     info.addMember(m_scrollingLayer, "scrollingLayer");
     info.addMember(m_scrollingContentsLayer, "scrollingContentsLayer");
 }
 
 } // namespace WebCore