Start a TCP server in the debugger thread.

atom/browser/node_debugger.cc

@@ -10,8 +10,7 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
-#include "net/socket/stream_socket.h"
+#include "net/socket/tcp_listen_socket.h"
-#include "net/socket/tcp_server_socket.h"
 #include "v8/include/v8-debug.h"
 
 namespace atom {
@@ -39,23 +38,19 @@ NodeDebugger::NodeDebugger()
     if (!port_str.empty())
       base::StringToInt(port_str, &port);
 
-    if (!thread_.Start()) {
+    // 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;
     }
 
-    net::IPAddressNumber ip_number;
+    // Start the server in new IO thread.
-    if (!net::ParseIPLiteralToNumber("127.0.0.1", &ip_number)) {
-      LOG(ERROR) << "Unable to convert ip address";
-      return;
-    }
-
-    server_socket_.reset(new net::TCPServerSocket(NULL, net::NetLog::Source()));
-    server_socket_->Listen(net::IPEndPoint(ip_number, port), 1);
-
     thread_.message_loop()->PostTask(
         FROM_HERE,
-        base::Bind(&NodeDebugger::DoAcceptLoop, weak_factory_.GetWeakPtr()));
+        base::Bind(&NodeDebugger::StartServer, weak_factory_.GetWeakPtr(),
+                   port));
   }
 }
 
@@ -63,7 +58,30 @@ NodeDebugger::~NodeDebugger() {
   thread_.Stop();
 }
 
-void NodeDebugger::DoAcceptLoop() {
+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::DidAccept(net::StreamListenSocket* server,
+                             scoped_ptr<net::StreamListenSocket> socket) {
+  // Only accept one session.
+  if (accepted_socket_)
+    return;
+
+  accepted_socket_ = socket.Pass();
+}
+
+void NodeDebugger::DidRead(net::StreamListenSocket* socket,
+                           const char* data,
+                           int len) {
+}
+
+void NodeDebugger::DidClose(net::StreamListenSocket* socket) {
+  accepted_socket_.reset();
 }
 
 }  // namespace atom

atom/browser/node_debugger.h

@@ -8,26 +8,30 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread.h"
-
+#include "net/socket/stream_listen_socket.h"
-namespace net {
-class StreamSocket;
-class TCPServerSocket;
-}
 
 namespace atom {
 
 // Add support for node's "--debug" switch.
-class NodeDebugger {
+class NodeDebugger : public net::StreamListenSocket::Delegate {
  public:
   NodeDebugger();
   virtual ~NodeDebugger();
 
  private:
-  void DoAcceptLoop();
+  void StartServer(int port);
+
+  // 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;
 
   base::Thread thread_;
-  scoped_ptr<net::TCPServerSocket> server_socket_;
+  scoped_ptr<net::StreamListenSocket> server_;
-  scoped_ptr<net::StreamSocket> accepted_socket_;
+  scoped_ptr<net::StreamListenSocket> accepted_socket_;
 
   base::WeakPtrFactory<NodeDebugger> weak_factory_;