Changeset 91599 in webkit

Timestamp:

Jul 22, 2011 1:04:56 PM (13 years ago)

Author:

alokp@chromium.org

Message:

Use software rendering for small canvas
​https://bugs.webkit.org/show_bug.cgi?id=64958

Reviewed by Stephen White.

No new tests. Does not affect rendering output, just canvas backing.
If there is a regression, they should be caught by existing canvas tests.

• html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::reset):

• html/canvas/CanvasRenderingContext2D.cpp:

(WebCore::shouldAccelerateCanvas):
(WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
(WebCore::CanvasRenderingContext2D::reset):
(WebCore::CanvasRenderingContext2D::platformLayer):
(WebCore::CanvasRenderingContext2D::clearAcceleration):
(WebCore::CanvasRenderingContext2D::resetAcceleration):

• html/canvas/CanvasRenderingContext2D.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• html/HTMLCanvasElement.cpp (modified) (1 diff)
• html/canvas/CanvasRenderingContext2D.cpp (modified) (5 diffs)
• html/canvas/CanvasRenderingContext2D.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-07-22  Alok Priyadarshi  <alokp@chromium.org>
+
+        Use software rendering for small canvas
+        https://bugs.webkit.org/show_bug.cgi?id=64958
+
+        Reviewed by Stephen White.
+
+        No new tests. Does not affect rendering output, just canvas backing.
+        If there is a regression, they should be caught by existing canvas tests.
+
+        * html/HTMLCanvasElement.cpp:
+        (WebCore::HTMLCanvasElement::reset):
+        * html/canvas/CanvasRenderingContext2D.cpp:
+        (WebCore::shouldAccelerateCanvas):
+        (WebCore::CanvasRenderingContext2D::CanvasRenderingContext2D):
+        (WebCore::CanvasRenderingContext2D::reset):
+        (WebCore::CanvasRenderingContext2D::platformLayer):
+        (WebCore::CanvasRenderingContext2D::clearAcceleration):
+        (WebCore::CanvasRenderingContext2D::resetAcceleration):
+        * html/canvas/CanvasRenderingContext2D.h:
+
 2011-07-21  Adrienne Walker  <enne@google.com>
 

trunk/Source/WebCore/html/HTMLCanvasElement.cpp

@@ -246 +246 @@
 #endif
 
-    if (m_context && m_context->is2d())
-        static_cast<CanvasRenderingContext2D*>(m_context.get())->reset();
+    if (m_context && m_context->is2d()) {
+        CanvasRenderingContext2D* context2D = static_cast<CanvasRenderingContext2D*>(m_context.get());
+        bool wasAccelerated = context2D->isAccelerated();
+        context2D->reset();
+#if USE(IOSURFACE_CANVAS_BACKING_STORE) || (ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING))
+        // Recalculate compositing requirements if acceleration state changed.
+        if (context2D->isAccelerated() != wasAccelerated)
+            setNeedsStyleRecalc(SyntheticStyleChange);
+#else
+        UNUSED_PARAM(wasAccelerated);
+#endif
+    }
 
     if (RenderObject* renderer = this->renderer()) {

trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp

@@ -98 +98 @@
 }
 
+#if ENABLE(ACCELERATED_2D_CANVAS)
+// Number of pixels in a canvas below which we use software
+// rendering. This is obviously an arbitrary number. A more precise
+// number would depend on machine architecture and canvas contents.
+static const int numPixelsThreshold = 128 * 128;
+
+static bool shouldAccelerateCanvas(const HTMLCanvasElement* canvas)
+{
+    const Page* page = canvas->document()->page();
+    if (!page)
+        return false;
+
+    const Settings* settings = page->settings();
+    if (!settings->accelerated2dCanvasEnabled())
+        return false;
+
+    // Do not use acceleration for small canvas.
+    // For every accelerated canvas there is an extra back-buffer and a texture copy.
+    // Small canvases are also widely used for stylized fonts. Anti-aliasing
+    // text in hardware at that scale is generally slower.
+    if (canvas->width() * canvas->height() < numPixelsThreshold)
+        return false;
+
+    return true;
+}
+#endif
+
 class CanvasStrokeStyleApplier : public StrokeStyleApplier {
 public:
@@ -137 +164 @@
 
 #if ENABLE(ACCELERATED_2D_CANVAS)
-    Page* p = canvas->document()->page();
-    if (!p)
-        return;
-    if (!(p->settings()->accelerated2dCanvasEnabled() || p->settings()->legacyAccelerated2dCanvasEnabled()))
-        return;
-    if (GraphicsContext* c = drawingContext()) {
-        m_context3D = p->sharedGraphicsContext3D();
-        if (m_context3D) {
-            m_drawingBuffer = m_context3D->createDrawingBuffer(IntSize(canvas->width(), canvas->height()));
-            if (!m_drawingBuffer) {
-                c->setGraphicsContext3D(0, 0, IntSize());
-                m_context3D.clear();
-            } else
-                c->setGraphicsContext3D(m_context3D.get(), m_drawingBuffer.get(), IntSize(canvas->width(), canvas->height()));
-        }
-    }
+    resetAcceleration();
 #endif
 }
@@ -204 +216 @@
     m_path.clear();
 #if ENABLE(ACCELERATED_2D_CANVAS)
-    if (GraphicsContext* c = drawingContext()) {
-        if (m_context3D && m_drawingBuffer) {
-            if (m_drawingBuffer->reset(IntSize(canvas()->width(), canvas()->height()))) {
-                c->setGraphicsContext3D(m_context3D.get(), m_drawingBuffer.get(), IntSize(canvas()->width(), canvas()->height()));
-            } else {
-                c->setGraphicsContext3D(0, 0, IntSize());
-                m_drawingBuffer.clear();
-                m_context3D.clear();
-            }
+    resetAcceleration();
 #if USE(ACCELERATED_COMPOSITING)
-            RenderBox* renderBox = canvas()->renderBox();
-            if (renderBox && renderBox->hasLayer() && renderBox->layer()->hasAcceleratedCompositing())
-                renderBox->layer()->contentChanged(RenderLayer::CanvasChanged);
-#endif
-        }
-    }
+    RenderBox* renderBox = canvas()->renderBox();
+    if (renderBox && renderBox->hasLayer() && renderBox->layer()->hasAcceleratedCompositing())
+        renderBox->layer()->contentChanged(RenderLayer::CanvasChanged);
+#endif
 #endif
 }
