Correct the OffscreenCanvas.getContext API

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContext.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/webgl/WebGL2RenderingContext.h"
 
 #include "bindings/modules/v8/OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext.h"
 #include "bindings/modules/v8/RenderingContext.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 16 matching lines @@
 #include "modules/webgl/WebGLDebugRendererInfo.h"
 #include "modules/webgl/WebGLDebugShaders.h"
 #include "modules/webgl/WebGLLoseContext.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
 #include <memory>
 
 namespace blink {
 
+// An helper function for the two create() methods. The return value is an
+// indicate of whether the create() should return nullptr or not.
+static bool shouldCreateContext(WebGraphicsContext3DProvider* contextProvider,
+                                HTMLCanvasElement* canvas,
+                                OffscreenCanvas* offscreenCanvas) {
+  if (!contextProvider) {
+    if (canvas) {
+      canvas->dispatchEvent(WebGLContextEvent::create(
+          EventTypeNames::webglcontextcreationerror, false, true,
+          "Failed to create a WebGL2 context."));
+    } else {
+      offscreenCanvas->dispatchEvent(WebGLContextEvent::create(
+          EventTypeNames::webglcontextcreationerror, false, true,
+          "Failed to create a WebGL2 context."));
+    }
+    return false;
+  }
+
+  gpu::gles2::GLES2Interface* gl = contextProvider->contextGL();
+  std::unique_ptr<Extensions3DUtil> extensionsUtil =
+      Extensions3DUtil::create(gl);
+  if (!extensionsUtil)
+    return false;
+  if (extensionsUtil->supportsExtension("GL_EXT_debug_marker")) {
+    String contextLabel(
+        String::format("WebGL2RenderingContext-%p", contextProvider));
+    gl->PushGroupMarkerEXT(0, contextLabel.ascii().data());
+  }
+  return true;
+}
+
 CanvasRenderingContext* WebGL2RenderingContext::Factory::create(
     HTMLCanvasElement* canvas,
     const CanvasContextCreationAttributes& attrs,
     Document&) {
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider(
       createWebGraphicsContext3DProvider(canvas, attrs, 2));
-  if (!contextProvider) {
-    canvas->dispatchEvent(WebGLContextEvent::create(
-        EventTypeNames::webglcontextcreationerror, false, true,
-        "Failed to create a WebGL2 context."));
+  if (!shouldCreateContext(contextProvider.get(), canvas, nullptr))
     return nullptr;
-  }
-  gpu::gles2::GLES2Interface* gl = contextProvider->contextGL();
-  std::unique_ptr<Extensions3DUtil> extensionsUtil =
-      Extensions3DUtil::create(gl);
-  if (!extensionsUtil)
-    return nullptr;
-  if (extensionsUtil->supportsExtension("GL_EXT_debug_marker")) {
-    String contextLabel(
-        String::format("WebGL2RenderingContext-%p", contextProvider.get()));
-    gl->PushGroupMarkerEXT(0, contextLabel.ascii().data());
-  }
-
   WebGL2RenderingContext* renderingContext =
       new WebGL2RenderingContext(canvas, std::move(contextProvider), attrs);
 
   if (!renderingContext->drawingBuffer()) {
     canvas->dispatchEvent(WebGLContextEvent::create(
         EventTypeNames::webglcontextcreationerror, false, true,
         "Could not create a WebGL2 context."));
     return nullptr;
   }
 
   renderingContext->initializeNewContext();
   renderingContext->registerContextExtensions();
 
   return renderingContext;
 }
 
+CanvasRenderingContext* WebGL2RenderingContext::Factory::create(
+    ScriptState* scriptState,
+    OffscreenCanvas* offscreenCanvas,
+    const CanvasContextCreationAttributes& attrs) {
+  std::unique_ptr<WebGraphicsContext3DProvider> contextProvider(
+      createWebGraphicsContext3DProvider(scriptState, attrs, 2));
+  if (!shouldCreateContext(contextProvider.get(), nullptr, offscreenCanvas))
+    return nullptr;
+  WebGL2RenderingContext* renderingContext = new WebGL2RenderingContext(
+      offscreenCanvas, std::move(contextProvider), attrs);
+
+  if (!renderingContext->drawingBuffer()) {
+    offscreenCanvas->dispatchEvent(WebGLContextEvent::create(
+        EventTypeNames::webglcontextcreationerror, false, true,
+        "Could not create a WebGL2 context."));
+    return nullptr;
+  }
+
+  renderingContext->initializeNewContext();
+  renderingContext->registerContextExtensions();
+
+  return renderingContext;
+}
+
 void WebGL2RenderingContext::Factory::onError(HTMLCanvasElement* canvas,
                                               const String& error) {
   canvas->dispatchEvent(WebGLContextEvent::create(
       EventTypeNames::webglcontextcreationerror, false, true, error));
 }
 
 WebGL2RenderingContext::WebGL2RenderingContext(
     HTMLCanvasElement* passedCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes)
     : WebGL2RenderingContextBase(passedCanvas,
                                  std::move(contextProvider),
                                  requestedAttributes) {}
 
+WebGL2RenderingContext::WebGL2RenderingContext(
+    OffscreenCanvas* passedOffscreenCanvas,
+    std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
+    const CanvasContextCreationAttributes& requestedAttributes)
+    : WebGL2RenderingContextBase(passedOffscreenCanvas,
+                                 std::move(contextProvider),
+                                 requestedAttributes) {}
+
 WebGL2RenderingContext::~WebGL2RenderingContext() {}
 
 void WebGL2RenderingContext::setCanvasGetContextResult(
     RenderingContext& result) {
   result.setWebGL2RenderingContext(this);
 }
 
 void WebGL2RenderingContext::setOffscreenCanvasGetContextResult(
     OffscreenRenderingContext& result) {
   result.setWebGL2RenderingContext(this);
@@ skipping 42 matching lines @@
   visitor->trace(m_webglLoseContext);
   WebGL2RenderingContextBase::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGL2RenderingContext) {
   // Extensions are managed by WebGL2RenderingContextBase.
   WebGL2RenderingContextBase::traceWrappers(visitor);
 }
 
 }  // namespace blink