Bug 17269: Deobfuscate CanvasRenderingContext2D.cpp

Refactor CanvasRenderingContext2D::drawImage(HTMLCanvasElement) to remove evil ifdefs

Reviewed by Dan B.

Add logic draw(ImageBuffer*) method to GraphicsContext to handle
painting the source canvas content.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@30336 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 64f0f261d952dcf0df141d1f3faf2a7e85c74e9d..f85ae22c2c72d6ea099fe9ca278d27891906cdf3 100644 (file)
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,27 @@
+2008-02-15  Oliver Hunt  <oliver@apple.com>
+
+        Reviewed by Dan B.
+
+        Bug 17269: Deobfuscate CanvasRenderingContext2D.cpp
+        Refactor CanvasRenderingContext2D::drawImage(HTMLCanvasElement) to remove evil ifdefs
+
+        Add logic draw(ImageBuffer*) method to GraphicsContext to handle
+        painting the source canvas content.
+
+        * html/CanvasRenderingContext2D.cpp:
+        (WebCore::CanvasRenderingContext2D::drawImage):
+        * html/HTMLCanvasElement.cpp:
+        (WebCore::HTMLCanvasElement::buffer):
+        * html/HTMLCanvasElement.h:
+        * platform/graphics/GraphicsContext.h:
+        * platform/graphics/cairo/GraphicsContextCairo.cpp:
+        (WebCore::GraphicsContext::drawImage):
+        * platform/graphics/cg/GraphicsContextCG.cpp:
+        (WebCore::GraphicsContext::paintBuffer):
+        (WebCore::GraphicsContext::drawImage):
+        * platform/graphics/qt/GraphicsContextQt.cpp:
+        (WebCore::GraphicsContext::drawImage):
+
 2008-02-15  Kevin Ollivier  <kevino@theolliviers.com>
 
         Reviewed by David Hyatt.

diff --git a/WebCore/html/CanvasRenderingContext2D.cpp b/WebCore/html/CanvasRenderingContext2D.cpp
index ea01012f2380e1d837524070e2884a7d0d988fd3..aab0c0b647e51d82734d5c0d38b1823445ce600d 100644 (file)
--- a/WebCore/html/CanvasRenderingContext2D.cpp
+++ b/WebCore/html/CanvasRenderingContext2D.cpp
@@ -957,65 +957,12 @@ void CanvasRenderingContext2D::drawImage(HTMLCanvasElement* canvas, const FloatR
     FloatRect destRect = c->roundToDevicePixels(dstRect);
         
     // FIXME: Do this through platform-independent GraphicsContext API.
-#if PLATFORM(CG)
-    CGImageRef platformImage = canvas->createPlatformImage();
-    if (!platformImage)
+    ImageBuffer* buffer = canvas->buffer();
+    if (!buffer)
         return;
-
+    
     willDraw(destRect);
-
-    float iw = CGImageGetWidth(platformImage);
-    float ih = CGImageGetHeight(platformImage);
-    if (sourceRect.x() == 0 && sourceRect.y() == 0 && iw == sourceRect.width() && ih == sourceRect.height()) {
-        // Fast path, yay!
-        CGContextDrawImage(c->platformContext(), destRect, platformImage);
-    } else {
-        // Slow path, boo!
-        // Create a new bitmap of the appropriate size and then draw that into our context.
-
-        size_t csw = static_cast<size_t>(ceilf(sourceRect.width()));
-        size_t csh = static_cast<size_t>(ceilf(sourceRect.height()));
-
-        CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-        size_t bytesPerRow = csw * 4;
-        void* buffer = fastMalloc(csh * bytesPerRow);
-
-        CGContextRef clippedSourceContext = CGBitmapContextCreate(buffer, csw, csh,
-            8, bytesPerRow, colorSpace, kCGImageAlphaPremultipliedLast);
-        CGColorSpaceRelease(colorSpace);
-        CGContextTranslateCTM(clippedSourceContext, -sourceRect.x(), -sourceRect.y());
-        CGContextDrawImage(clippedSourceContext, CGRectMake(0, 0, iw, ih), platformImage);
-
-        CGImageRef clippedSourceImage = CGBitmapContextCreateImage(clippedSourceContext);
-        CGContextRelease(clippedSourceContext);
-
-        CGContextDrawImage(c->platformContext(), destRect, clippedSourceImage);
-        CGImageRelease(clippedSourceImage);
-        
-        fastFree(buffer);
-    }
-
-    CGImageRelease(platformImage);
-#elif PLATFORM(QT)
-    QPixmap px = canvas->createPlatformImage();
-    if (px.isNull())
-        return;
-    willDraw(dstRect);
-    QPainter* painter = static_cast<QPainter*>(c->platformContext());
-    painter->drawPixmap(dstRect, px, srcRect);
-#elif PLATFORM(CAIRO)
-    cairo_surface_t* image = canvas->createPlatformImage();
-    if (!image)
-        return;
-    willDraw(dstRect);
-    cairo_t* cr = c->platformContext();
-    cairo_save(cr);
-    cairo_set_source_surface(cr, image, srcRect.x(), srcRect.y());
-    cairo_surface_destroy(image);
-    cairo_rectangle(cr, dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height());
-    cairo_fill(cr);
-    cairo_restore(cr);
-#endif
+    c->drawImage(buffer, sourceRect, destRect);
 }
 
 // FIXME: Why isn't this just another overload of drawImage? Why have a different name?

