Merge pull request #626 from atom/v8-debugger

Implement V8 debugger agent

atom/browser/atom_browser_main_parts.cc

@@ -12,6 +12,7 @@
 #include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
 #include "base/command_line.h"
+#include "v8/include/v8-debug.h"
 
 #if defined(USE_X11)
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
@@ -55,11 +56,15 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
   node_bindings_->Initialize();
 
   // Support the "--debug" switch.
-  node_debugger_.reset(new NodeDebugger);
+  node_debugger_.reset(new NodeDebugger(js_env_->isolate()));
 
   // Create the global environment.
   global_env = node_bindings_->CreateEnvironment(js_env_->context());
 
+  // Make sure node can get correct environment when debugging.
+  if (node_debugger_->IsRunning())
+    global_env->AssignToContext(v8::Debug::GetDebugContext());
+
   // Add atom-shell extended APIs.
   atom_bindings_->BindTo(js_env_->isolate(), global_env->process_object());
 }

atom/browser/node_debugger.cc

@@ -6,25 +6,33 @@
 
 #include <string>
 
-#include "atom/common/atom_version.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
-#include "v8/include/v8.h"
+#include "base/strings/stringprintf.h"
-#include "v8/include/v8-debug.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/socket/tcp_listen_socket.h"
 
 #include "atom/common/node_includes.h"
 
 namespace atom {
 
-// static
+namespace {
-uv_async_t NodeDebugger::dispatch_debug_messages_async_;
 
-NodeDebugger::NodeDebugger() {
+// NodeDebugger is stored in Isolate's data, slots 0, 1, 3 have already been
-  uv_async_init(uv_default_loop(),
+// taken by gin, blink and node, using 2 is a safe option for now.
-                &dispatch_debug_messages_async_,
+const int kIsolateSlot = 2;
-                DispatchDebugMessagesInMainThread);
-  uv_unref(reinterpret_cast<uv_handle_t*>(&dispatch_debug_messages_async_));
 
+const char* kContentLength = "Content-Length";
+
+}  // namespace
+
+NodeDebugger::NodeDebugger(v8::Isolate* isolate)
+    : isolate_(isolate),
+      thread_("NodeDebugger"),
+      content_length_(-1),
+      weak_factory_(this) {
   bool use_debug_agent = false;
   int port = 5858;
   bool wait_for_connection = false;
@@ -44,26 +52,151 @@ NodeDebugger::NodeDebugger() {
   if (use_debug_agent) {
     if (!port_str.empty())
       base::StringToInt(port_str, &port);
-#if 0
+
-    v8::Debug::EnableAgent("atom-shell " ATOM_VERSION, port,
+    isolate_->SetData(kIsolateSlot, this);
-                           wait_for_connection);
+    v8::Debug::SetMessageHandler(DebugMessageHandler);
-    v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessagesInMsgThread,
+
-                                              false);
+    if (wait_for_connection)
-#endif
+      v8::Debug::DebugBreak(isolate_);
+
+    // Start a new IO thread.
+    base::Thread::Options options;
+    options.message_loop_type = base::MessageLoop::TYPE_IO;
+    if (!thread_.StartWithOptions(options)) {
+      LOG(ERROR) << "Unable to start debugger thread";
+      return;
+    }
+
+    // Start the server in new IO thread.
+    thread_.message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&NodeDebugger::StartServer, weak_factory_.GetWeakPtr(),
+                   port));
   }
 }
 
 NodeDebugger::~NodeDebugger() {
+  thread_.Stop();
+}
+
+bool NodeDebugger::IsRunning() const {
+  return thread_.IsRunning();
+}
+
+void NodeDebugger::StartServer(int port) {
+  server_ = net::TCPListenSocket::CreateAndListen("127.0.0.1", port, this);
+  if (!server_) {
+    LOG(ERROR) << "Cannot start debugger server";
+    return;
+  }
+}
+
+void NodeDebugger::CloseSession() {
+  accepted_socket_.reset();
+}
+
+void NodeDebugger::OnMessage(const std::string& message) {
+  if (message.find("\"type\":\"request\",\"command\":\"disconnect\"}") !=
+          std::string::npos)
+    CloseSession();
+
+  base::string16 message16 = base::UTF8ToUTF16(message);
+  v8::Debug::SendCommand(
+      isolate_,
+      reinterpret_cast<const uint16_t*>(message16.data()), message16.size());
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&v8::Debug::ProcessDebugMessages));
+}
+
+void NodeDebugger::SendMessage(const std::string& message) {
+  if (accepted_socket_) {
+    std::string header = base::StringPrintf(
+        "%s: %d\r\n\r\n", kContentLength, static_cast<int>(message.size()));
+    accepted_socket_->Send(header);
+    accepted_socket_->Send(message);
+  }
+}
+
+void NodeDebugger::SendConnectMessage() {
+  accepted_socket_->Send(base::StringPrintf(
+      "Type: connect\r\n"
+      "V8-Version: %s\r\n"
+      "Protocol-Version: 1\r\n"
+      "Embedding-Host: %s\r\n"
+      "%s: 0\r\n",
+      v8::V8::GetVersion(), "Atom-Shell", kContentLength), true);
 }
 
 // static
