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

Source/bindings/core/v8/V8Debugger.cpp

 /*
  * Copyright (c) 2010-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 19 matching lines @@
 
 #include "config.h"
 #include "bindings/core/v8/V8Debugger.h"
 
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8JavaScriptCallFrame.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/inspector/JavaScriptCallFrame.h"
 #include "core/inspector/ScriptDebugListener.h"
 #include "platform/JSONValues.h"
-#include "wtf/Deque.h"
 #include "wtf/StdLibExtras.h"
-#include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 #include "wtf/dtoa/utils.h"
 #include "wtf/text/CString.h"
 
 namespace blink {
 
 namespace {
 const char stepIntoV8MethodName[] = "stepIntoStatement";
 const char stepOutV8MethodName[] = "stepOutOfFunction";
 }
 
-class V8Debugger::ThreadSafeTaskQueue {
-    WTF_MAKE_NONCOPYABLE(ThreadSafeTaskQueue);
-public:
-    ThreadSafeTaskQueue() { }
-    PassOwnPtr<Task> tryTake()
-    {
-        MutexLocker lock(m_mutex);
-        if (m_queue.isEmpty())
-            return nullptr;
-        return m_queue.takeFirst();
-    }
-    void append(PassOwnPtr<Task> task)
-    {
-        MutexLocker lock(m_mutex);
-        m_queue.append(task);
-    }
-private:
-    Mutex m_mutex;
-    Deque<OwnPtr<Task>> m_queue;
-};
-
 v8::MaybeLocal<v8::Value> V8Debugger::callDebuggerMethod(const char* functionName, int argc, v8::Local<v8::Value> argv[])
 {
     v8::Local<v8::Object> debuggerScript = debuggerScriptLocal();
     v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(debuggerScript->Get(v8InternalizedString(functionName)));
     ASSERT(m_isolate->InContext());
     return V8ScriptRunner::callInternalFunction(function, debuggerScript, argc, argv, m_isolate);
 }
 
 V8Debugger::V8Debugger(v8::Isolate* isolate, Client* client)
     : m_isolate(isolate)
     , m_client(client)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
-    , m_taskQueue(adoptPtr(new ThreadSafeTaskQueue))
 {
 }
 
 V8Debugger::~V8Debugger()
 {
 }
 
 DEFINE_TRACE(V8Debugger)
 {
 }
@@ skipping 376 matching lines @@
     } else {
         v8::Local<v8::Value> argv[] = { m_executionState, v8::Integer::New(m_isolate, index) };
         currentCallFrameV8 = callDebuggerMethod("currentCallFrameByIndex", WTF_ARRAY_LENGTH(argv), argv).ToLocalChecked();
     }
     ASSERT(!currentCallFrameV8.IsEmpty());
     if (!currentCallFrameV8->IsObject())
         return nullptr;
     return JavaScriptCallFrame::create(debuggerContext(), v8::Local<v8::Object>::Cast(currentCallFrameV8));
 }
 
-void V8Debugger::interruptAndRun(PassOwnPtr<Task> task)
-{
-    m_taskQueue->append(task);
-    m_isolate->RequestInterrupt(&v8InterruptCallback, this);
-}
-
-void V8Debugger::runPendingTasks()
-{
-    while (true) {
-        OwnPtr<Task> task = m_taskQueue->tryTake();
-        if (!task)
-            return;
-        task->run();
-    }
-}
-
 static V8Debugger* toV8Debugger(v8::Local<v8::Value> data)
 {
     void* p = v8::Local<v8::External>::Cast(data)->Value();
     return static_cast<V8Debugger*>(p);
 }
 
 void V8Debugger::breakProgramCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ASSERT(2 == info.Length());
     V8Debugger* thisPtr = toV8Debugger(info.Data());
@@ skipping 39 matching lines @@
         callDebuggerMethod("stepFrameStatement", 1, argv);
     } else if (result == ScriptDebugListener::StepInto) {
         v8::Local<v8::Value> argv[] = { executionState };
         callDebuggerMethod(stepIntoV8MethodName, 1, argv);
     } else if (result == ScriptDebugListener::StepOut) {
         v8::Local<v8::Value> argv[] = { executionState };
         callDebuggerMethod(stepOutV8MethodName, 1, argv);
     }
 }
 
-void V8Debugger::v8InterruptCallback(v8::Isolate*, void* data)
-{
-    V8Debugger* server = static_cast<V8Debugger*>(data);
-    if (server->enabled())
-        server->runPendingTasks();
-}
-
 void V8Debugger::v8DebugEventCallback(const v8::Debug::EventDetails& eventDetails)
 {
     V8Debugger* thisPtr = toV8Debugger(eventDetails.GetCallbackData());
     thisPtr->handleV8DebugEvent(eventDetails);
 }
 
 v8::Local<v8::Value> V8Debugger::callInternalGetterFunction(v8::Local<v8::Object> object, const char* functionName)
 {
     v8::Local<v8::Value> getterValue = object->Get(v8InternalizedString(functionName));
     ASSERT(!getterValue.IsEmpty() && getterValue->IsFunction());
@@ skipping 170 matching lines @@
     return callDebuggerMethod("setFunctionVariableValue", 4, argv);
 }
 
 
 bool V8Debugger::isPaused()
 {
     return m_pausedScriptState;
 }
 
 } // namespace blink