Fixed crashes related to incorrect sizing of the Canvas's backing...

webkit/api/src/GraphicsContext3D.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 145 matching lines @@
         bool normalized;
         unsigned long stride;
         unsigned long offset;
     };
 
     enum {
         NumTrackedPointerStates = 2
     };
     VertexAttribPointerState m_vertexAttribPointerState[NumTrackedPointerStates];
 
+#if PLATFORM(SKIA)
+    // If the width and height of the Canvas's backing store don't
+    // match those that we were given in the most recent call to
+    // reshape(), then we need an intermediate bitmap to read back the
+    // frame buffer into. This seems to happen when CSS styles are
+    // used to resize the Canvas.
+    SkBitmap* m_resizingBitmap;
+#endif
+
 #if PLATFORM(WIN_OS)
     HWND  m_canvasWindow;
     HDC   m_canvasDC;
     HGLRC m_contextObj;
 #elif PLATFORM(CG)
     CGLPBufferObj m_pbuffer;
     CGLContextObj m_contextObj;
     unsigned char* m_renderOutput;
     CGContextRef m_cgContext;
 #elif PLATFORM(LINUX)
@@ skipping 41 matching lines @@
 #endif
 
 GraphicsContext3DInternal::GraphicsContext3DInternal()
     : m_texture(0)
     , m_fbo(0)
     , m_depthBuffer(0)
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
     , m_scanline(NULL)
 #endif
     , m_boundArrayBuffer(0)
+#if PLATFORM(SKIA)
+    , m_resizingBitmap(0)
+#endif
 #if PLATFORM(WIN_OS)
     , m_canvasWindow(NULL)
     , m_canvasDC(NULL)
     , m_contextObj(NULL)
 #elif PLATFORM(CG)
     , m_pbuffer(NULL)
     , m_contextObj(NULL)
     , m_renderOutput(NULL)
     , m_cgContext(NULL)
 #elif PLATFORM(LINUX)
@@ skipping 231 matching lines @@
     makeContextCurrent();
 #ifndef RENDER_TO_DEBUGGING_WINDOW
     glDeleteRenderbuffersEXT(1, &m_depthBuffer);
     glDeleteTextures(1, &m_texture);
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
     if (m_scanline != NULL)
         delete[] m_scanline;
 #endif
     glDeleteFramebuffersEXT(1, &m_fbo);
 #endif // !RENDER_TO_DEBUGGING_WINDOW
+#if PLATFORM(SKIA)
+    if (m_resizingBitmap)
+        delete m_resizingBitmap;
+#endif
 #if PLATFORM(WIN_OS)
     wglMakeCurrent(NULL, NULL);
     wglDeleteContext(m_contextObj);
     ReleaseDC(m_canvasWindow, m_canvasDC);
     DestroyWindow(m_canvasWindow);
 #elif PLATFORM(CG)
     CGLSetCurrentContext(NULL);
     CGLDestroyContext(m_contextObj);
     CGLDestroyPBuffer(m_pbuffer);
     if (m_cgContext != NULL)
@@ skipping 177 matching lines @@
 #else
     // Earlier versions of this code used the GPU to flip the
     // framebuffer vertically before reading it back for compositing
     // via software. This code was quite complicated, used a lot of
     // GPU memory, and didn't provide an obvious speedup. Since this
     // vertical flip is only a temporary solution anyway until Chrome
     // is fully GPU composited, it wasn't worth the complexity.
 
     HTMLCanvasElement* canvas = context->canvas();
     ImageBuffer* imageBuffer = canvas->buffer();
-    unsigned char* pixels = NULL;
+    unsigned char* pixels = 0;
 #if PLATFORM(SKIA)
