Worker: Protect a running debugger task from forcible worker termination

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

 /*
  * Copyright (C) 2008 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 72 matching lines @@
     }
 
     void run()
     {
         DCHECK(isMainThread());
         MutexLocker lock(m_workerThread->m_threadStateMutex);
         if (m_workerThread->m_readyToShutdown) {
             // Shutdown sequence is now running. Just return.
             return;
         }
+        if (m_workerThread->m_runningDebuggerTask) {
+            // Any debugger task is guaranteed to finish, so we can wait for the
+            // completion. Shutdown sequence will start after that.
+            return;
+        }
 
         m_workerThread->forciblyTerminateExecution();
         DCHECK_EQ(WorkerThread::ExitCode::NotTerminated, m_workerThread->m_exitCode);
         m_workerThread->m_exitCode = WorkerThread::ExitCode::AsyncForciblyTerminated;
     }
 
     WorkerThread* m_workerThread;
     OwnPtr<CancellableTaskFactory> m_cancellableTaskFactory;
 };
 
@@ skipping 105 matching lines @@
     return workerBackingThread().isolate();
 }
 
 bool WorkerThread::isCurrentThread()
 {
     return m_started && workerBackingThread().backingThread().isCurrentThread();
 }
 
 void WorkerThread::postTask(const WebTraceLocation& location, std::unique_ptr<ExecutionContextTask> task)
 {
+    {
+        MutexLocker lock(m_threadStateMutex);
+        if (m_terminated || m_readyToShutdown)
+            return;
+    }
     workerBackingThread().backingThread().postTask(location, createWorkerThreadTask(std::move(task), true));
 }
 
 void WorkerThread::appendDebuggerTask(std::unique_ptr<CrossThreadClosure> task)
 {
+    DCHECK(isMainThread());
     {
         MutexLocker lock(m_threadStateMutex);
-        if (m_readyToShutdown)
+        if (m_terminated)
             return;
     }
-    m_inspectorTaskRunner->appendTask(threadSafeBind(&WorkerThread::runDebuggerTaskOnWorkerThread, AllowCrossThreadAccess(this), passed(std::move(task))));
+    m_inspectorTaskRunner->appendTask(threadSafeBind(&WorkerThread::performDebuggerTaskOnWorkerThread, AllowCrossThreadAccess(this), passed(std::move(task))));
     {
         MutexLocker lock(m_threadStateMutex);
-        if (isolate())
+        if (isolate() && !m_readyToShutdown)
             m_inspectorTaskRunner->interruptAndRunAllTasksDontWait(isolate());
     }
-    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::runDebuggerTaskDontWaitOnWorkerThread, AllowCrossThreadAccess(this)));
+    workerBackingThread().backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WorkerThread::performDebuggerTaskDontWaitOnWorkerThread, AllowCrossThreadAccess(this)));
 }
 
-void WorkerThread::startRunningDebuggerTasksOnPause()
+void WorkerThread::startRunningDebuggerTasksOnPauseOnWorkerThread()
 {
+    DCHECK(isCurrentThread());
     m_pausedInDebugger = true;
     ThreadDebugger::idleStarted(isolate());
     std::unique_ptr<CrossThreadClosure> task;
     do {
         {
             SafePointScope safePointScope(BlinkGC::HeapPointersOnStack);
             task = m_inspectorTaskRunner->takeNextTask(InspectorTaskRunner::WaitForTask);
         }
         if (task)
             (*task)();
     // Keep waiting until execution is resumed.
     } while (task && m_pausedInDebugger);
     ThreadDebugger::idleFinished(isolate());
 }
 
-void WorkerThread::stopRunningDebuggerTasksOnPause()
+void WorkerThread::stopRunningDebuggerTasksOnPauseOnWorkerThread()
 {
+    DCHECK(isCurrentThread());
     m_pausedInDebugger = false;
 }
 
 WorkerGlobalScope* WorkerThread::workerGlobalScope()
 {
     DCHECK(isCurrentThread());
     return m_workerGlobalScope.get();
 }
 
 bool WorkerThread::terminated()
@@ skipping 179 matching lines @@
             ExecutionContext* executionContext = m_workerGlobalScope->getExecutionContext();
             if (executionContext) {
                 OriginTrialContext* originTrialContext = OriginTrialContext::from(executionContext);
                 if (originTrialContext)
                     originTrialContext->initializePendingFeatures();
             }
         }
     }
 
     if (startMode == PauseWorkerGlobalScopeOnStart)
-        startRunningDebuggerTasksOnPause();
+        startRunningDebuggerTasksOnPauseOnWorkerThread();
 
     if (m_workerGlobalScope->scriptController()->isContextInitialized()) {
         m_workerReportingProxy.didInitializeWorkerContext();
         v8::HandleScope handleScope(isolate());
         Platform::current()->workerContextCreated(m_workerGlobalScope->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);
 
     postInitialize();
 }
 
 void WorkerThread::prepareForShutdownOnWorkerThread()
 {
     DCHECK(isCurrentThread());
     {
         MutexLocker lock(m_threadStateMutex);
         if (m_readyToShutdown)
             return;
         m_readyToShutdown = true;
         if (m_exitCode == ExitCode::NotTerminated)
             m_exitCode = ExitCode::GracefullyTerminated;
     }
 
+    m_inspectorTaskRunner->kill();
     workerReportingProxy().willDestroyWorkerGlobalScope();
     InspectorInstrumentation::allAsyncTasksCanceled(workerGlobalScope());
     workerGlobalScope()->dispose();
     workerBackingThread().backingThread().removeTaskObserver(m_microtaskRunner.get());
 }
 
 void WorkerThread::performShutdownOnWorkerThread()
 {
     DCHECK(isCurrentThread());
 #if DCHECK_IS_ON
@@ skipping 39 matching lines @@
     // WorkerThread::Initialize()), we mustn't run any of the posted tasks.
     if (!globalScope) {
         DCHECK(terminated());
         return;
     }
 
     InspectorInstrumentation::AsyncTask asyncTask(globalScope, task.get(), isInstrumented);
     task->performTask(globalScope);
 }
 
-void WorkerThread::runDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure> task)
+void WorkerThread::performDebuggerTaskOnWorkerThread(std::unique_ptr<CrossThreadClosure> task)
 {
     DCHECK(isCurrentThread());
     InspectorTaskRunner::IgnoreInterruptsScope scope(m_inspectorTaskRunner.get());
     {
         MutexLocker lock(m_threadStateMutex);
+        DCHECK(!m_readyToShutdown);
         m_runningDebuggerTask = true;
     }
     ThreadDebugger::idleFinished(isolate());
     (*task)();
     ThreadDebugger::idleStarted(isolate());
     {
         MutexLocker lock(m_threadStateMutex);
         m_runningDebuggerTask = false;
 
         if (!m_terminated)
             return;
         // terminate() was called. Shutdown sequence will start soon.
     }
     // Stop further worker tasks to run after this point.
     prepareForShutdownOnWorkerThread();
 }
 
-void WorkerThread::runDebuggerTaskDontWaitOnWorkerThread()
+void WorkerThread::performDebuggerTaskDontWaitOnWorkerThread()
 {
     DCHECK(isCurrentThread());
     std::unique_ptr<CrossThreadClosure> task = m_inspectorTaskRunner->takeNextTask(InspectorTaskRunner::DontWaitForTask);
     if (task)
         (*task)();
 }
 
 WorkerThread::ExitCode WorkerThread::getExitCode()
 {
     MutexLocker lock(m_threadStateMutex);
     return m_exitCode;
 }
 
 } // namespace blink