Use SkImage as a backing store for copying 2d Contexts to ImageBitmaps.

Source/core/platform/graphics/ImageBuffer.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 22 matching lines @@
 #include "config.h"
 #include "core/platform/graphics/ImageBuffer.h"
 
 #include "core/html/ImageData.h"
 #include "core/platform/MIMETypeRegistry.h"
 #include "core/platform/graphics/BitmapImage.h"
 #include "core/platform/graphics/Extensions3D.h"
 #include "core/platform/graphics/GraphicsContext.h"
 #include "core/platform/graphics/GraphicsContext3D.h"
 #include "core/platform/graphics/IntRect.h"
+#include "core/platform/graphics/ReadOnlyBitmapImage.h"
 #include "core/platform/graphics/chromium/Canvas2DLayerBridge.h"
 #include "core/platform/graphics/gpu/SharedGraphicsContext3D.h"
 #include "core/platform/graphics/skia/NativeImageSkia.h"
 #include "core/platform/graphics/skia/SkiaUtils.h"
 #include "core/platform/image-encoders/skia/JPEGImageEncoder.h"
 #include "core/platform/image-encoders/skia/PNGImageEncoder.h"
 #include "core/platform/image-encoders/skia/WEBPImageEncoder.h"
 #include "public/platform/Platform.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/WTFString.h"
 
 using namespace std;
 
 namespace WebCore {
 
-static SkCanvas* createAcceleratedCanvas(const IntSize& size, OwnPtr<Canvas2DLayerBridge>* outLayerBridge, OpacityMode opacityMode)
+void ImageBuffer::createAcceleratedCanvas(const IntSize& size, OwnPtr<Canvas2DLayerBridge>* outLayerBridge, OpacityMode opacityMode)

[Justin Novosad, 2013/08/19 20:12:43]

This clashes with a refactoring I have in flight.  Let's not commit this right
away

[Stephen White, 2013/08/19 20:21:21]

If you don't need the SkCanvas* return value anymore, you should probably just
return a PassOwnPtr<Canvas2DLayerBridge> from this function.

[danakj, 2013/08/19 20:22:33]

SkCanvas is refcounted. Should it not go in a RefPtr?

 {
     RefPtr<GraphicsContext3D> context3D = SharedGraphicsContext3D::get();
     if (!context3D)
-        return 0;
+        return;
     Canvas2DLayerBridge::OpacityMode bridgeOpacityMode = opacityMode == Opaque ? Canvas2DLayerBridge::Opaque : Canvas2DLayerBridge::NonOpaque;
     *outLayerBridge = Canvas2DLayerBridge::create(context3D.release(), size, bridgeOpacityMode);
+
+    // FIXME: refactor Canvas2DLayerBridge so that SkSurface is accessible.
+    SkSurface* surface = 0;
+    m_surface = adoptPtr(surface);
+
     // If canvas buffer allocation failed, debug build will have asserted
     // For release builds, we must verify whether the device has a render target
-    return (*outLayerBridge) ? (*outLayerBridge)->getCanvas() : 0;
+    SkCanvas* canvas = (*outLayerBridge) ? (*outLayerBridge)->getCanvas() : 0;
+    m_canvas = adoptPtr(canvas);
 }
 
-static SkCanvas* createNonPlatformCanvas(const IntSize& size)
+void ImageBuffer::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;
+    SkImage::Info info;
+    info.fWidth = size.width();
+    info.fHeight = size.height();
+    info.fColorType = SkImage::kRGBA_8888_ColorType;
+    info.fAlphaType = SkImage::kPremul_AlphaType;
+    m_surface = adoptPtr(SkSurface::NewRaster(info));
+    if (!m_surface)
+        return;
+    m_canvas = adoptPtr(m_surface->getCanvas());
 }
 
 PassOwnPtr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const IntSize& size, float resolutionScale, const GraphicsContext* context, bool hasAlpha)
 {
     bool success = false;
     OwnPtr<ImageBuffer> buf = adoptPtr(new ImageBuffer(size, resolutionScale, context, hasAlpha, success));
     if (!success)
         return nullptr;
     return buf.release();
 }
@@ skipping 27 matching lines @@
 
     success = true;
 }
 
 ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, RenderingMode renderingMode, OpacityMode opacityMode, bool& success)
     : m_size(size)
     , m_logicalSize(size)
     , m_resolutionScale(resolutionScale)
 {
     if (renderingMode == Accelerated) {
-        m_canvas = adoptPtr(createAcceleratedCanvas(size, &m_layerBridge, opacityMode));
+        createAcceleratedCanvas(size, &m_layerBridge, opacityMode);
         if (!m_canvas)
             renderingMode = UnacceleratedNonPlatformBuffer;
     }
 
     if (renderingMode == UnacceleratedNonPlatformBuffer)
-        m_canvas = adoptPtr(createNonPlatformCanvas(size));
+        createNonPlatformCanvas(size);
 
     if (!m_canvas)
         m_canvas = adoptPtr(skia::TryCreateBitmapCanvas(size.width(), size.height(), false));
 
     if (!m_canvas) {
         success = false;
         return;
     }
 
     m_context = adoptPtr(new GraphicsContext(m_canvas.get()));
@@ skipping 36 matching lines @@
 
 static SkBitmap deepSkBitmapCopy(const SkBitmap& bitmap)
 {
     SkBitmap tmp;
     if (!bitmap.deepCopyTo(&tmp, bitmap.config()))
         bitmap.copyTo(&tmp, bitmap.config());
 
     return tmp;
 }
 
+PassRefPtr<Image> ImageBuffer::imageSnapshot() const
+{
+    // A canvas without a surface indicates that a platform buffer is being used. imageSnapshot() on a platform
+    // buffer is not supported.
+    ASSERT(!m_canvas);
+
+    if (!isValid())
+        return BitmapImage::create(NativeImageSkia::create());
+
+    // FIXME: Case where canvas is acclerated. This should be removed once ImageBuffer holds a ref to the SkSurface.
+    if (!m_surface)
+        return copyImage(CopyBackingStore);
+
+    return ReadOnlyBitmapImage::create(m_surface->newImageSnapshot());
+}
+
 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));
 }
 
@@ skipping 288 matching lines @@
     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
         return "data:,";
 
     Vector<char> base64Data;
     base64Encode(encodedImage, base64Data);
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 } // namespace WebCore