diff --git a/WebCore/html/HTMLCanvasElement.cpp b/WebCore/html/HTMLCanvasElement.cpp
index 37fb0218fdbae8652b5f25aeda01ae6a17f03405..b4aade22ec80316446eafd808a83eb68094747a0 100644 (file)
--- a/WebCore/html/HTMLCanvasElement.cpp
+++ b/WebCore/html/HTMLCanvasElement.cpp
@@ -211,10 +211,15 @@ void HTMLCanvasElement::createDrawingContext() const
 }
 
 GraphicsContext* HTMLCanvasElement::drawingContext() const
+{
+    return buffer()->context();
+}
+
+ImageBuffer* HTMLCanvasElement::buffer() const
 {
     if (!m_createdDrawingContext)
         createDrawingContext();
-    return m_data->context();
+    return m_data.get();
 }
 
 #if PLATFORM(CG)

diff --git a/WebCore/html/HTMLCanvasElement.h b/WebCore/html/HTMLCanvasElement.h
index 1895c40ffe2383305361593f6f813b0aa446d12d..348b860253d8fbeb967538928ed9cd9354d67f90 100644 (file)
--- a/WebCore/html/HTMLCanvasElement.h
+++ b/WebCore/html/HTMLCanvasElement.h
@@ -75,6 +75,7 @@ public:
 
     GraphicsContext* drawingContext() const;
 
+    ImageBuffer* buffer() const; 
 #if PLATFORM(CG)
     CGImageRef createPlatformImage() const;
 #elif PLATFORM(QT)

diff --git a/WebCore/platform/graphics/GraphicsContext.h b/WebCore/platform/graphics/GraphicsContext.h
index 075caf48feba30737e47e7487891594baa97a37b..732c8e38e5a0669bb8751f354ffaa6b68973bc65 100644 (file)
--- a/WebCore/platform/graphics/GraphicsContext.h
+++ b/WebCore/platform/graphics/GraphicsContext.h
@@ -145,11 +145,13 @@ namespace WebCore {
         void drawImage(Image*, const IntRect& destRect, const IntRect& srcRect, CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
         void drawImage(Image*, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1),
                        CompositeOperator = CompositeSourceOver, bool useLowQualityScale = false);
+        void drawImage(ImageBuffer*, const FloatRect& srcRect, const FloatRect& destRect);
         void drawTiledImage(Image*, const IntRect& destRect, const IntPoint& srcPoint, const IntSize& tileSize,
                        CompositeOperator = CompositeSourceOver);
         void drawTiledImage(Image*, const IntRect& destRect, const IntRect& srcRect, 
                             Image::TileRule hRule = Image::StretchTile, Image::TileRule vRule = Image::StretchTile,
                             CompositeOperator = CompositeSourceOver);
+
         void paintBuffer(ImageBuffer*, const IntRect&);
 #if PLATFORM(CG)
         void setUseLowQualityImageInterpolation(bool = true);

diff --git a/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp b/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp
index 2f81c0b01edebbb8fb73b7a9cc5a0114a5b37672..9baf7801c0322c7240a8465fffa48ed968ebee29 100644 (file)
--- a/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp
+++ b/WebCore/platform/graphics/cairo/GraphicsContextCairo.cpp
@@ -909,6 +909,16 @@ void GraphicsContext::paintBuffer(ImageBuffer* buffer, const IntRect& r)
     cairo_restore(cr);
 }
 
+void GraphicsContext::drawImage(ImageBuffer* buffer, const FloatRect& srcRect, const FloatRect& destRect)
+{
+    cairo_surface_flush(m_data->surface());    
+    cairo_save(platformContext());
+    cairo_set_source_surface(platformContext(), m_data->surface(), srcRect.x(), srcRect.y());
+    cairo_rectangle(platformContext(), dstRect.x(), dstRect.y(), dstRect.width(), dstRect.height());
+    cairo_fill(platformContext());
+    cairo_restore(platformContext());
+}
+
 } // namespace WebCore
 
 #endif // PLATFORM(CAIRO)

