Refactoring ImageBuffer to decouple it from Canvas2DLayerBridge

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 25 matching lines @@
 #include "bindings/v8/ScriptController.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #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/WebGLRenderingContext.h"
 #include "core/frame/Frame.h"
 #include "core/page/Settings.h"
+#include "core/platform/graphics/Canvas2DImageBufferSurface.h"
 #include "core/platform/graphics/GraphicsContextStateSaver.h"
 #include "core/platform/graphics/ImageBuffer.h"
+#include "core/platform/graphics/gpu/NonDrawableAcceleratedImageBufferSurface.h"
 #include "core/rendering/RenderHTMLCanvas.h"
 #include "platform/MIMETypeRegistry.h"
+#include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "public/platform/Platform.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // These values come from the WhatWG spec.
 static const int DefaultWidth = 300;
 static const int DefaultHeight = 150;
 
@@ skipping 365 matching lines @@
     // Do not use acceleration for small canvas.
     if (size.width() * size.height() < settings->minimumAccelerated2dCanvasSize())
         return false;
 
     if (!blink::Platform::current()->canAccelerate2dCanvas())
         return false;
 
     return true;
 }
 
+PassOwnPtr<ImageBufferSurface> HTMLCanvasElement::createImageBufferSurface(const IntSize& deviceSize, int* msaaSampleCount)
+{
+    OwnPtr<ImageBufferSurface> surface;
+    OpacityMode opacityMode = !m_context || m_context->hasAlpha() ? NonOpaque : Opaque;
+    *msaaSampleCount = 0;
+    if (is3D()) {
+        // Note: No MSAA for 3D canvases because the image buffer is only used for capturing contents.
+        // The actual rendering happens in DrawingBuffer.
+        surface = adoptPtr(new NonDrawableAcceleratedImageBufferSurface(size(), opacityMode, m_deviceScaleFactor));
+    } else {
+        if (shouldAccelerate(deviceSize)) {
+            if (document().settings())
+                *msaaSampleCount = document().settings()->accelerated2dCanvasMSAASampleCount();
+            surface = adoptPtr(new Canvas2DImageBufferSurface(size(), opacityMode, m_deviceScaleFactor, *msaaSampleCount));
+        }
+
+        if (!surface || !surface->isValid()) {
+            surface = adoptPtr(new UnacceleratedImageBufferSurface(size(), opacityMode, m_deviceScaleFactor));

[Stephen White, 2013/12/04 21:18:40]

I'd prefer a Create() method on the surface subclasses that returns a
PassOwnPtr. Then we don't need to call isValid() or adoptPtr() at the call
sites, making them more robust.

+        }
+    }
+
+    return surface.release();
+}
+
 void HTMLCanvasElement::createImageBuffer()
 {
     ASSERT(!m_imageBuffer);
 
     m_didFailToCreateImageBuffer = true;
     m_didClearImageBuffer = true;
 
     IntSize deviceSize = convertLogicalToDevice(size());
     if (deviceSize.width() * deviceSize.height() > MaxCanvasArea)
         return;
 
     if (deviceSize.width() > MaxSkiaDim || deviceSize.height() > MaxSkiaDim)
         return;
 
     if (!deviceSize.width() || !deviceSize.height())
         return;
 
-    RenderingMode renderingMode = is3D() ? TextureBacked : (shouldAccelerate(deviceSize) ? Accelerated : UnacceleratedNonPlatformBuffer);
-    int msaaSampleCount = 0;
-    if (document().settings())
-        msaaSampleCount = document().settings()->accelerated2dCanvasMSAASampleCount();
-    OpacityMode opacityMode = !m_context || m_context->hasAlpha() ? NonOpaque : Opaque;
-    m_imageBuffer = ImageBuffer::create(size(), m_deviceScaleFactor, renderingMode, opacityMode, msaaSampleCount);
-    if (!m_imageBuffer)
+    int msaaSampleCount;
+    OwnPtr<ImageBufferSurface> surface = createImageBufferSurface(deviceSize, &msaaSampleCount);
+    if (!surface || !surface->isValid())
         return;
+
     m_didFailToCreateImageBuffer = false;
+
+    m_imageBuffer = adoptPtr(new ImageBuffer(surface.release()));
+
     setExternallyAllocatedMemory(4 * width() * height());
     m_imageBuffer->context()->setShouldClampToSourceRect(false);
     m_imageBuffer->context()->setImageInterpolationQuality(DefaultInterpolationQuality);
     // Enabling MSAA overrides a request to disable antialiasing. This is true regardless of whether the
     // rendering mode is accelerated or not. For consistency, we don't want to apply AA in accelerated
     // canvases but not in unaccelerated canvases.
     if (!msaaSampleCount && document().settings() && !document().settings()->antialiased2dCanvasEnabled())
         m_imageBuffer->context()->setShouldAntialias(false);
     // GraphicsContext's defaults don't always agree with the 2d canvas spec.
     // See CanvasRenderingContext2D::State::State() for more information.
@@ skipping 70 matching lines @@
     ASSERT(hasImageBuffer() && !m_didFailToCreateImageBuffer);
     IntSize unscaledSize = size();
     IntSize size = convertLogicalToDevice(unscaledSize);
     AffineTransform transform;
     if (size.width() && size.height())
         transform.scaleNonUniform(size.width() / unscaledSize.width(), size.height() / unscaledSize.height());
     return m_imageBuffer->baseTransform() * transform;
 }
 
 }