#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"
}
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;
}
}
-void NodeDebugger::DidAccept(net::StreamListenSocket* server,
- scoped_ptr<net::StreamListenSocket> socket) {
+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);
SendConnectMessage();
}
-void NodeDebugger::DidRead(net::StreamListenSocket* socket,
+void NodeDebugger::DidRead(net::test_server::StreamListenSocket* socket,
const char* data,
int len) {
buffer_.append(data, len);
} 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\"}");
}
#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();
static void DebugMessageHandler(const v8::Debug::Message& message);
- // net::StreamListenSocket::Delegate:
- void DidAccept(net::StreamListenSocket* server,
- scoped_ptr<net::StreamListenSocket> socket) override;
- void DidRead(net::StreamListenSocket* socket,
+ // 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::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::StreamListenSocket> accepted_socket_;
+ scoped_ptr<net::test_server::StreamListenSocket> server_;
+ scoped_ptr<net::test_server::StreamListenSocket> accepted_socket_;
std::string buffer_;
int content_length_;
--- /dev/null
+// 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
--- /dev/null
+// 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_
--- /dev/null
+// 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
--- /dev/null
+// 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_
'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',
],
projects / platform / framework / web / crosswalk-tizen.git / commitdiff