DevTools: use v8::Isolate::RequestInterrupt instead of v8::Debug::DebugBreakForCommand

Source/bindings/core/v8/ScriptDebugServer.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 23 matching lines @@
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptSourceCode.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 "public/platform/Platform.h"
 #include "public/platform/WebData.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 {
-
-class ClientDataImpl : public v8::Debug::ClientData {
-public:
-    ClientDataImpl(PassOwnPtr<ScriptDebugServer::Task> task) : m_task(task) { }
-    virtual ~ClientDataImpl() { }
-    ScriptDebugServer::Task* task() const { return m_task.get(); }
-private:
-    OwnPtr<ScriptDebugServer::Task> m_task;
-};
-
 const char stepIntoV8MethodName[] = "stepIntoStatement";
 const char stepOutV8MethodName[] = "stepOutOfFunction";
 }
 
+class ScriptDebugServer::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::Local<v8::Value> ScriptDebugServer::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);
 }
 
 ScriptDebugServer::ScriptDebugServer(v8::Isolate* isolate)
     : m_isolate(isolate)
     , m_breakpointsActivated(true)
     , m_compiledScripts(isolate)
     , m_runningNestedMessageLoop(false)
+    , m_taskQueue(adoptPtr(new ThreadSafeTaskQueue))
 {
 }
 
 ScriptDebugServer::~ScriptDebugServer()
 {
 }
 
 DEFINE_TRACE(ScriptDebugServer)
 {
 }
@@ skipping 372 matching lines @@
         currentCallFrameV8 = callDebuggerMethod("currentCallFrameByIndex", WTF_ARRAY_LENGTH(argv), argv);
     }
     ASSERT(!currentCallFrameV8.IsEmpty());
     if (!currentCallFrameV8->IsObject())
         return nullptr;
     return JavaScriptCallFrame::create(v8::Debug::GetDebugContext(), v8::Local<v8::Object>::Cast(currentCallFrameV8));
 }
 
 void ScriptDebugServer::interruptAndRun(PassOwnPtr<Task> task)
 {
-    v8::Debug::DebugBreakForCommand(m_isolate, new ClientDataImpl(task));
+    m_taskQueue->append(task);
+    m_isolate->RequestInterrupt(&v8InterruptCallback, this);
 }
 
 void ScriptDebugServer::runPendingTasks()
 {
-    v8::Debug::ProcessDebugMessages();
+    while (true) {
+        OwnPtr<Task> task = m_taskQueue->tryTake();
+        if (!task)
+            return;
+        task->run();
+    }
 }
 
 static ScriptDebugServer* toScriptDebugServer(v8::Local<v8::Value> data)
 {
     void* p = v8::Local<v8::External>::Cast(data)->Value();
     return static_cast<ScriptDebugServer*>(p);
 }
 
 void ScriptDebugServer::breakProgramCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
@@ skipping 41 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 ScriptDebugServer::v8InterruptCallback(v8::Isolate*, void* data)
+{
+    ScriptDebugServer* server = static_cast<ScriptDebugServer*>(data);
+    server->runPendingTasks();
+}
+
 void ScriptDebugServer::v8DebugEventCallback(const v8::Debug::EventDetails& eventDetails)
 {
     ScriptDebugServer* thisPtr = toScriptDebugServer(eventDetails.GetCallbackData());
     thisPtr->handleV8DebugEvent(eventDetails);
 }
 
 static v8::Local<v8::Value> callInternalGetterFunction(v8::Local<v8::Object> object, const char* functionName, v8::Isolate* isolate)
 {
     v8::Local<v8::Value> getterValue = object->Get(v8AtomicString(isolate, functionName));
     ASSERT(!getterValue.IsEmpty() && getterValue->IsFunction());
     return V8ScriptRunner::callInternalFunction(v8::Local<v8::Function>::Cast(getterValue), object, 0, 0, isolate);
 }
 
 void ScriptDebugServer::handleV8DebugEvent(const v8::Debug::EventDetails& eventDetails)
 {
     v8::DebugEvent event = eventDetails.GetEvent();
-
-    if (event == v8::BreakForCommand) {
-        ClientDataImpl* data = static_cast<ClientDataImpl*>(eventDetails.GetClientData());
-        data->task()->run();
-        return;
-    }
-
     if (event != v8::AsyncTaskEvent && event != v8::Break && event != v8::Exception && event != v8::AfterCompile && event != v8::BeforeCompile && event != v8::CompileError && event != v8::PromiseEvent)
         return;
 
     v8::Local<v8::Context> eventContext = eventDetails.GetEventContext();
     ASSERT(!eventContext.IsEmpty());
 
     ScriptDebugListener* listener = getDebugListenerForContext(eventContext);
     if (listener) {
         v8::HandleScope scope(m_isolate);
         if (event == v8::AfterCompile || event == v8::CompileError) {
@@ skipping 219 matching lines @@
             *lineNumber = message->GetLineNumber();
             *columnNumber = message->GetStartColumn();
             v8::Local<v8::StackTrace> messageStackTrace = message->GetStackTrace();
             if (!messageStackTrace.IsEmpty() && messageStackTrace->GetFrameCount() > 0)
                 *stackTrace = createScriptCallStack(m_isolate, messageStackTrace, messageStackTrace->GetFrameCount());
         }
     }
 }
 
 } // namespace blink