Fixing Canvas2DLayerBridge to handle lost graphics contexts

Source/core/platform/graphics/skia/ImageBufferSkia.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 55 matching lines @@
 // the ownership easier to manage.
 ImageBufferData::ImageBufferData(const IntSize& size)
 {
 }
 
 static SkCanvas* createAcceleratedCanvas(const IntSize& size, ImageBufferData* data, OpacityMode opacityMode)
 {
     RefPtr<GraphicsContext3D> context3D = SharedGraphicsContext3D::get();
     if (!context3D)
         return 0;
-    GrContext* gr = context3D->grContext();
-    if (!gr)
-        return 0;
-    gr->resetContext();
     Canvas2DLayerBridge::OpacityMode bridgeOpacityMode = opacityMode == Opaque ? Canvas2DLayerBridge::Opaque : Canvas2DLayerBridge::NonOpaque;
     Canvas2DLayerBridge::ThreadMode threadMode = WebKit::Platform::current()->isThreadedCompositingEnabled() ? Canvas2DLayerBridge::Threaded : Canvas2DLayerBridge::SingleThread;
-    SkImage::Info info;
-    info.fWidth = size.width();
-    info.fHeight = size.height();
-    info.fColorType = SkImage::kPMColor_ColorType;
-    info.fAlphaType = SkImage::kPremul_AlphaType;
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context3D->grContext(), info));
-    if (!surface.get())
-        return 0;
-    SkDeferredCanvas* canvas = new SkDeferredCanvas(surface.get());
-    data->m_layerBridge = Canvas2DLayerBridge::create(context3D.release(), canvas, bridgeOpacityMode, threadMode);
+    data->m_layerBridge = Canvas2DLayerBridge::create(context3D.release(), size, bridgeOpacityMode, threadMode);
     // If canvas buffer allocation failed, debug build will have asserted
     // For release builds, we must verify whether the device has a render target
-    return canvas;
+    return data->m_layerBridge ? data->m_layerBridge->getCanvas() : 0;
 }
 
 static SkCanvas* createNonPlatformCanvas(const IntSize& size)
 {
     SkAutoTUnref<SkDevice> device(new SkDevice(SkBitmap::kARGB_8888_Config, size.width(), size.height()));
     SkPixelRef* pixelRef = device->accessBitmap(false).pixelRef();
     return pixelRef ? new SkCanvas(device) : 0;
 }
 
 PassOwnPtr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const IntSize& size, float resolutionScale, ColorSpace colorSpace, const GraphicsContext* context, bool hasAlpha)
@@ skipping 81 matching lines @@
 GraphicsContext* ImageBuffer::context() const
 {
     if (m_data.m_layerBridge) {
         // We're using context acquisition as a signal that someone is about to render into our buffer and we need
         // to be ready. This isn't logically const-correct, hence the cast.
         const_cast<Canvas2DLayerBridge*>(m_data.m_layerBridge.get())->contextAcquired();
     }
     return m_context.get();
 }
 
