canvas: make a temporary buffer when a context doesn't exist.

Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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.
@@ skipping 28 matching lines @@
 #include "core/html/ImageData.h"
 #include "core/html/canvas/Canvas2DContextAttributes.h"
 #include "core/html/canvas/CanvasRenderingContext2D.h"
 #include "core/html/canvas/WebGLContextAttributes.h"
 #include "core/html/canvas/WebGLContextEvent.h"
 #include "core/html/canvas/WebGLRenderingContext.h"
 #include "core/rendering/RenderHTMLCanvas.h"
 #include "core/rendering/RenderLayer.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/Canvas2DImageBufferSurface.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/WebGLImageBufferSurface.h"
 #include "platform/transforms/AffineTransform.h"
 #include "public/platform/Platform.h"
 #include <math.h>
@@ skipping 10 matching lines @@
 const int DefaultHeight = 150;
 
 // Firefox limits width/height to 32767 pixels, but slows down dramatically before it
 // reaches that limit. We limit by area instead, giving us larger maximum dimensions,
 // in exchange for a smaller maximum canvas size.
 const int MaxCanvasArea = 32768 * 8192; // Maximum canvas area in CSS pixels
 
 //In Skia, we will also limit width/height to 32767.
 const int MaxSkiaDim = 32767; // Maximum width/height in CSS pixels.
 
-bool canCreateImageBuffer(const IntSize& deviceSize)
+PassRefPtr<Image> createTransparentImage(const IntSize& size)
 {
-    if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
-        return false;
-    if (deviceSize.width() > MaxSkiaDim || deviceSize.height() > MaxSkiaDim)
-        return false;
-    if (!deviceSize.width() || !deviceSize.height())
-        return false;
-    return true;
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(size.width(), size.height());
+    bitmap.eraseColor(SK_ColorTRANSPARENT);
+    return BitmapImage::create(NativeImageSkia::create(bitmap));
 }
 
 } // namespace
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CanvasObserver);
 
 inline HTMLCanvasElement::HTMLCanvasElement(Document& document)
     : HTMLElement(canvasTag, document)
     , DocumentVisibilityObserver(document)
     , m_size(DefaultWidth, DefaultHeight)