@@ -2024 +2026 @@
 }
 
-#if ENABLE(ACCELERATED_2D_CANVAS) && USE(ACCELERATED_COMPOSITING)
+#if ENABLE(ACCELERATED_2D_CANVAS)
+#if USE(ACCELERATED_COMPOSITING)
 PlatformLayer* CanvasRenderingContext2D::platformLayer() const
 {
@@ -2031 +2034 @@
 #endif
 
+void CanvasRenderingContext2D::clearAcceleration()
+{
+    if (GraphicsContext* ctx = drawingContext())
+        ctx->setGraphicsContext3D(0, 0, IntSize());
+
+    m_drawingBuffer.clear();
+    m_context3D.clear();
+}
+
+void CanvasRenderingContext2D::resetAcceleration()
+{
+    if (!shouldAccelerateCanvas(canvas())) {
+        clearAcceleration();
+        return;
+    }
+
+    // Try to accelerate.
+    GraphicsContext* ctx = drawingContext();
+    if (!ctx) {
+        clearAcceleration();
+        return;
+    }
+
+    if (!m_context3D) {
+        Page* page = canvas()->document()->page();
+        m_context3D = page->sharedGraphicsContext3D();
+        if (!m_context3D) {
+            clearAcceleration();
+            return;
+        }
+    }
+
+    if (m_drawingBuffer) {
+        if (!m_drawingBuffer->reset(canvas()->size())) {
+            clearAcceleration();
+            return;
+        }
+    } else {
+        m_drawingBuffer = m_context3D->createDrawingBuffer(canvas()->size());
+        if (!m_drawingBuffer) {
+            clearAcceleration();
+            return;
+        }
+    }
+
+    ctx->setGraphicsContext3D(m_context3D.get(), m_drawingBuffer.get(), canvas()->size());
+}
+#endif
+
 } // namespace WebCore

trunk/Source/WebCore/html/canvas/CanvasRenderingContext2D.h

@@ -296 +296 @@
     void prepareGradientForDashboard(CanvasGradient* gradient) const;
 
+#if ENABLE(ACCELERATED_2D_CANVAS)
+    void clearAcceleration();
+    void resetAcceleration();
+#endif
+
     Vector<State, 1> m_stateStack;
     bool m_usesCSSCompatibilityParseMode;