[worklets] Make WorkerThread handle both Worker and Worklet global scopes.

third_party/WebKit/Source/core/workers/WorkerThread.cpp

Index: third_party/WebKit/Source/core/workers/WorkerThread.cpp
diff --git a/third_party/WebKit/Source/core/workers/WorkerThread.cpp b/third_party/WebKit/Source/core/workers/WorkerThread.cpp
index 176304e57170f4e79a14d96b5f0f671cd127ab10..a1f892df5de8aec53099a0f52ce49ad0e0508b66 100644
--- a/third_party/WebKit/Source/core/workers/WorkerThread.cpp
+++ b/third_party/WebKit/Source/core/workers/WorkerThread.cpp
@@ -30,12 +30,14 @@
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8IdleTaskRunner.h"
+#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTaskRunner.h"
 #include "core/inspector/WorkerThreadDebugger.h"
 #include "core/origin_trials/OriginTrialContext.h"
 #include "core/workers/WorkerBackingThread.h"
 #include "core/workers/WorkerClients.h"
+#include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "platform/CrossThreadFunctional.h"
@@ -119,16 +121,16 @@ public:
     void willProcessTask() override
     {
         // No tasks should get executed after we have closed.
-        DCHECK(!m_workerThread->workerGlobalScope() || !m_workerThread->workerGlobalScope()->isClosing());
+        DCHECK(!m_workerThread->globalScope() || !m_workerThread->globalScope()->isClosing());
     }
 
     void didProcessTask() override
     {
         Microtask::performCheckpoint(m_workerThread->isolate());
-        if (WorkerGlobalScope* globalScope = m_workerThread->workerGlobalScope()) {
-            if (WorkerOrWorkletScriptController* scriptController = globalScope->scriptController())
+        if (WorkerOrWorkletGlobalScope* global = m_workerThread->globalScope()) {
+            if (WorkerOrWorkletScriptController* scriptController = global->scriptController())
                 scriptController->getRejectedPromises()->processQueue();
-            if (globalScope->isClosing()) {
+            if (global->isClosing()) {
                 // |m_workerThread| will eventually be requested to terminate.
                 m_workerThread->workerReportingProxy().workerGlobalScopeClosed();
 
@@ -246,7 +248,7 @@ void WorkerThread::postTask(const WebTraceLocation& location, std::unique_ptr<Ex
         return;
     if (isInstrumented) {
         DCHECK(isCurrentThread());
-        InspectorInstrumentation::asyncTaskScheduled(workerGlobalScope(), "Worker task", task.get());
+        InspectorInstrumentation::asyncTaskScheduled(globalScope(), "Worker task", task.get());
     }
     workerBackingThread().backingThread().postTask(location, crossThreadBind(&WorkerThread::performTaskOnWorkerThread, crossThreadUnretained(this), passed(std::move(task)), isInstrumented));
 }
@@ -289,10 +291,10 @@ void WorkerThread::stopRunningDebuggerTasksOnPauseOnWorkerThread()
     m_pausedInDebugger = false;
 }
 
-WorkerGlobalScope* WorkerThread::workerGlobalScope()
+WorkerOrWorkletGlobalScope* WorkerThread::globalScope()
 {
     DCHECK(isCurrentThread());
-    return m_workerGlobalScope.get();
+    return m_globalScope.get();
 }
 
 bool WorkerThread::terminated()
@@ -346,7 +348,7 @@ void WorkerThread::terminateInternal(TerminationMode mode)
         // termination via the global scope racing each other.
         MutexLocker lock(m_threadStateMutex);
 
-        hasBeenInitialized = m_workerGlobalScope;
+        hasBeenInitialized = m_globalScope;
 
         // If terminate has already been called.
         if (m_terminated) {
@@ -426,8 +428,8 @@ void WorkerThread::terminateInternal(TerminationMode mode)
 
 void WorkerThread::forciblyTerminateExecution()
 {
-    DCHECK(m_workerGlobalScope);
-    m_workerGlobalScope->scriptController()->willScheduleExecutionTermination();
+    DCHECK(m_globalScope);
+    m_globalScope->scriptController()->willScheduleExecutionTermination();
     isolate()->TerminateExecution();
 }
 
@@ -460,9 +462,9 @@ void WorkerThread::initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupD
         if (m_terminated) {
             DCHECK_EQ(ExitCode::GracefullyTerminated, m_exitCode);
 
-            // Notify the proxy that the WorkerGlobalScope has been disposed of.
-            // This can free this thread object, hence it must not be touched
-            // afterwards.
+            // Notify the proxy that the WorkerOrWorkletGlobalScope has been
+            // disposed of. This can free this thread object, hence it must not
+            // be touched afterwards.
             m_workerReportingProxy.workerThreadTerminated();
 
             // Notify the main thread that it is safe to deallocate our
@@ -481,19 +483,21 @@ void WorkerThread::initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupD
 
         // Optimize for memory usage instead of latency for the worker isolate.
         isolate()->IsolateInBackgroundNotification();
-        m_workerGlobalScope = createWorkerGlobalScope(std::move(startupData));
-        m_workerGlobalScope->scriptLoaded(sourceCode.length(), cachedMetaData.get() ? cachedMetaData->size() : 0);
+        m_globalScope = createWorkerGlobalScope(std::move(startupData));
+        if (m_globalScope->isWorkerGlobalScope())
+            toWorkerGlobalScope(m_globalScope)->scriptLoaded(sourceCode.length(), cachedMetaData.get() ? cachedMetaData->size() : 0);
 
-        // Notify proxy that a new WorkerGlobalScope has been created and started.
-        m_workerReportingProxy.workerGlobalScopeStarted(m_workerGlobalScope.get());
+        // Notify proxy that a new WorkerOrWorkletGlobalScope has been created
+        // and started.
+        m_workerReportingProxy.workerGlobalScopeStarted(m_globalScope.get());
 
-        WorkerOrWorkletScriptController* scriptController = m_workerGlobalScope->scriptController();
+        WorkerOrWorkletScriptController* scriptController = m_globalScope->scriptController();
         if (!scriptController->isExecutionForbidden()) {
             scriptController->initializeContextIfNeeded();
 
             // If Origin Trials have been registered before the V8 context was ready,
             // then inject them into the context now
-            ExecutionContext* executionContext = m_workerGlobalScope->getExecutionContext();
+            ExecutionContext* executionContext = m_globalScope;
             if (executionContext) {
                 OriginTrialContext* originTrialContext = OriginTrialContext::from(executionContext);
                 if (originTrialContext)
@@ -512,16 +516,19 @@ void WorkerThread::initializeOnWorkerThread(std::unique_ptr<WorkerThreadStartupD
             return;
     }
 
-    if (m_workerGlobalScope->scriptController()->isContextInitialized()) {
+    if (m_globalScope->scriptController()->isContextInitialized()) {
         m_workerReportingProxy.didInitializeWorkerContext();
         v8::HandleScope handleScope(isolate());
-        Platform::current()->workerContextCreated(m_workerGlobalScope->scriptController()->context());
+        Platform::current()->workerContextCreated(m_globalScope->scriptController()->context());
     }
 
-    CachedMetadataHandler* handler = workerGlobalScope()->createWorkerScriptCachedMetadataHandler(scriptURL, cachedMetaData.get());
-    bool success = m_workerGlobalScope->scriptController()->evaluate(ScriptSourceCode(sourceCode, scriptURL), nullptr, handler, v8CacheOptions);
-    m_workerGlobalScope->didEvaluateWorkerScript();
-    m_workerReportingProxy.didEvaluateWorkerScript(success);
+    if (m_globalScope->isWorkerGlobalScope()) {
+        WorkerGlobalScope* workerGlobalScope = toWorkerGlobalScope(m_globalScope);
+        CachedMetadataHandler* handler = workerGlobalScope->createWorkerScriptCachedMetadataHandler(scriptURL, cachedMetaData.get());
+        bool success = workerGlobalScope->scriptController()->evaluate(ScriptSourceCode(sourceCode, scriptURL), nullptr, handler, v8CacheOptions);
+        workerGlobalScope->didEvaluateWorkerScript();
+        m_workerReportingProxy.didEvaluateWorkerScript(success);
+    }
 
     postInitialize();
 }
@@ -540,8 +547,8 @@ void WorkerThread::prepareForShutdownOnWorkerThread()
 
     m_inspectorTaskRunner->kill();
     workerReportingProxy().willDestroyWorkerGlobalScope();
-    InspectorInstrumentation::allAsyncTasksCanceled(workerGlobalScope());
-    workerGlobalScope()->dispose();
+    InspectorInstrumentation::allAsyncTasksCanceled(globalScope());
+    globalScope()->dispose();
     workerBackingThread().backingThread().removeTaskObserver(m_microtaskRunner.get());
 }
 
@@ -561,8 +568,8 @@ void WorkerThread::performShutdownOnWorkerThread()
     // because no other thread will run GC or otherwise destroy them. If Oilpan
     // is enabled, we detach of the context/global scope, with the final heap
     // cleanup below sweeping it out.
-    m_workerGlobalScope->notifyContextDestroyed();
-    m_workerGlobalScope = nullptr;
+    m_globalScope->notifyContextDestroyed();
+    m_globalScope = nullptr;
 
     if (isOwningBackingThread())
         workerBackingThread().shutdown();
@@ -570,8 +577,8 @@ void WorkerThread::performShutdownOnWorkerThread()
 
     m_microtaskRunner = nullptr;
 
-    // Notify the proxy that the WorkerGlobalScope has been disposed of.
-    // This can free this thread object, hence it must not be touched
+    // Notify the proxy that the WorkerOrWorkletGlobalScope has been disposed
+    // of. This can free this thread object, hence it must not be touched
     // afterwards.
     workerReportingProxy().workerThreadTerminated();
 
@@ -584,19 +591,19 @@ void WorkerThread::performTaskOnWorkerThread(std::unique_ptr<ExecutionContextTas
     if (isInShutdown())
         return;
 
-    WorkerGlobalScope* globalScope = workerGlobalScope();
+    WorkerOrWorkletGlobalScope* global = globalScope();
     // If the thread is terminated before it had a chance initialize (see
     // WorkerThread::Initialize()), we mustn't run any of the posted tasks.
-    if (!globalScope) {
+    if (!global) {
         DCHECK(terminated());
         return;
     }
 
-    InspectorInstrumentation::AsyncTask asyncTask(globalScope, task.get(), isInstrumented);
+    InspectorInstrumentation::AsyncTask asyncTask(global, task.get(), isInstrumented);
     {
         DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounter, new CustomCountHistogram("WorkerThread.Task.Time", 0, 10000000, 50));
         ScopedUsHistogramTimer timer(scopedUsCounter);
-        task->performTask(globalScope);
+        task->performTask(global);
     }
 }