@@ skipping 249 matching lines @@
 
     if (renderBox() && renderBox()->hasAcceleratedCompositing())
         return false;
 
     return true;
 }
 
 
 void HTMLCanvasElement::paint(GraphicsContext* context, const LayoutRect& r)
 {
-    if (m_context) {
-        if (!paintsIntoCanvasBuffer() && !document().printing())
-            return;
-        m_context->paintRenderingResultsToCanvas(FrontBuffer);
+    if (!m_context)
+        return;
+    if (!paintsIntoCanvasBuffer() && !document().printing())
+        return;
+    if (!canCreateImageBuffer()) {

[Justin Novosad, 2014/11/27 00:49:31]

I disagree with this part. We should not create an image buffer if we don't need
to. Having no image buffer happens in cases where a context has not been drawn
to since it was created or since it was last resized.  We also want to prevent
the immediate creation of an image buffer in cases where Chrome is in the
process of recovering from a lost GPU  context (GPU process crash, GPU driver
crash). Also, canCreateImageBuffer() does not guarantee that buffer() will
return a valid image buffer.

[dshwang, 2014/11/27 15:12:11]

Thank you for explaining. I rollback this code in next patch set

+        // When alpha is false, we should draw to opaque black.
+        if (!m_context->hasAlpha())
+            context->fillRect(FloatRect(r), Color(0, 0, 0));
+        return;
     }
 
-    if (hasImageBuffer()) {
-        CompositeOperator compositeOperator = !m_context || m_context->hasAlpha() ? CompositeSourceOver : CompositeCopy;
-        context->drawImageBuffer(buffer(), pixelSnappedIntRect(r), 0, compositeOperator);
-    } else {
-        // When alpha is false, we should draw to opaque black.
-        if (m_context && !m_context->hasAlpha())
-            context->fillRect(FloatRect(r), Color(0, 0, 0));
-    }
+    m_context->paintRenderingResultsToCanvas(FrontBuffer);
+    CompositeOperator compositeOperator = m_context->hasAlpha() ? CompositeSourceOver : CompositeCopy;
+    context->drawImageBuffer(buffer(), pixelSnappedIntRect(r), 0, compositeOperator);
 
     if (is3D())
         toWebGLRenderingContext(m_context.get())->markLayerComposited();
 }
 
 bool HTMLCanvasElement::is3D() const
 {
     return m_context && m_context->is3d();
 }
 
@@ skipping 22 matching lines @@
     return lowercaseMimeType;
 }
 
 const AtomicString HTMLCanvasElement::imageSourceURL() const
 {
     return AtomicString(toDataURLInternal("image/png", 0, FrontBuffer));
 }
 
 String HTMLCanvasElement::toDataURLInternal(const String& mimeType, const double* quality, SourceDrawingBuffer sourceBuffer) const
 {
-    if (m_size.isEmpty() || !canCreateImageBuffer(size()))
+    if (!canCreateImageBuffer())
         return String("data:,");
 
     String encodingMimeType = toEncodingMimeType(mimeType);
     if (!m_context) {
         RefPtrWillBeRawPtr<ImageData> imageData = ImageData::create(m_size);
         return ImageDataToDataURL(ImageDataBuffer(imageData->size(), imageData->data()), encodingMimeType, quality);
     }
 
     if (m_context->is3d()) {
         // Get non-premultiplied data because of inaccurate premultiplied alpha conversion of buffer()->toDataURL().
@@ skipping 124 matching lines @@
             return surface.release();
         surfaceFactory = createSurfaceFactory(deviceSize, msaaSampleCount); // recreate because old previous one was released
     }
 
     return surfaceFactory->createSurface(deviceSize, opacityMode);
 }
 
 void HTMLCanvasElement::createImageBuffer()
 {
     createImageBufferInternal();
-    if (m_didFailToCreateImageBuffer && m_context && m_context->is2d())
+    if (m_didFailToCreateImageBuffer && m_context->is2d())
         toCanvasRenderingContext2D(m_context.get())->loseContext();
 }
 
 void HTMLCanvasElement::createImageBufferInternal()
 {
     ASSERT(!m_imageBuffer);
     ASSERT(!m_contextStateSaver);
 
     m_didFailToCreateImageBuffer = true;
     m_imageBufferIsClear = true;
 
-    if (!canCreateImageBuffer(size()))
+    if (!canCreateImageBuffer())
         return;
 
     int msaaSampleCount;
     OwnPtr<ImageBufferSurface> surface = createImageBufferSurface(size(), &msaaSampleCount);
     if (!surface->isValid())
         return;
 
     m_imageBuffer = ImageBuffer::create(surface.release());
     m_imageBuffer->setClient(this);
 
@@ skipping 21 matching lines @@
     m_imageBuffer->context()->setStrokeThickness(1);
 #if ENABLE(ASSERT)
     m_imageBuffer->context()->disableDestructionChecks(); // 2D canvas is allowed to leave context in an unfinalized state.
 #endif
     m_contextStateSaver = adoptPtr(new GraphicsContextStateSaver(*m_imageBuffer->context()));
 
     if (m_context)
         setNeedsCompositingUpdate();
 }
 