diff --git a/WebCore/platform/graphics/cg/GraphicsContextCG.cpp b/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
index 289e3999da0199cb6cd40f1d5a4ef2b96784a513..de546ac6b2fb4314559ba8a26a920cdbfcd5c23a 100644 (file)
--- a/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
+++ b/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
@@ -36,6 +36,7 @@
 #include <CoreGraphics/CGBitmapContext.h>
 #include <CoreGraphics/CGPDFContext.h>
 #include <wtf/MathExtras.h>
+#include <wtf/OwnArrayPtr.h>
 #include <wtf/RetainPtr.h>
 
 using namespace std;
@@ -930,14 +931,46 @@ void GraphicsContext::setCompositeOperation(CompositeOperator mode)
 
 void GraphicsContext::paintBuffer(ImageBuffer* buffer, const IntRect& r)
 {
-    if (paintingDisabled())
+    CGContextRef context = buffer->context()->platformContext();
+    if (!context)
         return;
+    CGContextFlush(context);
+    if (CGImageRef image = CGBitmapContextCreateImage(context)) {
+        CGContextDrawImage(platformContext(), roundToDevicePixels(r), image);
+        CGImageRelease(image);
+    }
+}
 
-    RetainPtr<CGImageRef> image(AdoptCF, CGBitmapContextCreateImage(buffer->context()->platformContext()));
-    if (!image)
-        return;
-    CGContextDrawImage(platformContext(), roundToDevicePixels(r), image.get());
+void GraphicsContext::drawImage(ImageBuffer* buffer, const FloatRect& srcRect, const FloatRect& destRect)
+{
+    CGContextRef context = buffer->context()->platformContext();
+    CGContextFlush(context);
+    RetainPtr<CGImageRef> image(AdoptCF, CGBitmapContextCreateImage(context));
+    float iw = CGImageGetWidth(image.get());
+    float ih = CGImageGetHeight(image.get());
+    if (srcRect.x() == 0 && srcRect.y() == 0 && iw == srcRect.width() && ih == srcRect.height()) {
+        // Fast path, yay!
+        CGContextDrawImage(platformContext(), destRect, image.get());
+    } else {
+        // Slow path, boo!
+        // FIXME: We can do this without creating a separate image
+        
+        size_t csw = static_cast<size_t>(ceilf(srcRect.width()));
+        size_t csh = static_cast<size_t>(ceilf(srcRect.height()));
+        
+        RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
+        size_t bytesPerRow = csw * 4;
+        OwnArrayPtr<char> buffer(new char[csh * bytesPerRow]);
+        RetainPtr<CGContextRef> clippedSourceContext(AdoptCF, CGBitmapContextCreate(buffer.get(), csw, csh,
+                                                                8, bytesPerRow, colorSpace.get(), kCGImageAlphaPremultipliedLast));
+        CGContextTranslateCTM(clippedSourceContext.get(), -srcRect.x(), -srcRect.y());
+        CGContextDrawImage(clippedSourceContext.get(), CGRectMake(0, 0, iw, ih), image.get());
+        
+        RetainPtr<CGImageRef> clippedSourceImage(AdoptCF, CGBitmapContextCreateImage(clippedSourceContext.get()));
+        
+        CGContextDrawImage(platformContext(), destRect, clippedSourceImage.get());
+    }
 }
-    
+
 }
 

diff --git a/WebCore/platform/graphics/qt/GraphicsContextQt.cpp b/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
index 0d91630761676283cdb92e917c963a74fc072bb1..6f97a9771c0a381ddc0d338bdd2d9d425d666ed1 100644 (file)
--- a/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
+++ b/WebCore/platform/graphics/qt/GraphicsContextQt.cpp
@@ -929,6 +929,15 @@ void GraphicsContext::paintBuffer(ImageBuffer* buffer, const IntRect& r)
     painter->setBackground(currentBackground);
 }
 
+void GraphicsContext::drawImage(ImageBuffer* buffer, const FloatRect& srcRect, const FloatRect& destRect)
+{
+    QPainter* painter = static_cast<QPainter*>(platformContext());
+    QPixmap px = *buffer->pixmap();
+    if (px.isNull())
+        return;
+    painter->drawPixmap(dstRect, px, srcRect);
+}
+
 }
 
 // vim: ts=4 sw=4 et