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;
 
 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 379 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::createWebGraphicsContext3DProviderOnMainThread(WebGLRenderingContextBase::createWebGraphicsContext3DProviderUtils* createUtils, WaitableEvent* waitableEvent)
+{
+    ASSERT(isMainThread());
+    Platform::GraphicsInfo glInfo = createUtils->glInfo();
+    OwnPtr<WebGraphicsContext3DProvider> provider = adoptPtr(Platform::current()->createOffscreenGraphicsContext3DProvider(
+        createUtils->contextAttributes(), createUtils->scriptState()->getExecutionContext()->url(), 0, &glInfo, Platform::DoNotBindToCurrentThread));
+    createUtils->setContextProvider(provider.release());
+    waitableEvent->signal();
+}
+
+PassOwnPtr<WebGraphicsContext3DProvider> WebGLRenderingContextBase::createWebGraphicsContext3DProviderInternal(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;
+            WebTaskRunner* taskRunner = Platform::current()->mainThread()->getWebTaskRunner();
+            OwnPtr<WebGLRenderingContextBase::createWebGraphicsContext3DProviderUtils> createUtils = adoptPtr(new WebGLRenderingContextBase::createWebGraphicsContext3DProviderUtils(contextAttributes, glInfo, scriptState));
+            taskRunner->postTask(BLINK_FROM_HERE, threadSafeBind(&createWebGraphicsContext3DProviderOnMainThread, AllowCrossThreadAccess(createUtils.get()), AllowCrossThreadAccess(&waitableEvent)));
+            waitableEvent.wait();
+            contextProvider = createUtils->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;
@@ skipping 519 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))

[sof, 2016/05/06 16:06:17]

This shouldn't be needed -- if this context object is allowed to destruct, that
means there can be no reference to it remaining. Including from these two global
maps which keeps weak references.

[xidachen, 2016/05/06 16:54:43]

I was actually going to ask for your suggestions. If I comment our this section,
I am hitting this assertion on willDestroyContext:
ASSERT(!activeContexts().contains(context));

This is specific to a worker thread.

[Ken Russell (switch to Gerrit), 2016/05/06 17:56:46]

Interesting. What's the order of processing when clearing weak refs in Oilpan?
Is the target object destroyed and then all weak refs to it cleared? It sounds
like this is happening, as opposed to vice versa.

[sof, 2016/05/06 18:43:34]

The only reason I can think of why that might happen is if thread-local weak
processing doesn't happen when terminating a worker thread, for some reason. But
looking at the code, it ought to, so I don't understand what is going on here. 

But it's a bug, all weak processing must have happened before finalizers run.

[sof, 2016/05/06 21:37:23]

I now understand what's missing here,
https://codereview.chromium.org/1957523007/ addresses. Will tidy up and send it
along tomorrow.

[sof, 2016/05/07 17:09:49]

If the CL is rebased >= r392263, the fix will be in scope & this shouldn't be
needed.

+        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