-    const SkBitmap& bitmap = *imageBuffer->context()->platformContext()->bitmap();
-    ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
-    ASSERT(bitmap.width() == m_cachedWidth);
-    ASSERT(bitmap.height() == m_cachedHeight);
+    const SkBitmap* canvasBitmap = imageBuffer->context()->platformContext()->bitmap();
+    const SkBitmap* readbackBitmap = 0;
+    ASSERT(canvasBitmap->config() == SkBitmap::kARGB_8888_Config);
+    if (canvasBitmap->width() == m_cachedWidth &&
+        canvasBitmap->height() == m_cachedHeight) {
+        // This is the fastest and most common case. We read back
+        // directly into the canvas's backing store.
+        readbackBitmap = canvasBitmap;
+        if (m_resizingBitmap != NULL) {
+            delete m_resizingBitmap;
+            m_resizingBitmap = 0;
+        }
+    } else {
+        // We need to allocate a temporary bitmap for reading back the
+        // pixel data. We will then use Skia to rescale this bitmap to
+        // the size of the canvas's backing store.
+        if (m_resizingBitmap &&
+            (m_resizingBitmap->width() != m_cachedWidth ||
+             m_resizingBitmap->height() != m_cachedHeight)) {
+            delete m_resizingBitmap;
+            m_resizingBitmap = 0;
+        }
+        if (m_resizingBitmap == 0) {
+            m_resizingBitmap = new SkBitmap();
+            m_resizingBitmap->setConfig(SkBitmap::kARGB_8888_Config,
+                                        m_cachedWidth,
+                                        m_cachedHeight);
+            if (!m_resizingBitmap->allocPixels()) {
+                delete m_resizingBitmap;
+                m_resizingBitmap = 0;
+                return;
+            }
+        }
+        readbackBitmap = m_resizingBitmap;
+    }
 
     // Read back the frame buffer.
-    SkAutoLockPixels bitmapLock(bitmap);
-    pixels = static_cast<unsigned char*>(bitmap.getPixels());
+    SkAutoLockPixels bitmapLock(*readbackBitmap);
+    pixels = static_cast<unsigned char*>(readbackBitmap->getPixels());
     glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
 #elif PLATFORM(CG)
     if (m_renderOutput != NULL) {
         ASSERT(CGBitmapContextGetWidth(m_cgContext) == m_cachedWidth);
         ASSERT(CGBitmapContextGetHeight(m_cgContext) == m_cachedHeight);
         pixels = m_renderOutput;
         glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
     }
 #else
 #error Must port to your platform
 #endif
 
 #ifdef FLIP_FRAMEBUFFER_VERTICALLY
     if (pixels != NULL)
         flipVertically(pixels, m_cachedWidth, m_cachedHeight);
 #endif
 
 #if PLATFORM(SKIA)
-    // No further work necessary
+    if (m_resizingBitmap) {
+        // We need to draw the resizing bitmap into the canvas's backing store.
+        SkCanvas canvas(*canvasBitmap);
+        SkRect dst;
+        dst.set(0, 0, canvasBitmap->width(), canvasBitmap->height());
+        canvas.drawBitmapRect(*m_resizingBitmap, 0, dst);

[brettw, 2009/11/03 20:21:18]

Do you want antialiasing? This call will not give you any. If you do, make a
SkPaint and do setFilterBitmap (or something like that) on it before passing it
into drawBitmapRect.

+    }
 #elif PLATFORM(CG)
     if (m_renderOutput != NULL) {
         CGImageRef cgImage = CGBitmapContextCreateImage(m_cgContext);
-        CGRect rect = CGRectMake(0, 0, m_cachedWidth, m_cachedHeight);
+        // CSS styling may cause the canvas's content to be resized on
+        // the page. Go back to the Canvas to figure out the correct
+        // width and height to draw.
+        CGRect rect = CGRectMake(0, 0,
+                                 context->canvas()->width(),
+                                 context->canvas()->height());
         // We want to completely overwrite the previous frame's
         // rendering results.
         CGContextSetBlendMode(imageBuffer->context()->platformContext(),
                               kCGBlendModeCopy);
         CGContextDrawImage(imageBuffer->context()->platformContext(),
                            rect, cgImage);
         CGImageRelease(cgImage);
     }
 #else
 #error Must port to your platform
@@ skipping 1497 matching lines @@
 
 void GraphicsContext3D::viewport(long x, long y, unsigned long width, unsigned long height)
 {
     makeContextCurrent();
     m_internal->viewportImpl(x, y, width, height);
 }
 
 }
 
 #endif // ENABLE(3D_CANVAS)