+bool ImageBuffer::isValid() const
+{
+    if (m_data.m_layerBridge)
+        return const_cast<Canvas2DLayerBridge*>(m_data.m_layerBridge.get())->isValid();
+    return true;
+}
+
 static SkBitmap deepSkBitmapCopy(const SkBitmap& bitmap)
 {
     SkBitmap tmp;
     if (!bitmap.deepCopyTo(&tmp, bitmap.config()))
         bitmap.copyTo(&tmp, bitmap.config());
 
     return tmp;
 }
 
 PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior, ScaleBehavior) const
 {
+    if (!isValid())
+        return BitmapImage::create(NativeImageSkia::create());
+
     const SkBitmap& bitmap = *context()->bitmap();
     // FIXME: Start honoring ScaleBehavior to scale 2x buffers down to 1x.
     return BitmapImage::create(NativeImageSkia::create(copyBehavior == CopyBackingStore ? deepSkBitmapCopy(bitmap) : bitmap, m_resolutionScale));
 }
 
 BackingStoreCopy ImageBuffer::fastCopyImageMode()
 {
     return DontCopyBackingStore;
 }
 
 PlatformLayer* ImageBuffer::platformLayer() const
 {
     return m_data.m_layerBridge ? m_data.m_layerBridge->layer() : 0;
 }
 
 bool ImageBuffer::copyToPlatformTexture(GraphicsContext3D& context, Platform3DObject texture, GC3Denum internalFormat, GC3Denum destType, GC3Dint level, bool premultiplyAlpha, bool flipY)
 {
-    if (!m_data.m_layerBridge || !platformLayer())
+    if (!m_data.m_layerBridge || !platformLayer() || !isValid())
         return false;
 
     Platform3DObject sourceTexture = m_data.m_layerBridge->backBufferTexture();
 
     if (!context.makeContextCurrent())
         return false;
 
     Extensions3D* extensions = context.getExtensions();
     if (!extensions->supports("GL_CHROMIUM_copy_texture") || !extensions->supports("GL_CHROMIUM_flipy")
         || !extensions->canUseCopyTextureCHROMIUM(internalFormat, destType, level))
@@ skipping 19 matching lines @@
 }
 
 static bool drawNeedsCopy(GraphicsContext* src, GraphicsContext* dst)
 {
     return (src == dst);
 }
 
 void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
     CompositeOperator op, BlendMode blendMode, bool useLowQualityScale)
 {
+    if (!isValid())
+        return;
+
     const SkBitmap& bitmap = *m_context->bitmap();
     RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
     context->drawImage(image.get(), styleColorSpace, destRect, srcRect, op, blendMode, DoNotRespectImageOrientation, useLowQualityScale);
 }
 
 void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
                               const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
 {
+    if (!isValid())
+        return;
+
     const SkBitmap& bitmap = *m_context->bitmap();
     RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
     image->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
 }
 
 void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
 {
     // FIXME: Disable color space conversions on accelerated canvases (for now).
-    if (context()->isAccelerated())
+    if (context()->isAccelerated() || !isValid())
         return;
 
     const SkBitmap& bitmap = *context()->bitmap();
     if (bitmap.isNull())
         return;
 
     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
     SkAutoLockPixels bitmapLock(bitmap);
     for (int y = 0; y < m_size.height(); ++y) {
         uint32_t* srcRow = bitmap.getAddr32(0, y);
@@ skipping 34 matching lines @@
         config8888 = SkCanvas::kRGBA_Premul_Config8888;
     else
         config8888 = SkCanvas::kRGBA_Unpremul_Config8888;
 
     context->readPixels(&destBitmap, rect.x(), rect.y(), config8888);
     return result.release();
 }
 
 PassRefPtr<Uint8ClampedArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect, CoordinateSystem) const
 {
+    if (!isValid()) {
+        RefPtr<Uint8ClampedArray> result = Uint8ClampedArray::create(rect.width() * rect.height() * 4);
+        return result.release();

[Stephen White, 2013/05/28 14:23:10]

Nit: I think you could just return the result of Uint8ClampedArray::create()
without storing it in a temporary.

+    }
     return getImageData<Unmultiplied>(rect, context(), m_size);
 }
 
 PassRefPtr<Uint8ClampedArray> ImageBuffer::getPremultipliedImageData(const IntRect& rect, CoordinateSystem) const
 {
+    if (!isValid()) {
+        RefPtr<Uint8ClampedArray> result = Uint8ClampedArray::create(rect.width() * rect.height() * 4);

[Stephen White, 2013/05/28 14:23:10]

Same here.

+        return result.release();
+    }
     return getImageData<Premultiplied>(rect, context(), m_size);
 }
 
 void ImageBuffer::putByteArray(Multiply multiplied, Uint8ClampedArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem)
 {
+    if (!isValid())
+        return;
+
     ASSERT(sourceRect.width() > 0);
     ASSERT(sourceRect.height() > 0);
 
     int originX = sourceRect.x();
     int destX = destPoint.x() + sourceRect.x();
     ASSERT(destX >= 0);
     ASSERT(destX < m_size.width());
     ASSERT(originX >= 0);
     ASSERT(originX < sourceRect.maxX());
 
@@ skipping 50 matching lines @@
         ASSERT(mimeType == "image/png");
     }
 
     return true;
 }
 
 String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
 {
     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
-    Vector<char> encodedImage;
-    if (!encodeImage(*context()->bitmap(), mimeType, quality, &encodedImage))
-        return "data:,";
-
     Vector<char> base64Data;
-    base64Encode(encodedImage, base64Data);
+    if (isValid()) {
+        Vector<char> encodedImage;
+        if (!encodeImage(*context()->bitmap(), mimeType, quality, &encodedImage))
+            return "data:,";
+        base64Encode(encodedImage, base64Data);
+    }
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 void ImageBufferData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this);
     info.addMember(m_canvas, "canvas");
     info.addMember(m_layerBridge, "layerBridge");
 }
 
 String ImageDataToDataURL(const ImageData& imageData, const String& mimeType, const double* quality)
 {
     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
 
     Vector<char> encodedImage;
     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
         return "data:,";
 
     Vector<char> base64Data;
     base64Encode(encodedImage, base64Data);
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 } // namespace WebCore