Merge pull request #2608 from atom/fix-debugger

Fix debugger not working for main process

atom/app/node_main.cc

@@ -5,15 +5,18 @@
 #include "atom/app/node_main.h"
 
 #include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
+#include "atom/common/node_includes.h"
+#include "base/command_line.h"
 #include "gin/array_buffer.h"
 #include "gin/public/isolate_holder.h"
 #include "gin/v8_initializer.h"
 
-#include "atom/common/node_includes.h"
-
 namespace atom {
 
 int NodeMain(int argc, char *argv[]) {
+  base::CommandLine::Init(argc, argv);
+
   argv = uv_setup_args(argc, argv);
   int exec_argc;
   const char** exec_argv;
@@ -31,17 +34,13 @@ int NodeMain(int argc, char *argv[]) {
         gin_env.isolate(), uv_default_loop(), gin_env.context(), argc, argv,
         exec_argc, exec_argv);
 
-    // Start debugger.
+    // Start our custom debugger implementation.
-    node::node_isolate = gin_env.isolate();
+    NodeDebugger node_debugger(gin_env.isolate());
-    if (node::use_debug_agent)
+    if (node_debugger.IsRunning())
-      node::StartDebug(env, node::debug_wait_connect);
+      env->AssignToContext(v8::Debug::GetDebugContext());
 
     node::LoadEnvironment(env);
 
-    // Enable debugger.
-    if (node::use_debug_agent)
-      node::EnableDebug(env);
-
     bool more;
     do {
       more = uv_run(env->event_loop(), UV_RUN_ONCE);

atom/browser/atom_browser_main_parts.cc

@@ -9,6 +9,7 @@
 #include "atom/browser/atom_browser_context.h"
 #include "atom/browser/browser.h"
 #include "atom/browser/javascript_environment.h"
+#include "atom/browser/node_debugger.h"
 #include "atom/common/api/atom_bindings.h"
 #include "atom/common/node_bindings.h"
 #include "base/command_line.h"
@@ -69,9 +70,16 @@ void AtomBrowserMainParts::PostEarlyInitialization() {
 
   node_bindings_->Initialize();
 
+  // Support the "--debug" switch.
+  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/atom_browser_main_parts.h

@@ -19,6 +19,7 @@ class AtomBindings;
 class Browser;
 class JavascriptEnvironment;
 class NodeBindings;
+class NodeDebugger;
 
 class AtomBrowserMainParts : public brightray::BrowserMainParts {
  public:
@@ -57,6 +58,7 @@ class AtomBrowserMainParts : public brightray::BrowserMainParts {
   scoped_ptr<JavascriptEnvironment> js_env_;
   scoped_ptr<NodeBindings> node_bindings_;
   scoped_ptr<AtomBindings> atom_bindings_;
+  scoped_ptr<NodeDebugger> node_debugger_;
 
   base::Timer gc_timer_;
 

atom/browser/node_debugger.cc

@@ -0,0 +1,209 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/node_debugger.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "base/command_line.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/test/embedded_test_server/tcp_listen_socket.h"
+
+#include "atom/common/node_includes.h"
+
+namespace atom {
+
+namespace {
+
+// NodeDebugger is stored in Isolate's data, slots 0, 1, 3 have already been
+// taken by gin, blink and node, using 2 is a safe option for now.
+const int kIsolateSlot = 2;
+
+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;
+
+  std::string port_str;
+  base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
+  if (cmd->HasSwitch("debug")) {
+    use_debug_agent = true;
+    port_str = cmd->GetSwitchValueASCII("debug");
+  }
+  if (cmd->HasSwitch("debug-brk")) {
+    use_debug_agent = true;
+    wait_for_connection = true;
+    port_str = cmd->GetSwitchValueASCII("debug-brk");
+  }
+
+  if (use_debug_agent) {
+    if (!port_str.empty())
+      base::StringToInt(port_str, &port);
+
+    isolate_->SetData(kIsolateSlot, this);
+    v8::Debug::SetMessageHandler(DebugMessageHandler);
+
+    if (wait_for_connection)
+      v8::Debug::DebugBreak(isolate_);
+
+    uv_async_init(uv_default_loop(), &weak_up_ui_handle_, ProcessMessageInUI);
+
+    // 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::test_server::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());
+
+  uv_async_send(&weak_up_ui_handle_);
+}
+
+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_PRODUCT_NAME, kContentLength), true);
+}
+
+// static
+void NodeDebugger::ProcessMessageInUI(uv_async_t* handle) {
+  v8::Debug::ProcessDebugMessages();
+}
+
+// static
+void NodeDebugger::DebugMessageHandler(const v8::Debug::Message& message) {
+  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));
+  }
+}
+
+void NodeDebugger::DidAccept(
+    net::test_server::StreamListenSocket* server,
+    scoped_ptr<net::test_server::StreamListenSocket> socket) {
+  // 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::test_server::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::test_server::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

@@ -0,0 +1,65 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_NODE_DEBUGGER_H_
+#define ATOM_BROWSER_NODE_DEBUGGER_H_
+
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread.h"
+#include "net/test/embedded_test_server/stream_listen_socket.h"
+#include "v8/include/v8-debug.h"
+#include "vendor/node/deps/uv/include/uv.h"
+
+namespace atom {
+
+// Add support for node's "--debug" switch.
+class NodeDebugger : public net::test_server::StreamListenSocket::Delegate {
+ public:
+  explicit NodeDebugger(v8::Isolate* isolate);
+  virtual ~NodeDebugger();
+
+  bool IsRunning() const;
+
+ private:
+  void StartServer(int port);
+  void CloseSession();
+  void OnMessage(const std::string& message);
+  void SendMessage(const std::string& message);
+  void SendConnectMessage();
+
+  static void ProcessMessageInUI(uv_async_t* handle);
+
+  static void DebugMessageHandler(const v8::Debug::Message& message);
+
+  // net::test_server::StreamListenSocket::Delegate:
+  void DidAccept(
+      net::test_server::StreamListenSocket* server,
+      scoped_ptr<net::test_server::StreamListenSocket> socket) override;
+  void DidRead(net::test_server::StreamListenSocket* socket,
+               const char* data,
+               int len) override;
+  void DidClose(net::test_server::StreamListenSocket* socket) override;
+
+  v8::Isolate* isolate_;
+
+  uv_async_t weak_up_ui_handle_;
+
+  base::Thread thread_;
+  scoped_ptr<net::test_server::StreamListenSocket> server_;
+  scoped_ptr<net::test_server::StreamListenSocket> accepted_socket_;
+
+  std::string buffer_;
+  int content_length_;
+
+  base::WeakPtrFactory<NodeDebugger> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(NodeDebugger);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_NODE_DEBUGGER_H_

atom/common/node_bindings.cc

@@ -137,11 +137,6 @@ void NodeBindings::Initialize() {
     AtomCommandLine::InitializeFromCommandLine();
 #endif
 
-  // Parse the debug args.
-  auto args = AtomCommandLine::argv();
-  for (const std::string& arg : args)
-    node::ParseDebugOpt(arg.c_str());
-
   // Init node.
   // (we assume node::Init would not modify the parameters under embedded mode).
   node::Init(nullptr, nullptr, nullptr, nullptr);
@@ -179,15 +174,7 @@ node::Environment* NodeBindings::CreateEnvironment(
 }
 
 void NodeBindings::LoadEnvironment(node::Environment* env) {
-  node::node_isolate = env->isolate();
-  if (node::use_debug_agent)
-    node::StartDebug(env, node::debug_wait_connect);
-
   node::LoadEnvironment(env);
-
-  if (node::use_debug_agent)
-    node::EnableDebug(env);
-
   mate::EmitEvent(env->isolate(), env->process_object(), "loaded");
 }
 

chromium_src/net/test/embedded_test_server/stream_listen_socket.cc

@@ -0,0 +1,330 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/test/embedded_test_server/stream_listen_socket.h"
+
+#if defined(OS_WIN)
+// winsock2.h must be included first in order to ensure it is included before
+// windows.h.
+#include <winsock2.h>
+#elif defined(OS_POSIX)
+#include <arpa/inet.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include "net/base/net_errors.h"
+#endif
+
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/sys_byteorder.h"
+#include "base/threading/platform_thread.h"
+#include "build/build_config.h"
+#include "net/base/ip_endpoint.h"
+#include "net/base/net_errors.h"
+#include "net/base/net_util.h"
+#include "net/socket/socket_descriptor.h"
+
+using std::string;
+
+#if defined(OS_WIN)
+typedef int socklen_t;
+#endif  // defined(OS_WIN)
+
+namespace net {
+
+namespace test_server {
+
+namespace {
+
+const int kReadBufSize = 4096;
+
+}  // namespace
+
+#if defined(OS_WIN)
+const int StreamListenSocket::kSocketError = SOCKET_ERROR;
+#elif defined(OS_POSIX)
+const int StreamListenSocket::kSocketError = -1;
+#endif
+
+StreamListenSocket::StreamListenSocket(SocketDescriptor s,
+                                       StreamListenSocket::Delegate* del)
+    : socket_delegate_(del),
+      socket_(s),
+      reads_paused_(false),
+      has_pending_reads_(false) {
+#if defined(OS_WIN)
+  socket_event_ = WSACreateEvent();
+  // TODO(ibrar): error handling in case of socket_event_ == WSA_INVALID_EVENT.
+  WatchSocket(NOT_WAITING);
+#elif defined(OS_POSIX)
+  wait_state_ = NOT_WAITING;
+#endif
+}
+
+StreamListenSocket::~StreamListenSocket() {
+  CloseSocket();
+#if defined(OS_WIN)
+  if (socket_event_) {
+    WSACloseEvent(socket_event_);
+    socket_event_ = WSA_INVALID_EVENT;
+  }
+#endif
+}
+
+void StreamListenSocket::Send(const char* bytes,
+                              int len,
+                              bool append_linefeed) {
+  SendInternal(bytes, len);
+  if (append_linefeed)
+    SendInternal("\r\n", 2);
+}
+
+void StreamListenSocket::Send(const string& str, bool append_linefeed) {
+  Send(str.data(), static_cast<int>(str.length()), append_linefeed);
+}
+
+int StreamListenSocket::GetLocalAddress(IPEndPoint* address) const {
+  SockaddrStorage storage;
+  if (getsockname(socket_, storage.addr, &storage.addr_len)) {
+#if defined(OS_WIN)
+    int err = WSAGetLastError();
+#else
+    int err = errno;
+#endif
+    return MapSystemError(err);
+  }
+  if (!address->FromSockAddr(storage.addr, storage.addr_len))
+    return ERR_ADDRESS_INVALID;
+  return OK;
+}
+
+int StreamListenSocket::GetPeerAddress(IPEndPoint* address) const {
+  SockaddrStorage storage;
+  if (getpeername(socket_, storage.addr, &storage.addr_len)) {
+#if defined(OS_WIN)
+    int err = WSAGetLastError();
+#else
+    int err = errno;
+#endif
+    return MapSystemError(err);
+  }
+
+  if (!address->FromSockAddr(storage.addr, storage.addr_len))
+    return ERR_ADDRESS_INVALID;
+
+  return OK;
+}
+
+SocketDescriptor StreamListenSocket::AcceptSocket() {
+  SocketDescriptor conn = HANDLE_EINTR(accept(socket_, NULL, NULL));
+  if (conn == kInvalidSocket)
+    LOG(ERROR) << "Error accepting connection.";
+  else
+    SetNonBlocking(conn);
+  return conn;
+}
+
+void StreamListenSocket::SendInternal(const char* bytes, int len) {
+  char* send_buf = const_cast<char*>(bytes);
+  int len_left = len;
+  while (true) {
+    int sent = HANDLE_EINTR(send(socket_, send_buf, len_left, 0));
+    if (sent == len_left) {  // A shortcut to avoid extraneous checks.
+      break;
+    }
+    if (sent == kSocketError) {
+#if defined(OS_WIN)
+      if (WSAGetLastError() != WSAEWOULDBLOCK) {
+        LOG(ERROR) << "send failed: WSAGetLastError()==" << WSAGetLastError();
+#elif defined(OS_POSIX)
+      if (errno != EWOULDBLOCK && errno != EAGAIN) {
+        LOG(ERROR) << "send failed: errno==" << errno;
+#endif
+        break;
+      }
+      // Otherwise we would block, and now we have to wait for a retry.
+      // Fall through to PlatformThread::YieldCurrentThread()
+    } else {
+      // sent != len_left according to the shortcut above.
+      // Shift the buffer start and send the remainder after a short while.
+      send_buf += sent;
+      len_left -= sent;
+    }
+    base::PlatformThread::YieldCurrentThread();
+  }
+}
+
+void StreamListenSocket::Listen() {
+  int backlog = 10;  // TODO(erikkay): maybe don't allow any backlog?
+  if (listen(socket_, backlog) == -1) {
+    // TODO(erikkay): error handling.
+    LOG(ERROR) << "Could not listen on socket.";
+    return;
+  }
+#if defined(OS_POSIX)
+  WatchSocket(WAITING_ACCEPT);
+#endif
+}
+
+void StreamListenSocket::Read() {
+  char buf[kReadBufSize + 1];  // +1 for null termination.
+  int len;
+  do {
+    len = HANDLE_EINTR(recv(socket_, buf, kReadBufSize, 0));
+    if (len == kSocketError) {
+#if defined(OS_WIN)
+      int err = WSAGetLastError();
+      if (err == WSAEWOULDBLOCK) {
+#elif defined(OS_POSIX)
+      if (errno == EWOULDBLOCK || errno == EAGAIN) {
+#endif
+        break;
+      } else {
+        // TODO(ibrar): some error handling required here.
+        break;
+      }
+    } else if (len == 0) {
+#if defined(OS_POSIX)
+      // In Windows, Close() is called by OnObjectSignaled. In POSIX, we need
+      // to call it here.
+      Close();
+#endif
+    } else {
+      // TODO(ibrar): maybe change DidRead to take a length instead.
+      DCHECK_GT(len, 0);
+      DCHECK_LE(len, kReadBufSize);
+      buf[len] = 0;  // Already create a buffer with +1 length.
+      socket_delegate_->DidRead(this, buf, len);
+    }
+  } while (len == kReadBufSize);
+}
+
+void StreamListenSocket::Close() {
+#if defined(OS_POSIX)
+  if (wait_state_ == NOT_WAITING)
+    return;
+  wait_state_ = NOT_WAITING;
+#endif
+  UnwatchSocket();
+  socket_delegate_->DidClose(this);
+}
+
+void StreamListenSocket::CloseSocket() {
+  if (socket_ != kInvalidSocket) {
+    UnwatchSocket();
+#if defined(OS_WIN)
+    closesocket(socket_);
+#elif defined(OS_POSIX)
+    close(socket_);
+#endif
+  }
+}
+
+void StreamListenSocket::WatchSocket(WaitState state) {
+#if defined(OS_WIN)
+  WSAEventSelect(socket_, socket_event_, FD_ACCEPT | FD_CLOSE | FD_READ);
+  watcher_.StartWatching(socket_event_, this);
+#elif defined(OS_POSIX)
+  // Implicitly calls StartWatchingFileDescriptor().
+  base::MessageLoopForIO::current()->WatchFileDescriptor(
+      socket_, true, base::MessageLoopForIO::WATCH_READ, &watcher_, this);
+  wait_state_ = state;
+#endif
+}
+
+void StreamListenSocket::UnwatchSocket() {
+#if defined(OS_WIN)
+  watcher_.StopWatching();
+#elif defined(OS_POSIX)
+  watcher_.StopWatchingFileDescriptor();
+#endif
+}
+
+// TODO(ibrar): We can add these functions into OS dependent files.
+#if defined(OS_WIN)
+// MessageLoop watcher callback.
+void StreamListenSocket::OnObjectSignaled(HANDLE object) {
+  WSANETWORKEVENTS ev;
+  if (kSocketError == WSAEnumNetworkEvents(socket_, socket_event_, &ev)) {
+    // TODO
+    return;
+  }
+
+  // If both FD_CLOSE and FD_READ are set we only call Read().
+  // This will cause OnObjectSignaled to be called immediately again
+  // unless this socket is destroyed in Read().
+  if ((ev.lNetworkEvents & (FD_CLOSE | FD_READ)) == FD_CLOSE) {
+    Close();
+    // Close might have deleted this object. We should return immediately.
+    return;
+  }
+  // The object was reset by WSAEnumNetworkEvents.  Watch for the next signal.
+  watcher_.StartWatching(object, this);
+
+  if (ev.lNetworkEvents == 0) {
+    // Occasionally the event is set even though there is no new data.
+    // The net seems to think that this is ignorable.
+    return;
+  }
+  if (ev.lNetworkEvents & FD_ACCEPT) {
+    Accept();
+  }
+  if (ev.lNetworkEvents & FD_READ) {
+    if (reads_paused_) {
+      has_pending_reads_ = true;
+    } else {
+      Read();
+      // Read might have deleted this object. We should return immediately.
+    }
+  }
+}
+#elif defined(OS_POSIX)
+void StreamListenSocket::OnFileCanReadWithoutBlocking(int fd) {
+  switch (wait_state_) {
+    case WAITING_ACCEPT:
+      Accept();
+      break;
+    case WAITING_READ:
+      if (reads_paused_) {
+        has_pending_reads_ = true;
+      } else {
+        Read();
+      }
+      break;
+    default:
+      // Close() is called by Read() in the Linux case.
+      NOTREACHED();
+      break;
+  }
+}
+
+void StreamListenSocket::OnFileCanWriteWithoutBlocking(int fd) {
+  // MessagePumpLibevent callback, we don't listen for write events
+  // so we shouldn't ever reach here.
+  NOTREACHED();
+}
+
+#endif
+
+void StreamListenSocket::PauseReads() {
+  DCHECK(!reads_paused_);
+  reads_paused_ = true;
+}
+
+void StreamListenSocket::ResumeReads() {
+  DCHECK(reads_paused_);
+  reads_paused_ = false;
+  if (has_pending_reads_) {
+    has_pending_reads_ = false;
+    Read();
+  }
+}
+
+}  // namespace test_server
+
+}  // namespace net

chromium_src/net/test/embedded_test_server/stream_listen_socket.h

@@ -0,0 +1,151 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Stream-based listen socket implementation that handles reading and writing
+// to the socket, but does not handle creating the socket nor connecting
+// sockets, which are handled by subclasses on creation and in Accept,
+// respectively.
+
+// StreamListenSocket handles IO asynchronously in the specified MessageLoop.
+// This class is NOT thread safe. It uses WSAEVENT handles to monitor activity
+// in a given MessageLoop. This means that callbacks will happen in that loop's
+// thread always and that all other methods (including constructor and
+// destructor) should also be called from the same thread.
+
+#ifndef NET_TEST_EMBEDDED_TEST_SERVER_STREAM_LISTEN_SOCKET_H_
+#define NET_TEST_EMBEDDED_TEST_SERVER_STREAM_LISTEN_SOCKET_H_
+
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <winsock2.h>
+#endif
+#include <string>
+#if defined(OS_WIN)
+#include "base/win/object_watcher.h"
+#elif defined(OS_POSIX)
+#include "base/message_loop/message_loop.h"
+#endif
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
+#include "net/base/net_export.h"
+#include "net/socket/socket_descriptor.h"
+
+namespace net {
+
+class IPEndPoint;
+
+namespace test_server {
+
+class StreamListenSocket :
+#if defined(OS_WIN)
+    public base::win::ObjectWatcher::Delegate {
+#elif defined(OS_POSIX)
+    public base::MessageLoopForIO::Watcher {
+#endif
+
+ public:
+  ~StreamListenSocket() override;
+
+  // TODO(erikkay): this delegate should really be split into two parts
+  // to split up the listener from the connected socket.  Perhaps this class
+  // should be split up similarly.
+  class Delegate {
+   public:
+    // |server| is the original listening Socket, connection is the new
+    // Socket that was created.
+    virtual void DidAccept(StreamListenSocket* server,
+                           scoped_ptr<StreamListenSocket> connection) = 0;
+    virtual void DidRead(StreamListenSocket* connection,
+                         const char* data,
+                         int len) = 0;
+    virtual void DidClose(StreamListenSocket* sock) = 0;
+
+   protected:
+    virtual ~Delegate() {}
+  };
+
+  // Send data to the socket.
+  void Send(const char* bytes, int len, bool append_linefeed = false);
+  void Send(const std::string& str, bool append_linefeed = false);
+
+  // Copies the local address to |address|. Returns a network error code.
+  // This method is virtual to support unit testing.
+  virtual int GetLocalAddress(IPEndPoint* address) const;
+  // Copies the peer address to |address|. Returns a network error code.
+  // This method is virtual to support unit testing.
+  virtual int GetPeerAddress(IPEndPoint* address) const;
+
+  static const int kSocketError;
+
+ protected:
+  enum WaitState { NOT_WAITING = 0, WAITING_ACCEPT = 1, WAITING_READ = 2 };
+
+  StreamListenSocket(SocketDescriptor s, Delegate* del);
+
+  SocketDescriptor AcceptSocket();
+  virtual void Accept() = 0;
+
+  void Listen();
+  void Read();
+  void Close();
+  void CloseSocket();
+
+  // Pass any value in case of Windows, because in Windows
+  // we are not using state.
+  void WatchSocket(WaitState state);
+  void UnwatchSocket();
+
+  Delegate* const socket_delegate_;
+
+ private:
+  friend class TransportClientSocketTest;
+
+  void SendInternal(const char* bytes, int len);
+
+#if defined(OS_WIN)
+  // ObjectWatcher delegate.
+  void OnObjectSignaled(HANDLE object) override;
+  base::win::ObjectWatcher watcher_;
+  HANDLE socket_event_;
+#elif defined(OS_POSIX)
+  // Called by MessagePumpLibevent when the socket is ready to do I/O.
+  void OnFileCanReadWithoutBlocking(int fd) override;
+  void OnFileCanWriteWithoutBlocking(int fd) override;
+  WaitState wait_state_;
+  // The socket's libevent wrapper.
+  base::MessageLoopForIO::FileDescriptorWatcher watcher_;
+#endif
+
+  // NOTE: This is for unit test use only!
+  // Pause/Resume calling Read(). Note that ResumeReads() will also call
+  // Read() if there is anything to read.
+  void PauseReads();
+  void ResumeReads();
+
+  const SocketDescriptor socket_;
+  bool reads_paused_;
+  bool has_pending_reads_;
+
+  DISALLOW_COPY_AND_ASSIGN(StreamListenSocket);
+};
+
+// Abstract factory that must be subclassed for each subclass of
+// StreamListenSocket.
+class StreamListenSocketFactory {
+ public:
+  virtual ~StreamListenSocketFactory() {}
+
+  // Returns a new instance of StreamListenSocket or NULL if an error occurred.
+  virtual scoped_ptr<StreamListenSocket> CreateAndListen(
+      StreamListenSocket::Delegate* delegate) const = 0;
+};
+
+}  // namespace test_server
+
+}  // namespace net
+
+#endif  // NET_TEST_EMBEDDED_TEST_SERVER_STREAM_LISTEN_SOCKET_H_

chromium_src/net/test/embedded_test_server/tcp_listen_socket.cc

@@ -0,0 +1,118 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/test/embedded_test_server/tcp_listen_socket.h"
+
+#if defined(OS_WIN)
+// winsock2.h must be included first in order to ensure it is included before
+// windows.h.
+#include <winsock2.h>
+#elif defined(OS_POSIX)
+#include <arpa/inet.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include "net/base/net_errors.h"
+#endif
+
+#include "base/logging.h"
+#include "base/sys_byteorder.h"
+#include "base/threading/platform_thread.h"
+#include "build/build_config.h"
+#include "net/base/net_util.h"
+#include "net/base/winsock_init.h"
+#include "net/socket/socket_descriptor.h"
+
+using std::string;
+
+namespace net {
+
+namespace test_server {
+
+// static
+scoped_ptr<TCPListenSocket> TCPListenSocket::CreateAndListen(
+    const string& ip,
+    uint16 port,
+    StreamListenSocket::Delegate* del) {
+  SocketDescriptor s = CreateAndBind(ip, port);
+  if (s == kInvalidSocket)
+    return scoped_ptr<TCPListenSocket>();
+  scoped_ptr<TCPListenSocket> sock(new TCPListenSocket(s, del));
+  sock->Listen();
+  return sock.Pass();
+}
+
+TCPListenSocket::TCPListenSocket(SocketDescriptor s,
+                                 StreamListenSocket::Delegate* del)
+    : StreamListenSocket(s, del) {
+}
+
+TCPListenSocket::~TCPListenSocket() {
+}
+
+SocketDescriptor TCPListenSocket::CreateAndBind(const string& ip, uint16 port) {
+  SocketDescriptor s = CreatePlatformSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (s != kInvalidSocket) {
+#if defined(OS_POSIX)
+    // Allow rapid reuse.
+    static const int kOn = 1;
+    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &kOn, sizeof(kOn));
+#endif
+    sockaddr_in addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_addr.s_addr = inet_addr(ip.c_str());
+    addr.sin_port = base::HostToNet16(port);
+    if (bind(s, reinterpret_cast<sockaddr*>(&addr), sizeof(addr))) {
+#if defined(OS_WIN)
+      closesocket(s);
+#elif defined(OS_POSIX)
+      close(s);
+#endif
+      LOG(ERROR) << "Could not bind socket to " << ip << ":" << port;
+      s = kInvalidSocket;
+    }
+  }
+  return s;
+}
+
+SocketDescriptor TCPListenSocket::CreateAndBindAnyPort(const string& ip,
+                                                       uint16* port) {
+  SocketDescriptor s = CreateAndBind(ip, 0);
+  if (s == kInvalidSocket)
+    return kInvalidSocket;
+  sockaddr_in addr;
+  socklen_t addr_size = sizeof(addr);
+  bool failed = getsockname(s, reinterpret_cast<struct sockaddr*>(&addr),
+                            &addr_size) != 0;
+  if (addr_size != sizeof(addr))
+    failed = true;
+  if (failed) {
+    LOG(ERROR) << "Could not determine bound port, getsockname() failed";
+#if defined(OS_WIN)
+    closesocket(s);
+#elif defined(OS_POSIX)
+    close(s);
+#endif
+    return kInvalidSocket;
+  }
+  *port = base::NetToHost16(addr.sin_port);
+  return s;
+}
+
+void TCPListenSocket::Accept() {
+  SocketDescriptor conn = AcceptSocket();
+  if (conn == kInvalidSocket)
+    return;
+  scoped_ptr<TCPListenSocket> sock(new TCPListenSocket(conn, socket_delegate_));
+#if defined(OS_POSIX)
+  sock->WatchSocket(WAITING_READ);
+#endif
+  socket_delegate_->DidAccept(this, sock.Pass());
+}
+
+}  // namespace test_server
+
+}  // namespace net

chromium_src/net/test/embedded_test_server/tcp_listen_socket.h

@@ -0,0 +1,55 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef NET_TEST_EMBEDDED_TEST_SERVER_TCP_LISTEN_SOCKET_H_
+#define NET_TEST_EMBEDDED_TEST_SERVER_TCP_LISTEN_SOCKET_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "net/base/net_export.h"
+#include "net/socket/socket_descriptor.h"
+#include "net/test/embedded_test_server/stream_listen_socket.h"
+
+namespace net {
+
+namespace test_server {
+
+// Implements a TCP socket.
+class TCPListenSocket : public StreamListenSocket {
+ public:
+  ~TCPListenSocket() override;
+
+  // Listen on port for the specified IP address.  Use 127.0.0.1 to only
+  // accept local connections.
+  static scoped_ptr<TCPListenSocket> CreateAndListen(
+      const std::string& ip,
+      uint16 port,
+      StreamListenSocket::Delegate* del);
+
+ protected:
+  TCPListenSocket(SocketDescriptor s, StreamListenSocket::Delegate* del);
+
+  // Implements StreamListenSocket::Accept.
+  void Accept() override;
+
+ private:
+  friend class EmbeddedTestServer;
+  friend class TCPListenSocketTester;
+
+  // Get raw TCP socket descriptor bound to ip:port.
+  static SocketDescriptor CreateAndBind(const std::string& ip, uint16 port);
+
+  // Get raw TCP socket descriptor bound to ip and return port it is bound to.
+  static SocketDescriptor CreateAndBindAnyPort(const std::string& ip,
+                                               uint16* port);
+
+  DISALLOW_COPY_AND_ASSIGN(TCPListenSocket);
+};
+
+}  // namespace test_server
+
+}  // namespace net
+
+#endif  // NET_TEST_EMBEDDED_TEST_SERVER_TCP_LISTEN_SOCKET_H_

filenames.gypi

@@ -164,6 +164,8 @@
       'atom/browser/net/url_request_buffer_job.h',
       'atom/browser/net/url_request_fetch_job.cc',
       'atom/browser/net/url_request_fetch_job.h',
+      'atom/browser/node_debugger.cc',
+      'atom/browser/node_debugger.h',
       'atom/browser/ui/accelerator_util.cc',
       'atom/browser/ui/accelerator_util.h',
       'atom/browser/ui/accelerator_util_mac.mm',
@@ -410,6 +412,10 @@
       'chromium_src/chrome/utility/utility_message_handler.h',
       'chromium_src/library_loaders/libspeechd_loader.cc',
       'chromium_src/library_loaders/libspeechd.h',
+      'chromium_src/net/test/embedded_test_server/stream_listen_socket.cc',
+      'chromium_src/net/test/embedded_test_server/stream_listen_socket.h',
+      'chromium_src/net/test/embedded_test_server/tcp_listen_socket.cc',
+      'chromium_src/net/test/embedded_test_server/tcp_listen_socket.h',
       '<@(native_mate_files)',
       '<(SHARED_INTERMEDIATE_DIR)/atom_natives.h',
     ],

vendor/node

@@ -1 +1 @@
-Subproject commit b9b6dd9f3fc095e66a3b89d3efd50f7c576da2c8
+Subproject commit 8253eb68252639db471090edb059eaa4fea4ce46