diff --git a/atom/browser/node_debugger.cc b/atom/browser/node_debugger.cc index 4e2302763c7e..beaf682a8d4b 100644 --- a/atom/browser/node_debugger.cc +++ b/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, - scoped_ptr socket) { +void NodeDebugger::DidAccept( + net::test_server::StreamListenSocket* server, + scoped_ptr 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\"}"); } diff --git a/atom/browser/node_debugger.h b/atom/browser/node_debugger.h index 6ee5b1e20688..bf77cb72da64 100644 --- a/atom/browser/node_debugger.h +++ b/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: - void DidAccept(net::StreamListenSocket* server, - scoped_ptr socket) override; - void DidRead(net::StreamListenSocket* socket, + // net::test_server::StreamListenSocket::Delegate: + void DidAccept( + net::test_server::StreamListenSocket* server, + scoped_ptr 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 server_; - scoped_ptr accepted_socket_; + scoped_ptr server_; + scoped_ptr accepted_socket_; std::string buffer_; int content_length_; diff --git a/chromium_src/net/test/embedded_test_server/stream_listen_socket.cc b/chromium_src/net/test/embedded_test_server/stream_listen_socket.cc new file mode 100644 index 000000000000..1056983a8e2f --- /dev/null +++ b/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 +#elif defined(OS_POSIX) +#include +#include +#include +#include +#include +#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(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(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 diff --git a/chromium_src/net/test/embedded_test_server/stream_listen_socket.h b/chromium_src/net/test/embedded_test_server/stream_listen_socket.h new file mode 100644 index 000000000000..02a8b9827a2e --- /dev/null +++ b/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 +#endif +#include +#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 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 CreateAndListen( + StreamListenSocket::Delegate* delegate) const = 0; +}; + +} // namespace test_server + +} // namespace net + +#endif // NET_TEST_EMBEDDED_TEST_SERVER_STREAM_LISTEN_SOCKET_H_ diff --git a/chromium_src/net/test/embedded_test_server/tcp_listen_socket.cc b/chromium_src/net/test/embedded_test_server/tcp_listen_socket.cc new file mode 100644 index 000000000000..418f34592127 --- /dev/null +++ b/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 +#elif defined(OS_POSIX) +#include +#include +#include +#include +#include +#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::CreateAndListen( + const string& ip, + uint16 port, + StreamListenSocket::Delegate* del) { + SocketDescriptor s = CreateAndBind(ip, port); + if (s == kInvalidSocket) + return scoped_ptr(); + scoped_ptr 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(&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(&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 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 diff --git a/chromium_src/net/test/embedded_test_server/tcp_listen_socket.h b/chromium_src/net/test/embedded_test_server/tcp_listen_socket.h new file mode 100644 index 000000000000..12b3fa40745e --- /dev/null +++ b/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 + +#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 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_ diff --git a/filenames.gypi b/filenames.gypi index b4015921e809..feb35789afe1 100644 --- a/filenames.gypi +++ b/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', ],