Clean up and fix logic around creating ImageBufferSurface and fallbacks

third_party/WebKit/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 804 matching lines @@
 {
     if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
         return true;
 
     if (!RuntimeEnabledFeatures::displayList2dCanvasEnabled())
         return false;
 
     return true;
 }
 
+std::unique_ptr<ImageBufferSurface> HTMLCanvasElement::createWebGLImageBufferSurface(const IntSize& deviceSize, OpacityMode opacityMode, sk_sp<SkColorSpace> colorSpace)
+{
+    DCHECK(is3D());
+    // If 3d, but the use of the canvas will be for non-accelerated content
+    // then make a non-accelerated ImageBuffer. This means copying the internal
+    // Image will require a pixel readback, but that is unavoidable in this case.
+    auto surface = wrapUnique(new AcceleratedImageBufferSurface(deviceSize, opacityMode, std::move(colorSpace)));
+    if (surface->isValid())
+        return std::move(surface);
+    return nullptr;
+}
+
 std::unique_ptr<ImageBufferSurface> HTMLCanvasElement::createAcceleratedImageBufferSurface(const IntSize& deviceSize, OpacityMode opacityMode, sk_sp<SkColorSpace> colorSpace, int* msaaSampleCount)
 {
-    if (is3D()) {
-        // If 3d, but the use of the canvas will be for non-accelerated content
-        // then make a non-accelerated ImageBuffer. This means copying the internal
-        // Image will require a pixel readback, but that is unavoidable in this case.
-        return wrapUnique(new AcceleratedImageBufferSurface(deviceSize, opacityMode, colorSpace));
-    }
-
     if (!shouldAccelerate(deviceSize))
         return nullptr;
 
     if (document().settings())
         *msaaSampleCount = document().settings()->accelerated2dCanvasMSAASampleCount();
 
     // Avoid creating |contextProvider| until we're sure we want to try use it,
     // since it costs us GPU memory.
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider(Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
     if (!contextProvider) {
         CanvasMetrics::countCanvasContextUsage(CanvasMetrics::Accelerated2DCanvasGPUContextLost);
         return nullptr;
     }
 
     if (contextProvider->isSoftwareRendering())
         return nullptr; // Don't use accelerated canvas with swiftshader.
 
     std::unique_ptr<ImageBufferSurface> surface = wrapUnique(new Canvas2DImageBufferSurface(std::move(contextProvider), deviceSize, *msaaSampleCount, opacityMode, Canvas2DLayerBridge::EnableAcceleration, std::move(colorSpace)));
-    if (surface->isValid()) {
-        CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreated);
-        return surface;
+    if (!surface->isValid()) {
+        CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreationFailed);
+        return nullptr;
     }
 
-    CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreationFailed);
-    return nullptr;
+    CanvasMetrics::countCanvasContextUsage(CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreated);
+    return surface;
 }
 
 std::unique_ptr<ImageBufferSurface> HTMLCanvasElement::createUnacceleratedImageBufferSurface(const IntSize& deviceSize, OpacityMode opacityMode, sk_sp<SkColorSpace> colorSpace)
 {
     if (shouldUseDisplayList(deviceSize)) {
         auto surface = wrapUnique(new RecordingImageBufferSurface(deviceSize, wrapUnique(new UnacceleratedSurfaceFactory), opacityMode, colorSpace));
         if (surface->isValid()) {
             CanvasMetrics::countCanvasContextUsage(CanvasMetrics::DisplayList2DCanvasImageBufferCreated);
             return std::move(surface);
         }
@@ skipping 23 matching lines @@
     DCHECK(!m_imageBuffer);
 
     m_didFailToCreateImageBuffer = true;
     m_imageBufferIsClear = true;
 
     if (!ImageBuffer::canCreateImageBuffer(size()))
         return;
 
     OpacityMode opacityMode = !m_context || m_context->creationAttributes().alpha() ? NonOpaque : Opaque;
     int msaaSampleCount = 0;
-    std::unique_ptr<ImageBufferSurface> surface = std::move(externalSurface);
-    if (!surface)
+    std::unique_ptr<ImageBufferSurface> surface;
+    if (externalSurface) {
+        if (externalSurface->isValid())
+            surface = std::move(externalSurface);
+    } else if (is3D()) {
+        surface = createWebGLImageBufferSurface(size(), opacityMode, m_context->skColorSpace());
+    } else {
         surface = createAcceleratedImageBufferSurface(size(), opacityMode, m_context->skColorSpace(), &msaaSampleCount);
-    if (!surface)
-        surface = createUnacceleratedImageBufferSurface(size(), opacityMode, m_context->skColorSpace());
+        if (!surface)
+            surface = createUnacceleratedImageBufferSurface(size(), opacityMode, m_context->skColorSpace());
+    }
     if (!surface)
         return;
     DCHECK(surface->isValid());
     m_imageBuffer = ImageBuffer::create(std::move(surface));
     DCHECK(m_imageBuffer);
     m_imageBuffer->setClient(this);
 
     m_didFailToCreateImageBuffer = false;
 
     updateExternallyAllocatedMemory();
@@ skipping 328 matching lines @@
 
 bool HTMLCanvasElement::createSurfaceLayer()
 {
     DCHECK(!m_surfaceLayerBridge);
     std::unique_ptr<CanvasSurfaceLayerBridgeClient> bridgeClient = wrapUnique(new CanvasSurfaceLayerBridgeClientImpl());
     m_surfaceLayerBridge = wrapUnique(new CanvasSurfaceLayerBridge(std::move(bridgeClient)));
     return m_surfaceLayerBridge->createSurfaceLayer(this->width(), this->height());
 }
 
 } // namespace blink