Changeset 160894 in webkit

Timestamp:

Dec 19, 2013 7:48:10 PM (10 years ago)

Author:

Simon Fraser

Message:

Clarify the behavior of composited canvases
​https://bugs.webkit.org/show_bug.cgi?id=126042

Reviewed by Tim Horton.

Different platforms composite 2D and 3D canvases in different ways.

"Accelerated 2D" canvases, and WebGL are always set as GraphicsLayer
contents.

"IOSurface" canvases (Mac and iOS-only) get a compositing layer, but
paint into it (because this is fast, and a convenient way to get
synchronization).

So make these behaviors explicit in RenderLayerBacking and RenderLayerCompositor.
No behavior changes on OS X, bug fix on iOS.

• rendering/RenderLayerBacking.cpp:

(WebCore::canvasCompositingStrategy):
(WebCore::RenderLayerBacking::updateGraphicsLayerConfiguration):
(WebCore::RenderLayerBacking::containsPaintedContent):
(WebCore::RenderLayerBacking::contentChanged):

• rendering/RenderLayerBacking.h:
• rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::requiresCompositingForCanvas):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/RenderLayerBacking.cpp (modified) (4 diffs)
• rendering/RenderLayerBacking.h (modified) (1 diff)
• rendering/RenderLayerCompositor.cpp (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-12-19  Simon Fraser  <simon.fraser@apple.com>
+
+        Clarify the behavior of composited canvases
+        https://bugs.webkit.org/show_bug.cgi?id=126042
+
+        Reviewed by Tim Horton.
+
+        Different platforms composite 2D and 3D canvases in different ways.
+        
+        "Accelerated 2D" canvases, and WebGL are always set as GraphicsLayer
+        contents.
+        
+        "IOSurface" canvases (Mac and iOS-only) get a compositing layer, but
+        paint into it (because this is fast, and a convenient way to get
+        synchronization).
+        
+        So make these behaviors explicit in RenderLayerBacking and RenderLayerCompositor.
+        No behavior changes on OS X, bug fix on iOS.
+
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::canvasCompositingStrategy):
+        (WebCore::RenderLayerBacking::updateGraphicsLayerConfiguration):
+        (WebCore::RenderLayerBacking::containsPaintedContent):
+        (WebCore::RenderLayerBacking::contentChanged):
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::requiresCompositingForCanvas):
+
 2013-12-19  Joseph Pecoraro  <pecoraro@apple.com>
 

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -82 +82 @@
 static IntRect clipBox(RenderBox& renderer);
 
-static inline bool isAcceleratedCanvas(RenderObject* renderer)
-{
-#if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS)
-    if (renderer->isCanvas()) {
-        const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer->node());
-        if (CanvasRenderingContext* context = canvas->renderingContext())
-            return context->isAccelerated();
-    }
+CanvasCompositingStrategy canvasCompositingStrategy(const RenderObject& renderer)
+{
+    ASSERT(renderer.isCanvas());
+    
+    const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer.node());
+    CanvasRenderingContext* context = canvas->renderingContext();
+    if (!context || !context->isAccelerated())
+        return UnacceleratedCanvas;
+    
+    if (context->is3d())
+        return CanvasAsLayerContents;
+
+#if ENABLE(ACCELERATED_2D_CANVAS)
+    return CanvasAsLayerContents;
 #else
-    UNUSED_PARAM(renderer);
-#endif
-    return false;
+    return CanvasPaintedToLayer; // On Mac and iOS we paint accelerated canvases into their layers.
+#endif
 }
 
@@ -627 +632 @@
 #endif
 #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS)
-    else if (isAcceleratedCanvas(&renderer())) {
+    else if (renderer().isCanvas() && canvasCompositingStrategy(renderer()) == CanvasAsLayerContents) {
         const HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer().element());
         if (CanvasRenderingContext* context = canvas->renderingContext())
@@ -1833 +1838 @@
         return m_owningLayer.hasBoxDecorationsOrBackground();
 #endif
-#if PLATFORM(MAC) && !PLATFORM(IOS) && USE(CA)
-#elif ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS) || PLATFORM(IOS_SIMULATOR)
-    if (isAcceleratedCanvas(&renderer()))
+
+#if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS)
+    if (renderer().isCanvas() && canvasCompositingStrategy(renderer()) == CanvasAsLayerContents)
         return m_owningLayer.hasBoxDecorationsOrBackground();
 #endif
@@ -1884 +1889 @@
 
 #if ENABLE(WEBGL) || ENABLE(ACCELERATED_2D_CANVAS)
-    if ((changeType == CanvasChanged || changeType == CanvasPixelsChanged) && isAcceleratedCanvas(&renderer())) {
+    if ((changeType == CanvasChanged || changeType == CanvasPixelsChanged) && renderer().isCanvas() && canvasCompositingStrategy(renderer()) == CanvasAsLayerContents) {
         m_graphicsLayer->setContentsNeedsDisplay();
         return;

trunk/Source/WebCore/rendering/RenderLayerBacking.h

@@ -329 +329 @@
 };
 
+enum CanvasCompositingStrategy {
+    UnacceleratedCanvas,
+    CanvasPaintedToLayer,
+    CanvasAsLayerContents
+};
+CanvasCompositingStrategy canvasCompositingStrategy(const RenderObject&);
+
 } // namespace WebCore
 

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -2264 +2264 @@
 
     if (renderer.isCanvas()) {
-        HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer.element());
 #if USE(COMPOSITING_FOR_SMALL_CANVASES)
         bool isCanvasLargeEnoughToForceCompositing = true;
 #else
+        HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer.element());
         bool isCanvasLargeEnoughToForceCompositing = canvas->size().area() >= canvasAreaThresholdRequiringCompositing;
 #endif
-        return canvas->renderingContext() && canvas->renderingContext()->isAccelerated() && (canvas->renderingContext()->is3d() || isCanvasLargeEnoughToForceCompositing);
+        CanvasCompositingStrategy compositingStrategy = canvasCompositingStrategy(renderer);
+        return compositingStrategy == CanvasAsLayerContents || (compositingStrategy == CanvasPaintedToLayer && isCanvasLargeEnoughToForceCompositing);
     }