This CL implements the first draft of Canvas 2D Context Attributes, aka getContext('2d', { alpha: f…

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 52 matching lines @@
 
 // We pass a technically-uninitialized canvas to the platform context here since
 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
 // PlatformContext doesn't actually need to use the object, and this makes all
 // the ownership easier to manage.
 ImageBufferData::ImageBufferData(const IntSize& size)
     : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
 {
 }
 
-static SkCanvas* createAcceleratedCanvas(const IntSize& size, ImageBufferData* data)
+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, threadMode);
+    data->m_layerBridge = Canvas2DLayerBridge::create(context3D.release(), canvas, 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
     data->m_platformContext.setAccelerated(true);
     return canvas;
 }
 
 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();
@@ skipping 34 matching lines @@
 
     m_data.m_canvas = adoptPtr(new SkCanvas(device));
     m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
     m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
     m_context->setShouldSmoothFonts(false);
     m_context->scale(FloatSize(m_resolutionScale, m_resolutionScale));
 
     success = true;
 }
 
-ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace, RenderingMode renderingMode, bool& success)
+ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace, RenderingMode renderingMode, OpacityMode opacityMode, bool& success)
     : m_data(size)
     , m_size(size)
     , m_logicalSize(size)
     , m_resolutionScale(resolutionScale)
 {
     OwnPtr<SkCanvas> canvas;
 
     if (renderingMode == Accelerated)
-        canvas = adoptPtr(createAcceleratedCanvas(size, &m_data));
+        canvas = adoptPtr(createAcceleratedCanvas(size, &m_data, opacityMode));
     else if (renderingMode == UnacceleratedNonPlatformBuffer)
         canvas = adoptPtr(createNonPlatformCanvas(size));
 
     if (!canvas)
         canvas = adoptPtr(skia::TryCreateBitmapCanvas(size.width(), size.height(), false));
 
     if (!canvas) {
         success = false;
         return;
     }
 
     m_data.m_canvas = canvas.release();
     m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
     m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
-    m_context->setShouldSmoothFonts(false);
+    m_context->setShouldSmoothFonts(opacityMode == Opaque);
     m_context->scale(FloatSize(m_resolutionScale, m_resolutionScale));
 
-    // Make the background transparent. It would be nice if this wasn't
+    // Clear the background transparent or opaque, as required. It would be nice if this wasn't
     // required, but the canvas is currently filled with the magic transparency
     // color. Can we have another way to manage this?
-    m_data.m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
+    if (opacityMode == Opaque)
+        m_data.m_canvas->drawARGB(255, 0, 0, 0, SkXfermode::kSrc_Mode);
+    else
+        m_data.m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
 
     success = true;
 }
 
 ImageBuffer::~ImageBuffer()
 {
 }
 
 GraphicsContext* ImageBuffer::context() const
 {
@@ skipping 250 matching lines @@
     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
         return "data:,";
 
     Vector<char> base64Data;
     base64Encode(encodedImage, base64Data);
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 } // namespace WebCore