+bool HTMLCanvasElement::canCreateImageBuffer() const
+{
+    if (m_size.isEmpty())
+        return false;
+    if (m_size.width() * m_size.height() > MaxCanvasArea)
+        return false;
+    if (m_size.width() > MaxSkiaDim || m_size.height() > MaxSkiaDim)
+        return false;
+    return true;
+}
+
 void HTMLCanvasElement::notifySurfaceInvalid()
 {
     if (m_context && m_context->is2d()) {
         CanvasRenderingContext2D* context2d = toCanvasRenderingContext2D(m_context.get());
         context2d->loseContext();
     }
 }
 
 void HTMLCanvasElement::trace(Visitor* visitor)
 {
@@ skipping 35 matching lines @@
 GraphicsContext* HTMLCanvasElement::existingDrawingContext() const
 {
     if (!hasImageBuffer())
         return nullptr;
 
     return drawingContext();
 }
 
 ImageBuffer* HTMLCanvasElement::buffer() const
 {
+    ASSERT(m_context);

[dshwang, 2014/11/26 21:36:54]

It means that we can move imageBuffer to CanvasRenderingContext after this CL.

     if (!hasImageBuffer() && !m_didFailToCreateImageBuffer)
         const_cast<HTMLCanvasElement*>(this)->createImageBuffer();
     return m_imageBuffer.get();
 }
 
 void HTMLCanvasElement::ensureUnacceleratedImageBuffer()
 {
+    ASSERT(m_context);
     if ((hasImageBuffer() && !m_imageBuffer->isAccelerated()) || m_didFailToCreateImageBuffer)
         return;
     discardImageBuffer();
-    OpacityMode opacityMode = !m_context || m_context->hasAlpha() ? NonOpaque : Opaque;
+    OpacityMode opacityMode = m_context->hasAlpha() ? NonOpaque : Opaque;
     m_imageBuffer = ImageBuffer::create(size(), opacityMode);
     m_didFailToCreateImageBuffer = !m_imageBuffer;
 }
 
-Image* HTMLCanvasElement::copiedImage(SourceDrawingBuffer sourceBuffer) const
+PassRefPtr<Image> HTMLCanvasElement::copiedImage(SourceDrawingBuffer sourceBuffer) const
 {
+    if (!canCreateImageBuffer())
+        return nullptr;
+    if (!m_context)
+        return createTransparentImage(size());
+
     if (!m_copiedImage && buffer()) {
         if (m_context && m_context->is3d())
             m_context->paintRenderingResultsToCanvas(sourceBuffer);
         m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
         updateExternallyAllocatedMemory();
     }
-    return m_copiedImage.get();
+    return m_copiedImage;
 }
 
 void HTMLCanvasElement::discardImageBuffer()
 {
     m_contextStateSaver.clear(); // uses context owned by m_imageBuffer
     m_imageBuffer.clear();
     resetDirtyRect();
     updateExternallyAllocatedMemory();
 }
 
@@ skipping 36 matching lines @@
     HTMLElement::didMoveToNewDocument(oldDocument);
 }
 
 PassRefPtr<Image> HTMLCanvasElement::getSourceImageForCanvas(SourceImageMode mode, SourceImageStatus* status) const
 {
     if (!width() || !height()) {
         *status = ZeroSizeCanvasSourceImageStatus;
         return nullptr;
     }
 
-    if (!buffer()) {
+    if (!canCreateImageBuffer()) {
         *status = InvalidSourceImageStatus;
         return nullptr;
     }
 
-    if (m_context && m_context->is3d()) {
+    if (!m_context) {
+        *status = NormalSourceImageStatus;
+        return createTransparentImage(size());
+    }
+
+    if (m_context->is3d()) {
         m_context->paintRenderingResultsToCanvas(BackBuffer);
         *status = ExternalSourceImageStatus;
 
         // can't create SkImage from WebGLImageBufferSurface (contains only SkBitmap)
-        return m_imageBuffer->copyImage(DontCopyBackingStore, Unscaled);
+        return buffer()->copyImage(DontCopyBackingStore, Unscaled);

[Justin Novosad, 2014/11/27 00:49:31]

Here: not safe to assume buffer is non-null

[dshwang, 2014/11/27 15:12:11]

Yes, true
In next patch set, above "if statement" for buffer() is preserved. 

     }
 
-    RefPtr<SkImage> image = m_imageBuffer->newImageSnapshot();
+    RefPtr<SkImage> image = buffer()->newImageSnapshot();

[Justin Novosad, 2014/11/27 00:49:30]

here too

     if (image) {
         *status = NormalSourceImageStatus;
-
         return StaticBitmapImage::create(image.release());
     }
 
-
     *status = InvalidSourceImageStatus;
-
     return nullptr;
 }
 
 bool HTMLCanvasElement::wouldTaintOrigin(SecurityOrigin*) const
 {
     return !originClean();
 }
 
 FloatSize HTMLCanvasElement::sourceSize() const
 {
     return FloatSize(width(), height());
 }
 
 }