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 77 matching lines @@
     forciblyEvictedContexts().set(context, generation++);
 }
 
 void WebGLRenderingContextBase::removeFromEvictedList(WebGLRenderingContextBase* context)
 {
     forciblyEvictedContexts().remove(context);
 }
 
 void WebGLRenderingContextBase::willDestroyContext(WebGLRenderingContextBase* context)
 {
+    // If this function happens when the thread is terminating, then skip this function.
+    if (ThreadState::current()->isTerminating())
+        return;
+

[xidachen, 2016/05/06 15:15:28]

sof@: is it okay to call isTerminating() here? The reason I put it here is that
when the worker thread shuts down, it goes to here, and at line 233 where it
tries to see activeContexts().size(), the call activeContexts() creates a new
PersistentHeapHashSet, and the runTerminationGC() fails.

[sof, 2016/05/06 15:36:44]

Because the !currentCount assert fails, or something else?

[xidachen, 2016/05/06 15:38:05]

Yes, it is hitting the !currentCount, and I looked at the type of
PersistentNode, it is the HashSet and HashMap in here.

[sof, 2016/05/06 15:45:15]

thanks, I suggest we instead try to call releaseStaticPersistentNodes() (also)
inside the loop that runTerminationGC() has. I think it will work (but
untested.)

That way we avoid having to expose ThreadState internal states like
isTerminating() outside the Oilpan infrastructure.

[xidachen, 2016/05/06 15:59:35]

That works! Thank you.

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

It would be preferable to land that ThreadState change separately - a case we
hadn't come across before.

     // 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));
 
     // Try to re-enable the oldest inactive contexts.
     while (activeContexts().size() < maxGLActiveContexts && forciblyEvictedContexts().size()) {
         WebGLRenderingContextBase* evictedContext = oldestEvictedContext();
         if (!evictedContext->m_restoreAllowed) {
             forciblyEvictedContexts().remove(evictedContext);
@@ skipping 282 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 5403 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