Implement offscreenCanvas.getContext('webgl') on a worker thread

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

 /*
  * Copyright (C) 2009 Apple Inc. 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 48 matching lines @@
 #include "modules/webgl/OESTextureHalfFloatLinear.h"
 #include "modules/webgl/OESVertexArrayObject.h"
 #include "modules/webgl/WebGLActiveInfo.h"
 #include "modules/webgl/WebGLBuffer.h"
 #include "modules/webgl/WebGLCompressedTextureASTC.h"
 #include "modules/webgl/WebGLCompressedTextureATC.h"
 #include "modules/webgl/WebGLCompressedTextureETC1.h"
 #include "modules/webgl/WebGLCompressedTexturePVRTC.h"
 #include "modules/webgl/WebGLCompressedTextureS3TC.h"
 #include "modules/webgl/WebGLContextAttributeHelpers.h"
-#include "modules/webgl/WebGLContextAttributes.h"
 #include "modules/webgl/WebGLContextEvent.h"
 #include "modules/webgl/WebGLContextGroup.h"
 #include "modules/webgl/WebGLDebugRendererInfo.h"
 #include "modules/webgl/WebGLDebugShaders.h"
 #include "modules/webgl/WebGLDepthTexture.h"
 #include "modules/webgl/WebGLDrawBuffers.h"
 #include "modules/webgl/WebGLFramebuffer.h"
 #include "modules/webgl/WebGLLoseContext.h"
 #include "modules/webgl/WebGLProgram.h"
 #include "modules/webgl/WebGLRenderbuffer.h"
 #include "modules/webgl/WebGLShader.h"
 #include "modules/webgl/WebGLShaderPrecisionFormat.h"
-#include "modules/webgl/WebGLTexture.h"
 #include "modules/webgl/WebGLUniformLocation.h"
 #include "modules/webgl/WebGLVertexArrayObject.h"
 #include "modules/webgl/WebGLVertexArrayObjectOES.h"
 #include "platform/CheckedInt.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/ThreadSafeFunctional.h"
+#include "platform/WaitableEvent.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/gpu/AcceleratedImageBufferSurface.h"
-#include "platform/graphics/gpu/DrawingBuffer.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebGraphicsContext3DProvider.h"
 #include "public/platform/functional/WebFunction.h"
 #include "wtf/Functional.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringUTF8Adaptor.h"
 #include "wtf/typed_arrays/ArrayBufferContents.h"
 
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 const double secondsBetweenRestoreAttempts = 1.0;
 const int maxGLErrorsAllowedToConsole = 256;
 const unsigned maxGLActiveContexts = 16;
+const unsigned maxGLActiveContextsOnWorker = 4;
 
 using WebGLRenderingContextBaseSet = PersistentHeapHashSet<WeakMember<WebGLRenderingContextBase>>;
 WebGLRenderingContextBaseSet& activeContexts()
 {
-    DEFINE_STATIC_LOCAL(WebGLRenderingContextBaseSet, activeContexts, ());
-    return activeContexts;
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<WebGLRenderingContextBaseSet>, activeContexts, new ThreadSpecific<WebGLRenderingContextBaseSet>());
+    if (!activeContexts.isSet())
+        activeContexts->registerAsStaticReference();
+    return *activeContexts;
 }
 
 using WebGLRenderingContextBaseMap = PersistentHeapHashMap<WeakMember<WebGLRenderingContextBase>, int>;
 WebGLRenderingContextBaseMap& forciblyEvictedContexts()
 {
-    DEFINE_STATIC_LOCAL(WebGLRenderingContextBaseMap, forciblyEvictedContexts, ());
-    return forciblyEvictedContexts;
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<WebGLRenderingContextBaseMap>, forciblyEvictedContexts, new ThreadSpecific<WebGLRenderingContextBaseMap>());
+    if (!forciblyEvictedContexts.isSet())
+        forciblyEvictedContexts->registerAsStaticReference();
+    return *forciblyEvictedContexts;
 }
 
 } // namespace
 
 ScopedRGBEmulationColorMask::ScopedRGBEmulationColorMask(gpu::gles2::GLES2Interface* contextGL, GLboolean* colorMask, DrawingBuffer* drawingBuffer)
     : m_contextGL(contextGL)
     , m_requiresEmulation(drawingBuffer->requiresAlphaChannelToBePreserved())
 {
     if (m_requiresEmulation) {
         memcpy(m_colorMask, colorMask, 4 * sizeof(GLboolean));
@@ skipping 49 matching lines @@
             candidate = context;
             generation = forciblyEvictedContexts().get(context);
         }
     }
 
     return candidate;
 }
 
 void WebGLRenderingContextBase::activateContext(WebGLRenderingContextBase* context)
 {
+    unsigned maxGLContexts;

[sof, 2016/05/07 07:21:42]

Could you create a local method for this next to where
maxGLActiveContextsOnWorker is defined & declared?

+    if (isMainThread())
+        maxGLContexts = maxGLActiveContexts;
+    else
+        maxGLContexts = maxGLActiveContextsOnWorker;
     unsigned removedContexts = 0;
-    while (activeContexts().size() >= maxGLActiveContexts && removedContexts < maxGLActiveContexts) {
+    while (activeContexts().size() >= maxGLContexts && removedContexts < maxGLContexts) {
         forciblyLoseOldestContext("WARNING: Too many active WebGL contexts. Oldest context will be lost.");
         removedContexts++;
     }
 
     ASSERT(!context->isContextLost());
     activeContexts().add(context);
 }
 
 void WebGLRenderingContextBase::deactivateContext(WebGLRenderingContextBase* context)
 {
@@ skipping 11 matching lines @@
     forciblyEvictedContexts().remove(context);
 }
 
 void WebGLRenderingContextBase::willDestroyContext(WebGLRenderingContextBase* context)
 {
     // These two sets keep weak references to their contexts;
     // verify that the GC already removed the |context| entries.
     ASSERT(!forciblyEvictedContexts().contains(context));
     ASSERT(!activeContexts().contains(context));
 
+    unsigned maxGLContexts;
+    if (isMainThread())
+        maxGLContexts = maxGLActiveContexts;
+    else
+        maxGLContexts = maxGLActiveContextsOnWorker;
     // Try to re-enable the oldest inactive contexts.
-    while (activeContexts().size() < maxGLActiveContexts && forciblyEvictedContexts().size()) {
+    while (activeContexts().size() < maxGLContexts && forciblyEvictedContexts().size()) {
         WebGLRenderingContextBase* evictedContext = oldestEvictedContext();
         if (!evictedContext->m_restoreAllowed) {
             forciblyEvictedContexts().remove(evictedContext);
             continue;
         }
 
         IntSize desiredSize = DrawingBuffer::adjustSize(evictedContext->clampedCanvasSize(), IntSize(), evictedContext->m_maxTextureSize);
 
         // If there's room in the pixel budget for this context, restore it.
         if (!desiredSize.isEmpty()) {
@@ skipping 275 matching lines @@
     formatWebGLStatusString("Sandboxed", info.sandboxed ? "yes" : "no", statusMessage);
     formatWebGLStatusString("Optimus", info.optimus ? "yes" : "no", statusMessage);
     formatWebGLStatusString("AMD switchable", info.amdSwitchable ? "yes" : "no", statusMessage);
     formatWebGLStatusString("Reset notification strategy", String::format("0x%04x", info.resetNotificationStrategy).utf8().data(), statusMessage);
     formatWebGLStatusString("GPU process crash count", String::number(info.processCrashCount).utf8().data(), statusMessage);
     formatWebGLStatusString("ErrorMessage", info.errorMessage.utf8().data(), statusMessage);
     statusMessage.append(".");
     return statusMessage;
 }
 
-static PassOwnPtr<WebGraphicsContext3DProvider> createWebGraphicsContext3DProviderInternal(HTMLCanvasElement* canvas, ScriptState* scriptState, WebGLContextAttributes attributes, unsigned webGLVersion)
+void WebGLRenderingContextBase::createContextProviderOnMainThread(WebGLRenderingContextBase::ContextProviderCreationInfo* creationInfo, WaitableEvent* waitableEvent)
+{
+    ASSERT(isMainThread());
+    Platform::GraphicsInfo glInfo = creationInfo->glInfo();
+    OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
+        creationInfo->contextAttributes(), creationInfo->scriptState()->getExecutionContext()->url(), 0, &glInfo, Platform::DoNotBindToCurrentThread));
+    creationInfo->setContextProvider(provider.release());
+    waitableEvent->signal();
+}
+
+PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createContextProviderInternal(HTMLCanvasElement* canvas, ScriptState* scriptState, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
     Platform::ContextAttributes contextAttributes = toPlatformContextAttributes(attributes, webGLVersion);
     Platform::GraphicsInfo glInfo;
     OwnPtr<WebGraphicsContext3DProvider> contextProvider;
     if (canvas) {
         contextProvider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
-            contextAttributes, canvas->document().topDocument().url(), 0, &glInfo));
+            contextAttributes, canvas->document().topDocument().url(), 0, &glInfo, Platform::BindToCurrentThread));
     } else {
-        contextProvider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
-            contextAttributes, scriptState->getExecutionContext()->url(), 0, &glInfo));
+        if (isMainThread()) {
+            contextProvider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
+                contextAttributes, scriptState->getExecutionContext()->url(), 0, &glInfo, Platform::BindToCurrentThread));
+        } else {
+            WaitableEvent waitableEvent;

[sof, 2016/05/07 07:21:42]

Could you abstract this out as createContextProviderFromWorkerThread()? All the
scaffolding code around posting this task obscures reading.

Is it acceptable for this creation operation to be synchronous, or does that
aspect merit a TODO?

[xidachen, 2016/05/07 17:07:48]

Yes, it is definitely a future work to make this asynchronous. I put a TODO
comment here.

+            WebTaskRunner* taskRunner = Platform::current()->mainThread()->getWebTaskRunner();
+            OwnPtr<WebGLRenderingContextBase::ContextProviderCreationInfo> creationInfo = adoptPtr(new WebGLRenderingContextBase::ContextProviderCreationInfo(contextAttributes, glInfo, scriptState));
+            taskRunner->postTask(BLINK_FROM_HERE, threadSafeBind(&createContextProviderOnMainThread, AllowCrossThreadAccess(creationInfo.get()), AllowCrossThreadAccess(&waitableEvent)));
+            waitableEvent.wait();
+            contextProvider = creationInfo->releaseContextProvider();
+            if (!contextProvider->BindToCurrentThread())
+                return nullptr;
+        }
     }
     if (!contextProvider || shouldFailContextCreationForTesting) {
         shouldFailContextCreationForTesting = false;
         if (canvas)
             canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, extractWebGLContextCreationError(glInfo)));
         return nullptr;
     }
     gpu::gles2::GLES2Interface* gl = contextProvider->contextGL();
     if (!String(gl->GetString(GL_EXTENSIONS)).contains("GL_OES_packed_depth_stencil")) {
         if (canvas)
             canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "OES_packed_depth_stencil support is required."));
         return nullptr;
     }
-
     return contextProvider.release();
 }
 
 PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(HTMLCanvasElement* canvas, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
     Document& document = canvas->document();
     LocalFrame* frame = document.frame();
     if (!frame) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
     Settings* settings = frame->settings();
 
     // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
     // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
     if (!frame->loader().client()->allowWebGL(settings && settings->webGLEnabled())) {
         canvas->dispatchEvent(WebGLContextEvent::create(EventTypeNames::webglcontextcreationerror, false, true, "Web page was not allowed to create a WebGL context."));
         return nullptr;
     }
 
-    return createWebGraphicsContext3DProviderInternal(canvas, nullptr, attributes, webGLVersion);
+    return createContextProviderInternal(canvas, nullptr, attributes, webGLVersion);
 }
 
 PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProvider(ScriptState* scriptState, WebGLContextAttributes attributes, unsigned webGLVersion)
 {
-    return createWebGraphicsContext3DProviderInternal(nullptr, scriptState, attributes, webGLVersion);
+    return createContextProviderInternal(nullptr, scriptState, attributes, webGLVersion);
 }
 
 void WebGLRenderingContextBase::forceNextWebGLContextCreationToFail()
 {
     shouldFailContextCreationForTesting = true;
 }
 
 namespace {
 
 // ES2 enums
@@ skipping 493 matching lines @@
         tracker->loseExtension(true);
     }
     m_extensions.clear();
 
     // Context must be removed from the group prior to the destruction of the
     // GL context, otherwise shared objects may not be properly deleted.
     m_contextGroup->removeContext(this);
 
     destroyContext();
 
+    if (activeContexts().contains(this))
+        activeContexts().remove(this);
+    if (forciblyEvictedContexts().contains(this))
+        forciblyEvictedContexts().remove(this);
+
     willDestroyContext(this);
 }
 
 void WebGLRenderingContextBase::destroyContext()
 {
     if (!drawingBuffer())
         return;
 
     m_extensionsUtil.clear();
 
@@ skipping 4864 matching lines @@
 
     // If the context was lost due to RealLostContext, we need to destroy the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.
     if (drawingBuffer()) {
         m_drawingBuffer->beginDestruction();
         m_drawingBuffer.clear();
     }
 
     Platform::ContextAttributes attributes = toPlatformContextAttributes(m_requestedAttributes, version());
     Platform::GraphicsInfo glInfo;
     OwnPtr<WebGraphicsContext3DProvider> contextProvider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
-        attributes, canvas()->document().topDocument().url(), 0, &glInfo));
+        attributes, canvas()->document().topDocument().url(), 0, &glInfo, Platform::BindToCurrentThread));
     RefPtr<DrawingBuffer> buffer;
     if (contextProvider) {
         // Construct a new drawing buffer with the new GL context.
         buffer = createDrawingBuffer(contextProvider.release());
         // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
     }
     if (!buffer) {
         if (m_contextLostMode == RealLostContext) {
             m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts, BLINK_FROM_HERE);
         } else {
@@ skipping 324 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink