Fix crash in inspector-protocol/debugger/debugger-pause-dedicated-worker.html

Source/core/inspector/WorkerInspectorController.cpp

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/inspector/WorkerInspectorController.h"
 
+#include "bindings/core/v8/WorkerThreadDebugger.h"
 #include "core/InspectorBackendDispatcher.h"
 #include "core/InspectorFrontend.h"
 #include "core/inspector/AsyncCallTracker.h"
 #include "core/inspector/InjectedScriptHost.h"
 #include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorConsoleAgent.h"
 #include "core/inspector/InspectorFrontendChannel.h"
 #include "core/inspector/InspectorHeapProfilerAgent.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorProfilerAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InspectorStateClient.h"
+#include "core/inspector/InspectorTaskRunner.h"
 #include "core/inspector/InspectorTimelineAgent.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/WorkerConsoleAgent.h"
 #include "core/inspector/WorkerDebuggerAgent.h"
 #include "core/inspector/WorkerRuntimeAgent.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "wtf/PassOwnPtr.h"
 
@@ skipping 23 matching lines @@
 class WorkerStateClient final : public InspectorStateClient {
     WTF_MAKE_FAST_ALLOCATED(WorkerStateClient);
 public:
     WorkerStateClient(WorkerGlobalScope* context) { }
     virtual ~WorkerStateClient() { }
 
 private:
     virtual void updateInspectorStateCookie(const String& cookie) override { }
 };
 
+class RunInspectorCommandsTask final : public InspectorTaskRunner::Task {
+public:
+    explicit RunInspectorCommandsTask(WorkerThread* thread)
+        : m_thread(thread) { }
+    virtual ~RunInspectorCommandsTask() { }
+    virtual void run() override
+    {
+        // Process all queued debugger commands. WorkerThread is certainly
+        // alive if this task is being executed.
+        m_thread->willEnterNestedLoop();
+        while (MessageQueueMessageReceived == m_thread->runDebuggerTask(WorkerThread::DontWaitForMessage)) { }
+        m_thread->didLeaveNestedLoop();
+    }
+
+private:
+    WorkerThread* m_thread;
+};
+
 }
 
 class WorkerInjectedScriptHostClient: public InjectedScriptHostClient {
 public:
     WorkerInjectedScriptHostClient() { }
 
     ~WorkerInjectedScriptHostClient() override { }
 };
 
 WorkerInspectorController::WorkerInspectorController(WorkerGlobalScope* workerGlobalScope)
     : m_workerGlobalScope(workerGlobalScope)
     , m_stateClient(adoptPtr(new WorkerStateClient(workerGlobalScope)))
     , m_state(adoptPtrWillBeNoop(new InspectorCompositeState(m_stateClient.get())))
     , m_instrumentingAgents(InstrumentingAgents::create())
     , m_injectedScriptManager(InjectedScriptManager::createForWorker())
     , m_workerThreadDebugger(WorkerThreadDebugger::create(workerGlobalScope))
     , m_agents(m_instrumentingAgents.get(), m_state.get())
+    , m_inspectorTaskRunner(adoptPtr(new InspectorTaskRunner(v8::Isolate::GetCurrent())))
     , m_paused(false)
 {
     OwnPtrWillBeRawPtr<WorkerRuntimeAgent> workerRuntimeAgent = WorkerRuntimeAgent::create(m_injectedScriptManager.get(), m_workerThreadDebugger->debugger(), workerGlobalScope, this);
     m_workerRuntimeAgent = workerRuntimeAgent.get();
     m_agents.append(workerRuntimeAgent.release());
 
     OwnPtrWillBeRawPtr<WorkerDebuggerAgent> workerDebuggerAgent = WorkerDebuggerAgent::create(m_workerThreadDebugger.get(), workerGlobalScope, m_injectedScriptManager.get());
     m_workerDebuggerAgent = workerDebuggerAgent.get();
     m_agents.append(workerDebuggerAgent.release());
     m_asyncCallTracker = adoptPtrWillBeNoop(new AsyncCallTracker(m_workerDebuggerAgent, m_instrumentingAgents.get()));
@@ skipping 50 matching lines @@
 {
     ASSERT(!m_frontend);
     connectFrontend();
     m_state->loadFromCookie(inspectorCookie);
 
     m_agents.restore();
 }
 
 void WorkerInspectorController::dispatchMessageFromFrontend(const String& message)
 {
+    m_inspectorTaskRunner->setIgnoreInterrupts(true);
     if (m_backendDispatcher)
         m_backendDispatcher->dispatch(message);
+    m_inspectorTaskRunner->setIgnoreInterrupts(false);
 }
 
 void WorkerInspectorController::dispose()
 {
     m_instrumentingAgents->reset();
     disconnectFrontend();
 }
 
 void WorkerInspectorController::interruptAndDispatchInspectorCommands()
 {
-    m_workerDebuggerAgent->interruptAndDispatchInspectorCommands();
+    m_inspectorTaskRunner->interruptAndRun(adoptPtr(new RunInspectorCommandsTask(m_workerGlobalScope->thread())));
 }
 
 void WorkerInspectorController::resumeStartup()
 {
     m_paused = false;
 }
 
 bool WorkerInspectorController::isRunRequired()
 {
     return m_paused;
@@ skipping 19 matching lines @@
     visitor->trace(m_injectedScriptManager);
     visitor->trace(m_workerThreadDebugger);
     visitor->trace(m_backendDispatcher);
     visitor->trace(m_agents);
     visitor->trace(m_workerDebuggerAgent);
     visitor->trace(m_asyncCallTracker);
     visitor->trace(m_workerRuntimeAgent);
 }
 
 } // namespace blink