Import the TCPListenSocket removed by Chromium

atom/browser/node_debugger.cc

@@ -12,7 +12,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/browser_thread.h"
-#include "net/socket/tcp_listen_socket.h"
+#include "net/test/embedded_test_server/tcp_listen_socket.h"
 
 #include "atom/common/node_includes.h"
 
@@ -84,7 +84,8 @@ bool NodeDebugger::IsRunning() const {
 }
 
 void NodeDebugger::StartServer(int port) {
-  server_ = net::TCPListenSocket::CreateAndListen("127.0.0.1", port, this);
+  server_ = net::test_server::TCPListenSocket::CreateAndListen(
+      "127.0.0.1", port, this);
   if (!server_) {
     LOG(ERROR) << "Cannot start debugger server";
     return;
@@ -143,8 +144,9 @@ void NodeDebugger::DebugMessageHandler(const v8::Debug::Message& message) {
   }
 }
 
-void NodeDebugger::DidAccept(net::StreamListenSocket* server,
+void NodeDebugger::DidAccept(
-                             scoped_ptr<net::StreamListenSocket> socket) {
+    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);
@@ -155,7 +157,7 @@ void NodeDebugger::DidAccept(net::StreamListenSocket* server,
   SendConnectMessage();
 }
 
-void NodeDebugger::DidRead(net::StreamListenSocket* socket,
+void NodeDebugger::DidRead(net::test_server::StreamListenSocket* socket,
                            const char* data,
                            int len) {
   buffer_.append(data, len);
@@ -194,7 +196,7 @@ void NodeDebugger::DidRead(net::StreamListenSocket* socket,
   } while (true);
 }
 
-void NodeDebugger::DidClose(net::StreamListenSocket* socket) {
+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\"}");
 }

atom/browser/node_debugger.h

@@ -10,13 +10,13 @@
 #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 "net/test/embedded_test_server/stream_listen_socket.h"
 #include "v8/include/v8-debug.h"
 
 namespace atom {
 
 // Add support for node's "--debug" switch.
-class NodeDebugger : public net::StreamListenSocket::Delegate {
+class NodeDebugger : public net::test_server::StreamListenSocket::Delegate {
  public:
   explicit NodeDebugger(v8::Isolate* isolate);
   virtual ~NodeDebugger();
@@ -32,19 +32,20 @@ class NodeDebugger : public net::StreamListenSocket::Delegate {
 
   static void DebugMessageHandler(const v8::Debug::Message& message);
 
-  // net::StreamListenSocket::Delegate:
+  // net::test_server::StreamListenSocket::Delegate:
-  void DidAccept(net::StreamListenSocket* server,
+  void DidAccept(
-                 scoped_ptr<net::StreamListenSocket> socket) override;
+      net::test_server::StreamListenSocket* server,
-  void DidRead(net::StreamListenSocket* socket,
+      scoped_ptr<net::test_server::StreamListenSocket> socket) override;
+  void DidRead(net::test_server::StreamListenSocket* socket,
                const char* data,
                int len) override;
-  void DidClose(net::StreamListenSocket* socket) override;
+  void DidClose(net::test_server::StreamListenSocket* socket) override;
 
   v8::Isolate* isolate_;
 
   base::Thread thread_;
-  scoped_ptr<net::StreamListenSocket> server_;
+  scoped_ptr<net::test_server::StreamListenSocket> server_;
-  scoped_ptr<net::StreamListenSocket> accepted_socket_;
+  scoped_ptr<net::test_server::StreamListenSocket> accepted_socket_;
 
   std::string buffer_;
   int content_length_;

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

@@ -412,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',
     ],