-void NodeDebugger::DispatchDebugMessagesInMainThread(uv_async_t* handle) {
+void NodeDebugger::DebugMessageHandler(const v8::Debug::Message& message) {
-  v8::Debug::ProcessDebugMessages();
+  NodeDebugger* self = static_cast<NodeDebugger*>(
+      message.GetIsolate()->GetData(kIsolateSlot));
+
+  if (self) {
+    std::string message8(*v8::String::Utf8Value(message.GetJSON()));
+    self->thread_.message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&NodeDebugger::SendMessage, self->weak_factory_.GetWeakPtr(),
+                   message8));
+  }
 }
 
-// static
+void NodeDebugger::DidAccept(net::StreamListenSocket* server,
-void NodeDebugger::DispatchDebugMessagesInMsgThread() {
+                             scoped_ptr<net::StreamListenSocket> socket) {
-  uv_async_send(&dispatch_debug_messages_async_);
+  // Only accept one session.
+  if (accepted_socket_) {
+    socket->Send(std::string("Remote debugging session already active"), true);
+    return;
+  }
+
+  accepted_socket_ = socket.Pass();
+  SendConnectMessage();
+}
+
+void NodeDebugger::DidRead(net::StreamListenSocket* socket,
+                           const char* data,
+                           int len) {
+  buffer_.append(data, len);
+
+  do {
+    if (buffer_.size() == 0)
+      return;
+
+    // Read the "Content-Length" header.
+    if (content_length_ < 0) {
+      size_t pos = buffer_.find("\r\n\r\n");
+      if (pos == std::string::npos)
+        return;
+
+      // We can be sure that the header is "Content-Length: xxx\r\n".
+      std::string content_length = buffer_.substr(16, pos - 16);
+      if (!base::StringToInt(content_length, &content_length_)) {
+        DidClose(accepted_socket_.get());
+        return;
+      }
+
+      // Strip header from buffer.
+      buffer_ = buffer_.substr(pos + 4);
+    }
+
+    // Read the message.
+    if (buffer_.size() >= static_cast<size_t>(content_length_)) {
+      std::string message = buffer_.substr(0, content_length_);
+      buffer_ = buffer_.substr(content_length_);
+
+      OnMessage(message);
+
+      // Get ready for next message.
+      content_length_ = -1;
+    }
+  } while (true);
+}
+
+void NodeDebugger::DidClose(net::StreamListenSocket* socket) {
+  // If we lost the connection, then simulate a disconnect msg:
+  OnMessage("{\"seq\":1,\"type\":\"request\",\"command\":\"disconnect\"}");
 }
 
 }  // namespace atom

atom/browser/node_debugger.h

@@ -5,22 +5,51 @@
 #ifndef ATOM_BROWSER_NODE_DEBUGGER_H_
 #define ATOM_BROWSER_NODE_DEBUGGER_H_
 
-#include "base/basictypes.h"
+#include <string>
-#include "vendor/node/deps/uv/include/uv.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread.h"
+#include "net/socket/stream_listen_socket.h"
+#include "v8/include/v8-debug.h"
 
 namespace atom {
 
 // Add support for node's "--debug" switch.
-class NodeDebugger {
+class NodeDebugger : public net::StreamListenSocket::Delegate {
  public:
-  NodeDebugger();
+  explicit NodeDebugger(v8::Isolate* isolate);
   virtual ~NodeDebugger();
 
- private:
+  bool IsRunning() const;
-  static void DispatchDebugMessagesInMainThread(uv_async_t* handle);
-  static void DispatchDebugMessagesInMsgThread();
 
-  static uv_async_t dispatch_debug_messages_async_;
+ private:
+  void StartServer(int port);
+  void CloseSession();
+  void OnMessage(const std::string& message);
+  void SendMessage(const std::string& message);
+  void SendConnectMessage();
+
+  static void DebugMessageHandler(const v8::Debug::Message& message);
+
+  // net::StreamListenSocket::Delegate:
+  virtual void DidAccept(net::StreamListenSocket* server,
+                         scoped_ptr<net::StreamListenSocket> socket) OVERRIDE;
+  virtual void DidRead(net::StreamListenSocket* socket,
+                       const char* data,
+                       int len) OVERRIDE;
+  virtual void DidClose(net::StreamListenSocket* socket) OVERRIDE;
+
+  v8::Isolate* isolate_;
+
+  base::Thread thread_;
+  scoped_ptr<net::StreamListenSocket> server_;
+  scoped_ptr<net::StreamListenSocket> accepted_socket_;
+
+  std::string buffer_;
+  int content_length_;
+
+  base::WeakPtrFactory<NodeDebugger> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NodeDebugger);
 };