Revert of Replace StreamListenSocket with StreamSocket in HttpServer....

Revert of Replace StreamListenSocket with StreamSocket in HttpServer. (patchset #29 of https://codereview.chromium.org/296053012/)

Reason for revert:
looks like it caused net_unittests failures: http://build.chromium.org/p/chromium.win/builders/Vista%20Tests%20(2)/builds/44610/steps/net_unittests/logs/MultipleRequestsOnSameConnection

Original issue's description:
> Replace StreamListenSocket with StreamSocket in HttpServer.
>     
> 1) HttpServer gets ServerSocket instead of StreamListenSocket.
> 2) HttpConnection is just a container for socket, websocket, and pending read/write buffers.
> 3) HttpServer handles data buffering and asynchronous read/write.
> 4) HttpConnection has limit in data buffering, up to 1Mbytes by default.
> 5) For devtools, send buffer limit is 100Mbytes.
> 6) Unittests for buffer handling in HttpConnection.
>     
> BUG=371906
> 
> Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=291447

NOTREECHECKS=true
NOTRY=true
TBR=rsleevi@chromium.org

Review URL: https://codereview.chromium.org/497223003

Cr-Commit-Position: refs/heads/master@{#291521}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@291521 0039d316-1c4b-4281-b951-d872f2087c98

android_webview/native/aw_dev_tools_server.cc

@@ -19,7 +19,7 @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/user_agent.h"
 #include "jni/AwDevToolsServer_jni.h"
-#include "net/socket/unix_domain_server_socket_posix.h"
+#include "net/socket/unix_domain_listen_socket_posix.h"
 
 using content::DevToolsAgentHost;
 using content::RenderViewHost;
@@ -157,25 +157,6 @@ std::string GetViewDescription(WebContents* web_contents) {
   return json;
 }
 
-// Factory for UnixDomainServerSocket.
-class UnixDomainServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  explicit UnixDomainServerSocketFactory(const std::string& socket_name)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::UnixDomainServerSocket(
-            base::Bind(&content::CanUserConnectToDevTools),
-            true /* use_abstract_namespace */));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
-};
-
 }  // namespace
 
 namespace android_webview {
@@ -192,11 +173,11 @@ void AwDevToolsServer::Start() {
   if (protocol_handler_)
     return;
 
-  scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory> factory(
-      new UnixDomainServerSocketFactory(
-          base::StringPrintf(kSocketNameFormat, getpid())));
   protocol_handler_ = content::DevToolsHttpHandler::Start(
-      factory.Pass(),
+      new net::deprecated::UnixDomainListenSocketWithAbstractNamespaceFactory(
+          base::StringPrintf(kSocketNameFormat, getpid()),
+          "",
+          base::Bind(&content::CanUserConnectToDevTools)),
       base::StringPrintf(kFrontEndURL, content::GetWebKitRevision().c_str()),
       new AwDevToolsServerDelegate(),
       base::FilePath());

chrome/browser/android/dev_tools_server.cc

@@ -40,9 +40,7 @@
 #include "content/public/common/user_agent.h"
 #include "grit/browser_resources.h"
 #include "jni/DevToolsServer_jni.h"
-#include "net/base/net_errors.h"
 #include "net/socket/unix_domain_listen_socket_posix.h"
-#include "net/socket/unix_domain_server_socket_posix.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
 
@@ -395,49 +393,6 @@ class DevToolsServerDelegate : public content::DevToolsHttpHandlerDelegate {
   DISALLOW_COPY_AND_ASSIGN(DevToolsServerDelegate);
 };
 
-// Factory for UnixDomainServerSocket. It tries a fallback socket when
-// original socket doesn't work.
-class UnixDomainServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  UnixDomainServerSocketFactory(
-      const std::string& socket_name,
-      const net::UnixDomainServerSocket::AuthCallback& auth_callback)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1),
-        auth_callback_(auth_callback) {
-  }
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::UnixDomainServerSocket(auth_callback_,
-                                        true /* use_abstract_namespace */));
-  }
-
-  virtual scoped_ptr<net::ServerSocket> CreateAndListen() const OVERRIDE {
-    scoped_ptr<net::ServerSocket> socket = Create();
-    if (!socket)
-      return scoped_ptr<net::ServerSocket>();
-
-    if (socket->ListenWithAddressAndPort(address_, port_, backlog_) == net::OK)
-      return socket.Pass();
-
-    // Try a fallback socket name.
-    const std::string fallback_address(
-        base::StringPrintf("%s_%d", address_.c_str(), getpid()));
-    if (socket->ListenWithAddressAndPort(fallback_address, port_, backlog_)
-        == net::OK)
-      return socket.Pass();
-
-    return scoped_ptr<net::ServerSocket>();
-  }
-
-  const net::UnixDomainServerSocket::AuthCallback auth_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
-};
-
 }  // namespace
 
 DevToolsServer::DevToolsServer(const std::string& socket_name_prefix)
@@ -464,10 +419,12 @@ void DevToolsServer::Start(bool allow_debug_permission) {
       allow_debug_permission ?
           base::Bind(&AuthorizeSocketAccessWithDebugPermission) :
           base::Bind(&content::CanUserConnectToDevTools);
-  scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory> factory(
-      new UnixDomainServerSocketFactory(socket_name_, auth_callback));
+
   protocol_handler_ = content::DevToolsHttpHandler::Start(
-      factory.Pass(),
+      new net::deprecated::UnixDomainListenSocketWithAbstractNamespaceFactory(
+          socket_name_,
+          base::StringPrintf("%s_%d", socket_name_.c_str(), getpid()),
+          auth_callback),
       base::StringPrintf(kFrontEndURL, content::GetWebKitRevision().c_str()),
       new DevToolsServerDelegate(auth_callback),
       base::FilePath());

chrome/browser/devtools/device/android_web_socket.cc

@@ -199,7 +199,8 @@ void WebSocketImpl::OnBytesRead(scoped_refptr<net::IOBuffer> response_buffer,
     return;
   }
 
-  response_buffer_.append(response_buffer->data(), result);
+  std::string data = std::string(response_buffer->data(), result);
+  response_buffer_ += data;
 
   int bytes_consumed;
   std::string output;

chrome/browser/devtools/remote_debugging_server.cc

@@ -9,28 +9,7 @@
 #include "chrome/browser/ui/webui/devtools_ui.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/devtools_http_handler.h"
-#include "net/socket/tcp_server_socket.h"
-
-namespace {
-
-class TCPServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  TCPServerSocketFactory(const std::string& address, int port, int backlog)
-      : content::DevToolsHttpHandler::ServerSocketFactory(
-            address, port, backlog) {}
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
-};
-
-}  // namespace
+#include "net/socket/tcp_listen_socket.h"
 
 RemoteDebuggingServer::RemoteDebuggingServer(
     chrome::HostDesktopType host_desktop_type,
@@ -45,10 +24,8 @@ RemoteDebuggingServer::RemoteDebuggingServer(
     DCHECK(result);
   }
 
-  scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory> factory(
-      new TCPServerSocketFactory(ip, port, 1));
   devtools_http_handler_ = content::DevToolsHttpHandler::Start(
-      factory.Pass(),
+      new net::TCPListenSocketFactory(ip, port),
       "",
       new BrowserListTabContentsProvider(host_desktop_type),
       output_dir);

chrome/test/chromedriver/net/net_util_unittest.cc

@@ -20,7 +20,7 @@
 #include "net/base/net_errors.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -54,10 +54,8 @@ class FetchUrlTest : public testing::Test,
   }
 
   void InitOnIO(base::WaitableEvent* event) {
-    scoped_ptr<net::ServerSocket> server_socket(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
-    server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
-    server_.reset(new net::HttpServer(server_socket.Pass(), this));
+    net::TCPListenSocketFactory factory("127.0.0.1", 0);
+    server_ = new net::HttpServer(factory, this);
     net::IPEndPoint address;
     CHECK_EQ(net::OK, server_->GetLocalAddress(&address));
     server_url_ = base::StringPrintf("http://127.0.0.1:%d", address.port());
@@ -65,7 +63,7 @@ class FetchUrlTest : public testing::Test,
   }
 
   void DestroyServerOnIO(base::WaitableEvent* event) {
-    server_.reset(NULL);
+    server_ = NULL;
     event->Signal();
   }
 
@@ -80,7 +78,10 @@ class FetchUrlTest : public testing::Test,
         server_->Send404(connection_id);
         break;
       case kClose:
-        server_->Close(connection_id);
+        // net::HttpServer doesn't allow us to close connection during callback.
+        base::MessageLoop::current()->PostTask(
+            FROM_HERE,
+            base::Bind(&net::HttpServer::Close, server_, connection_id));
         break;
       default:
         break;
@@ -103,7 +104,7 @@ class FetchUrlTest : public testing::Test,
 
   base::Thread io_thread_;
   ServerResponse response_;
-  scoped_ptr<net::HttpServer> server_;
+  scoped_refptr<net::HttpServer> server_;
   scoped_refptr<URLRequestContextGetter> context_getter_;
   std::string server_url_;
 };

chrome/test/chromedriver/net/test_http_server.cc

@@ -13,7 +13,7 @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/server/http_server_request_info.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 TestHttpServer::TestHttpServer()
@@ -92,7 +92,10 @@ void TestHttpServer::OnWebSocketRequest(
       server_->Send404(connection_id);
       break;
     case kClose:
-      server_->Close(connection_id);
+      // net::HttpServer doesn't allow us to close connection during callback.
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&net::HttpServer::Close, server_, connection_id));
       break;
   }
 }
@@ -109,7 +112,10 @@ void TestHttpServer::OnWebSocketMessage(int connection_id,
       server_->SendOverWebSocket(connection_id, data);
       break;
     case kCloseOnMessage:
-      server_->Close(connection_id);
+      // net::HttpServer doesn't allow us to close connection during callback.
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(&net::HttpServer::Close, server_, connection_id));
       break;
   }
 }
@@ -122,10 +128,8 @@ void TestHttpServer::OnClose(int connection_id) {
 
 void TestHttpServer::StartOnServerThread(bool* success,
                                          base::WaitableEvent* event) {
-  scoped_ptr<net::ServerSocket> server_socket(
-      new net::TCPServerSocket(NULL, net::NetLog::Source()));
-  server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
-  server_.reset(new net::HttpServer(server_socket.Pass(), this));
+  net::TCPListenSocketFactory factory("127.0.0.1", 0);
+  server_ = new net::HttpServer(factory, this);
 
   net::IPEndPoint address;
   int error = server_->GetLocalAddress(&address);
@@ -135,13 +139,14 @@ void TestHttpServer::StartOnServerThread(bool* success,
     web_socket_url_ = GURL(base::StringPrintf("ws://127.0.0.1:%d",
                                               address.port()));
   } else {
-    server_.reset(NULL);
+    server_ = NULL;
   }
   *success = server_.get();
   event->Signal();
 }
 
 void TestHttpServer::StopOnServerThread(base::WaitableEvent* event) {
-  server_.reset(NULL);
+  if (server_.get())
+    server_ = NULL;
   event->Signal();
 }

chrome/test/chromedriver/net/test_http_server.h

@@ -77,7 +77,7 @@ class TestHttpServer : public net::HttpServer::Delegate {
   base::Thread thread_;
 
   // Access only on the server thread.
-  scoped_ptr<net::HttpServer> server_;
+  scoped_refptr<net::HttpServer> server_;
 
   // Access only on the server thread.
   std::set<int> connections_;

chrome/test/chromedriver/server/chromedriver_server.cc

@@ -33,7 +33,7 @@
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 
 namespace {
 
@@ -55,10 +55,8 @@ class HttpServer : public net::HttpServer::Delegate {
     std::string binding_ip = kLocalHostAddress;
     if (allow_remote)
       binding_ip = "0.0.0.0";
-    scoped_ptr<net::ServerSocket> server_socket(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
-    server_socket->ListenWithAddressAndPort(binding_ip, port, 1);
-    server_.reset(new net::HttpServer(server_socket.Pass(), this));
+    server_ = new net::HttpServer(
+        net::TCPListenSocketFactory(binding_ip, port), this);
     net::IPEndPoint address;
     return server_->GetLocalAddress(&address) == net::OK;
   }
@@ -91,7 +89,7 @@ class HttpServer : public net::HttpServer::Delegate {
   }
 
   HttpRequestHandlerFunc handle_request_func_;
-  scoped_ptr<net::HttpServer> server_;
+  scoped_refptr<net::HttpServer> server_;
   base::WeakPtrFactory<HttpServer> weak_factory_;  // Should be last.
 };
 

chromecast/shell/browser/devtools/remote_debugging_server.cc

@@ -17,11 +17,11 @@
 #include "content/public/browser/devtools_http_handler.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/user_agent.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 
 #if defined(OS_ANDROID)
 #include "content/public/browser/android/devtools_auth.h"
-#include "net/socket/unix_domain_server_socket_posix.h"
+#include "net/socket/unix_domain_socket_posix.h"
 #endif  // defined(OS_ANDROID)
 
 namespace chromecast {
@@ -35,45 +35,7 @@ const char kFrontEndURL[] =
 #endif  // defined(OS_ANDROID)
 const int kDefaultRemoteDebuggingPort = 9222;
 
-#if defined(OS_ANDROID)
-class UnixDomainServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  explicit UnixDomainServerSocketFactory(const std::string& socket_name)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::UnixDomainServerSocket(
-            base::Bind(&content::CanUserConnectToDevTools),
-            true /* use_abstract_namespace */));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
-};
-#else
-class TCPServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  TCPServerSocketFactory(const std::string& address, int port, int backlog)
-      : content::DevToolsHttpHandler::ServerSocketFactory(
-            address, port, backlog) {}
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
-};
-#endif
-
-scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>
-CreateSocketFactory(int port) {
+net::StreamListenSocketFactory* CreateSocketFactory(int port) {
 #if defined(OS_ANDROID)
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   std::string socket_name = "content_shell_devtools_remote";
@@ -81,12 +43,11 @@ CreateSocketFactory(int port) {
     socket_name = command_line->GetSwitchValueASCII(
         switches::kRemoteDebuggingSocketName);
   }
-  return scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>(
-      new UnixDomainServerSocketFactory(socket_name));
+  return new net::UnixDomainSocketWithAbstractNamespaceFactory(
+      socket_name, "", base::Bind(&content::CanUserConnectToDevTools));
 #else
-  return scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>(
-      new TCPServerSocketFactory("0.0.0.0", port, 1));
-#endif
+  return new net::TCPListenSocketFactory("0.0.0.0", port);
+#endif  // defined(OS_ANDROID)
 }
 
 std::string GetFrontendUrl() {

cloud_print/gcp20/prototype/privet_http_server.cc

@@ -10,7 +10,7 @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 #include "url/gurl.h"
 
 namespace {
@@ -105,12 +105,10 @@ bool PrivetHttpServer::Start(uint16 port) {
   if (server_)
     return true;
 
-  scoped_ptr<net::ServerSocket> server_socket(
-      new net::TCPServerSocket(NULL, net::NetLog::Source()));
-  server_socket->ListenWithAddressAndPort("0.0.0.0", port, 1);
-  server_.reset(new net::HttpServer(server_socket.Pass(), this));
-
+  net::TCPListenSocketFactory factory("0.0.0.0", port);
+  server_ = new net::HttpServer(factory, this);
   net::IPEndPoint address;
+
   if (server_->GetLocalAddress(&address) != net::OK) {
     NOTREACHED() << "Cannot start HTTP server";
     return false;
@@ -124,7 +122,7 @@ void PrivetHttpServer::Shutdown() {
   if (!server_)
     return;
 
-  server_.reset(NULL);
+  server_ = NULL;
 }
 
 void PrivetHttpServer::OnHttpRequest(int connection_id,

cloud_print/gcp20/prototype/privet_http_server.h

@@ -204,7 +204,7 @@ class PrivetHttpServer: public net::HttpServer::Delegate {
   uint16 port_;
 
   // Contains encapsulated object for listening for requests.
-  scoped_ptr<net::HttpServer> server_;
+  scoped_refptr<net::HttpServer> server_;
 
   Delegate* delegate_;
 
@@ -212,3 +212,4 @@ class PrivetHttpServer: public net::HttpServer::Delegate {
 };
 
 #endif  // CLOUD_PRINT_GCP20_PROTOTYPE_PRIVET_HTTP_SERVER_H_
+

content/browser/devtools/devtools_browser_target.cc

@@ -17,8 +17,9 @@
 
 namespace content {
 
-DevToolsBrowserTarget::DevToolsBrowserTarget(net::HttpServer* http_server,
-                                             int connection_id)
+DevToolsBrowserTarget::DevToolsBrowserTarget(
+    net::HttpServer* http_server,
+    int connection_id)
     : message_loop_proxy_(base::MessageLoopProxy::current()),
       http_server_(http_server),
       connection_id_(connection_id),

content/browser/devtools/devtools_http_handler_impl.cc

@@ -39,7 +39,6 @@
 #include "net/base/net_errors.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
-#include "net/socket/server_socket.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
@@ -68,9 +67,6 @@ const char kTargetFaviconUrlField[] = "faviconUrl";
 const char kTargetWebSocketDebuggerUrlField[] = "webSocketDebuggerUrl";
 const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
 
-// Maximum write buffer size of devtools http/websocket connectinos.
-const int32 kSendBufferSizeForDevTools = 100 * 1024 * 1024;  // 100Mb
-
 // An internal implementation of DevToolsAgentHostClient that delegates
 // messages sent to a DebuggerShell instance.
 class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
@@ -108,15 +104,13 @@ class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
-                   base::Unretained(server_),
+                   server_,
                    connection_id_,
                    response));
 
     message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&net::HttpServer::Close,
-                   base::Unretained(server_),
-                   connection_id_));
+        base::Bind(&net::HttpServer::Close, server_, connection_id_));
   }
 
   virtual void DispatchProtocolMessage(
@@ -125,7 +119,7 @@ class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&net::HttpServer::SendOverWebSocket,
-                   base::Unretained(server_),
+                   server_,
                    connection_id_,
                    message));
   }
@@ -136,9 +130,9 @@ class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
   }
 
  private:
-  base::MessageLoop* const message_loop_;
-  net::HttpServer* const server_;
-  const int connection_id_;
+  base::MessageLoop* message_loop_;
+  net::HttpServer* server_;
+  int connection_id_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
@@ -166,12 +160,12 @@ int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
 
 // static
 DevToolsHttpHandler* DevToolsHttpHandler::Start(
-    scoped_ptr<ServerSocketFactory> server_socket_factory,
+    const net::StreamListenSocketFactory* socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate,
     const base::FilePath& active_port_output_directory) {
   DevToolsHttpHandlerImpl* http_handler =
-      new DevToolsHttpHandlerImpl(server_socket_factory.Pass(),
+      new DevToolsHttpHandlerImpl(socket_factory,
                                   frontend_url,
                                   delegate,
                                   active_port_output_directory);
@@ -179,28 +173,6 @@ DevToolsHttpHandler* DevToolsHttpHandler::Start(
   return http_handler;
 }
 
-DevToolsHttpHandler::ServerSocketFactory::ServerSocketFactory(
-    const std::string& address,
-    int port,
-    int backlog)
-    : address_(address),
-      port_(port),
-      backlog_(backlog) {
-}
-
-DevToolsHttpHandler::ServerSocketFactory::~ServerSocketFactory() {
-}
-
-scoped_ptr<net::ServerSocket>
-DevToolsHttpHandler::ServerSocketFactory::CreateAndListen() const {
-  scoped_ptr<net::ServerSocket> socket = Create();
-  if (socket &&
-      socket->ListenWithAddressAndPort(address_, port_, backlog_) == net::OK) {
-    return socket.Pass();
-  }
-  return scoped_ptr<net::ServerSocket>();
-}
-
 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Stop() must be called prior to destruction.
@@ -290,8 +262,6 @@ static std::string GetMimeType(const std::string& filename) {
 void DevToolsHttpHandlerImpl::OnHttpRequest(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
-  server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
-
   if (info.path.find("/json") == 0) {
     BrowserThread::PostTask(
         BrowserThread::UI,
@@ -381,7 +351,6 @@ void DevToolsHttpHandlerImpl::OnWebSocketRequest(
         true /* handle on UI thread */);
     browser_targets_[connection_id] = browser_target;
 
-    server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
     server_->AcceptWebSocket(connection_id, request);
     return;
   }
@@ -682,16 +651,16 @@ void DevToolsHttpHandlerImpl::OnCloseUI(int connection_id) {
 }
 
 DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
-    scoped_ptr<ServerSocketFactory> server_socket_factory,
+    const net::StreamListenSocketFactory* socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate,
     const base::FilePath& active_port_output_directory)
     : frontend_url_(frontend_url),
-      server_socket_factory_(server_socket_factory.Pass()),
+      socket_factory_(socket_factory),
       delegate_(delegate),
       active_port_output_directory_(active_port_output_directory) {
   if (frontend_url_.empty())
-    frontend_url_ = "/devtools/devtools.html";
+      frontend_url_ = "/devtools/devtools.html";
 
   // Balanced in ResetHandlerThreadAndRelease().
   AddRef();
@@ -699,15 +668,14 @@ DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
 
 // Runs on the handler thread
 void DevToolsHttpHandlerImpl::Init() {
-  server_.reset(new net::HttpServer(server_socket_factory_->CreateAndListen(),
-                                    this));
+  server_ = new net::HttpServer(*socket_factory_.get(), this);
   if (!active_port_output_directory_.empty())
     WriteActivePortToUserProfile();
 }
 
 // Runs on the handler thread
 void DevToolsHttpHandlerImpl::Teardown() {
-  server_.reset(NULL);
+  server_ = NULL;
 }
 
 // Runs on FILE thread to make sure that it is serialized against
@@ -765,7 +733,7 @@ void DevToolsHttpHandlerImpl::SendJson(int connection_id,
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::SendResponse,
-                 base::Unretained(server_.get()),
+                 server_.get(),
                  connection_id,
                  response));
 }
@@ -778,7 +746,7 @@ void DevToolsHttpHandlerImpl::Send200(int connection_id,
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::Send200,
-                 base::Unretained(server_.get()),
+                 server_.get(),
                  connection_id,
                  data,
                  mime_type));
@@ -789,9 +757,7 @@ void DevToolsHttpHandlerImpl::Send404(int connection_id) {
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::Send404,
-                 base::Unretained(server_.get()),
-                 connection_id));
+      base::Bind(&net::HttpServer::Send404, server_.get(), connection_id));
 }
 
 void DevToolsHttpHandlerImpl::Send500(int connection_id,
@@ -800,9 +766,7 @@ void DevToolsHttpHandlerImpl::Send500(int connection_id,
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::Send500,
-                 base::Unretained(server_.get()),
-                 connection_id,
+      base::Bind(&net::HttpServer::Send500, server_.get(), connection_id,
                  message));
 }
 
@@ -813,16 +777,8 @@ void DevToolsHttpHandlerImpl::AcceptWebSocket(
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&net::HttpServer::SetSendBufferSize,
-                 base::Unretained(server_.get()),
-                 connection_id,
-                 kSendBufferSizeForDevTools));
-  thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&net::HttpServer::AcceptWebSocket,
-                 base::Unretained(server_.get()),
-                 connection_id,
-                 request));
+      base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
+                 connection_id, request));
 }
 
 base::DictionaryValue* DevToolsHttpHandlerImpl::SerializeTarget(

content/browser/devtools/devtools_http_handler_impl.h

@@ -27,7 +27,7 @@ class Value;
 }
 
 namespace net {
-class ServerSocketFactory;
+class StreamListenSocketFactory;
 class URLRequestContextGetter;
 }
 
@@ -43,7 +43,8 @@ class DevToolsHttpHandlerImpl
   friend class base::RefCountedThreadSafe<DevToolsHttpHandlerImpl>;
   friend class DevToolsHttpHandler;
 
-  DevToolsHttpHandlerImpl(scoped_ptr<ServerSocketFactory> server_socket_factory,
+  // Takes ownership over |socket_factory|.
+  DevToolsHttpHandlerImpl(const net::StreamListenSocketFactory* socket_factory,
                           const std::string& frontend_url,
                           DevToolsHttpHandlerDelegate* delegate,
                           const base::FilePath& active_port_output_directory);
@@ -116,12 +117,12 @@ class DevToolsHttpHandlerImpl
   scoped_ptr<base::Thread> thread_;
 
   std::string frontend_url_;
-  const scoped_ptr<ServerSocketFactory> server_socket_factory_;
-  scoped_ptr<net::HttpServer> server_;
+  scoped_ptr<const net::StreamListenSocketFactory> socket_factory_;
+  scoped_refptr<net::HttpServer> server_;
   typedef std::map<int, DevToolsAgentHostClient*> ConnectionToClientMap;
   ConnectionToClientMap connection_to_client_ui_;
-  const scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
-  const base::FilePath active_port_output_directory_;
+  scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
+  base::FilePath active_port_output_directory_;
   typedef std::map<std::string, DevToolsTarget*> TargetMap;
   TargetMap target_map_;
   typedef std::map<int, scoped_refptr<DevToolsBrowserTarget> > BrowserTargets;

content/browser/devtools/devtools_http_handler_unittest.cc

@@ -13,7 +13,7 @@
 #include "content/public/browser/devtools_target.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
-#include "net/socket/server_socket.h"
+#include "net/socket/stream_listen_socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -23,55 +23,49 @@ const int kDummyPort = 4321;
 const base::FilePath::CharType kDevToolsActivePortFileName[] =
     FILE_PATH_LITERAL("DevToolsActivePort");
 
-class DummyServerSocket : public net::ServerSocket {
- public:
-  DummyServerSocket() {}
-
-  // net::ServerSocket "implementation"
-  virtual int Listen(const net::IPEndPoint& address, int backlog) OVERRIDE {
-    return net::OK;
-  }
-
-  virtual int ListenWithAddressAndPort(const std::string& ip_address,
-                                       int port,
-                                       int backlog) OVERRIDE {
-    return net::OK;
-  }
+using net::StreamListenSocket;
 
-  virtual int GetLocalAddress(net::IPEndPoint* address) const OVERRIDE {
+class DummyListenSocket : public StreamListenSocket,
+                          public StreamListenSocket::Delegate {
+ public:
+  DummyListenSocket()
+      : StreamListenSocket(net::kInvalidSocket, this) {}
+
+  // StreamListenSocket::Delegate "implementation"
+  virtual void DidAccept(StreamListenSocket* server,
+                         scoped_ptr<StreamListenSocket> connection) OVERRIDE {}
+  virtual void DidRead(StreamListenSocket* connection,
+                       const char* data,
+                       int len) OVERRIDE {}
+  virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
+ protected:
+  virtual ~DummyListenSocket() {}
+  virtual void Accept() OVERRIDE {}
+  virtual int GetLocalAddress(net::IPEndPoint* address) OVERRIDE {
     net::IPAddressNumber number;
     EXPECT_TRUE(net::ParseIPLiteralToNumber("127.0.0.1", &number));
     *address = net::IPEndPoint(number, kDummyPort);
     return net::OK;
   }
-
-  virtual int Accept(scoped_ptr<net::StreamSocket>* socket,
-                     const net::CompletionCallback& callback) OVERRIDE {
-    return net::ERR_IO_PENDING;
-  }
 };
 
-class DummyServerSocketFactory
-    : public DevToolsHttpHandler::ServerSocketFactory {
+class DummyListenSocketFactory : public net::StreamListenSocketFactory {
  public:
-  DummyServerSocketFactory(base::Closure quit_closure_1,
-                           base::Closure quit_closure_2)
-      : DevToolsHttpHandler::ServerSocketFactory("", 0, 0),
-        quit_closure_1_(quit_closure_1),
-        quit_closure_2_(quit_closure_2) {}
-
-  virtual ~DummyServerSocketFactory() {
+  DummyListenSocketFactory(
+      base::Closure quit_closure_1, base::Closure quit_closure_2)
+      : quit_closure_1_(quit_closure_1), quit_closure_2_(quit_closure_2) {}
+  virtual ~DummyListenSocketFactory() {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, quit_closure_2_);
   }
 
- private:
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
+  virtual scoped_ptr<StreamListenSocket> CreateAndListen(
+      StreamListenSocket::Delegate* delegate) const OVERRIDE {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, quit_closure_1_);
-    return scoped_ptr<net::ServerSocket>(new DummyServerSocket());
+    return scoped_ptr<net::StreamListenSocket>(new DummyListenSocket());
   }
-
+ private:
   base::Closure quit_closure_1_;
   base::Closure quit_closure_2_;
 };
@@ -79,28 +73,22 @@ class DummyServerSocketFactory
 class DummyDelegate : public DevToolsHttpHandlerDelegate {
  public:
   virtual std::string GetDiscoveryPageHTML() OVERRIDE { return std::string(); }
-
   virtual bool BundlesFrontendResources() OVERRIDE { return true; }
-
   virtual base::FilePath GetDebugFrontendDir() OVERRIDE {
     return base::FilePath();
   }
-
   virtual std::string GetPageThumbnailData(const GURL& url) OVERRIDE {
     return std::string();
   }
-
   virtual scoped_ptr<DevToolsTarget> CreateNewTarget(const GURL& url) OVERRIDE {
     return scoped_ptr<DevToolsTarget>();
   }
-
   virtual void EnumerateTargets(TargetCallback callback) OVERRIDE {
     callback.Run(TargetList());
   }
-
   virtual scoped_ptr<net::StreamListenSocket> CreateSocketForTethering(
-      net::StreamListenSocket::Delegate* delegate,
-      std::string* name) OVERRIDE {
+    net::StreamListenSocket::Delegate* delegate,
+    std::string* name) OVERRIDE {
     return scoped_ptr<net::StreamListenSocket>();
   }
 };
@@ -112,17 +100,14 @@ class DevToolsHttpHandlerTest : public testing::Test {
   DevToolsHttpHandlerTest()
       : ui_thread_(BrowserThread::UI, &message_loop_) {
   }
-
  protected:
   virtual void SetUp() {
     file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE));
     file_thread_->Start();
   }
-
   virtual void TearDown() {
     file_thread_->Stop();
   }
-
  private:
   base::MessageLoopForIO message_loop_;
   BrowserThreadImpl ui_thread_;
@@ -131,14 +116,13 @@ class DevToolsHttpHandlerTest : public testing::Test {
 
 TEST_F(DevToolsHttpHandlerTest, TestStartStop) {
   base::RunLoop run_loop, run_loop_2;
-  scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
-      new DummyServerSocketFactory(run_loop.QuitClosure(),
-                                   run_loop_2.QuitClosure()));
   content::DevToolsHttpHandler* devtools_http_handler_ =
-      content::DevToolsHttpHandler::Start(factory.Pass(),
-                                          std::string(),
-                                          new DummyDelegate(),
-                                          base::FilePath());
+      content::DevToolsHttpHandler::Start(
+          new DummyListenSocketFactory(run_loop.QuitClosure(),
+                                       run_loop_2.QuitClosure()),
+          std::string(),
+          new DummyDelegate(),
+          base::FilePath());
   // Our dummy socket factory will post a quit message once the server will
   // become ready.
   run_loop.Run();
@@ -151,14 +135,13 @@ TEST_F(DevToolsHttpHandlerTest, TestDevToolsActivePort) {
   base::RunLoop run_loop, run_loop_2;
   base::ScopedTempDir temp_dir;
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
-  scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
-      new DummyServerSocketFactory(run_loop.QuitClosure(),
-                                   run_loop_2.QuitClosure()));
   content::DevToolsHttpHandler* devtools_http_handler_ =
-      content::DevToolsHttpHandler::Start(factory.Pass(),
-                                          std::string(),
-                                          new DummyDelegate(),
-                                          temp_dir.path());
+      content::DevToolsHttpHandler::Start(
+          new DummyListenSocketFactory(run_loop.QuitClosure(),
+                                       run_loop_2.QuitClosure()),
+          std::string(),
+          new DummyDelegate(),
+          temp_dir.path());
   // Our dummy socket factory will post a quit message once the server will
   // become ready.
   run_loop.Run();

content/public/browser/devtools_http_handler.h

@@ -8,13 +8,12 @@
 #include <string>
 
 #include "base/files/file_path.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/common/content_export.h"
 
 class GURL;
 
 namespace net {
-class ServerSocket;
+class StreamListenSocketFactory;
 class URLRequestContextGetter;
 }
 
@@ -27,32 +26,6 @@ class DevToolsHttpHandlerDelegate;
 // this browser.
 class DevToolsHttpHandler {
  public:
-
-  // Factory of net::ServerSocket. This is to separate instantiating dev tools
-  // and instantiating server socket.
-  class CONTENT_EXPORT ServerSocketFactory {
-   public:
-    ServerSocketFactory(const std::string& address, int port, int backlog);
-    virtual ~ServerSocketFactory();
-
-    // Returns a new instance of ServerSocket or NULL if an error occurred.
-    // It calls ServerSocket::ListenWithAddressAndPort() with address, port and
-    // backlog passed to constructor.
-    virtual scoped_ptr<net::ServerSocket> CreateAndListen() const;
-
-   protected:
-    // Creates a server socket. ServerSocket::Listen() will be called soon
-    // unless it returns NULL.
-    virtual scoped_ptr<net::ServerSocket> Create() const = 0;
-
-    const std::string address_;
-    const int port_;
-    const int backlog_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ServerSocketFactory);
-  };
-
   // Returns true if the given protocol version is supported.
   CONTENT_EXPORT static bool IsSupportedProtocolVersion(
       const std::string& version);
@@ -67,7 +40,7 @@ class DevToolsHttpHandler {
   // port selected by the OS will be written to a well-known file in
   // the output directory.
   CONTENT_EXPORT static DevToolsHttpHandler* Start(
-      scoped_ptr<ServerSocketFactory> server_socket_factory,
+      const net::StreamListenSocketFactory* socket_factory,
       const std::string& frontend_url,
       DevToolsHttpHandlerDelegate* delegate,
       const base::FilePath& active_port_output_directory);

content/shell/browser/shell_devtools_delegate.cc

@@ -24,12 +24,12 @@
 #include "content/public/common/user_agent.h"
 #include "content/shell/browser/shell.h"
 #include "grit/shell_resources.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if defined(OS_ANDROID)
 #include "content/public/browser/android/devtools_auth.h"
-#include "net/socket/unix_domain_server_socket_posix.h"
+#include "net/socket/unix_domain_listen_socket_posix.h"
 #endif
 
 using content::DevToolsAgentHost;
@@ -44,45 +44,7 @@ const char kFrontEndURL[] =
 #endif
 const char kTargetTypePage[] = "page";
 
-#if defined(OS_ANDROID)
-class UnixDomainServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  explicit UnixDomainServerSocketFactory(const std::string& socket_name)
-      : content::DevToolsHttpHandler::ServerSocketFactory(socket_name, 0, 1) {}
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::UnixDomainServerSocket(
-            base::Bind(&content::CanUserConnectToDevTools),
-            true /* use_abstract_namespace */));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
-};
-#else
-class TCPServerSocketFactory
-    : public content::DevToolsHttpHandler::ServerSocketFactory {
- public:
-  TCPServerSocketFactory(const std::string& address, int port, int backlog)
-      : content::DevToolsHttpHandler::ServerSocketFactory(
-            address, port, backlog) {}
-
- private:
-  // content::DevToolsHttpHandler::ServerSocketFactory.
-  virtual scoped_ptr<net::ServerSocket> Create() const OVERRIDE {
-    return scoped_ptr<net::ServerSocket>(
-        new net::TCPServerSocket(NULL, net::NetLog::Source()));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
-};
-#endif
-
-scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>
-CreateSocketFactory() {
+net::StreamListenSocketFactory* CreateSocketFactory() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 #if defined(OS_ANDROID)
   std::string socket_name = "content_shell_devtools_remote";
@@ -90,8 +52,9 @@ CreateSocketFactory() {
     socket_name = command_line.GetSwitchValueASCII(
         switches::kRemoteDebuggingSocketName);
   }
-  return scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>(
-      new UnixDomainServerSocketFactory(socket_name));
+  return new net::deprecated::
+      UnixDomainListenSocketWithAbstractNamespaceFactory(
+          socket_name, "", base::Bind(&content::CanUserConnectToDevTools));
 #else
   // See if the user specified a port on the command line (useful for
   // automation). If not, use an ephemeral port by specifying 0.
@@ -107,8 +70,7 @@ CreateSocketFactory() {
       DLOG(WARNING) << "Invalid http debugger port number " << temp_port;
     }
   }
-  return scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory>(
-      new TCPServerSocketFactory("127.0.0.1", port, 1));
+  return new net::TCPListenSocketFactory("127.0.0.1", port);
 #endif
 }
 

extensions/browser/api/socket/tcp_socket.cc

@@ -201,7 +201,6 @@ int TCPSocket::Listen(const std::string& address,
   if (!server_socket_.get()) {
     server_socket_.reset(new net::TCPServerSocket(NULL, net::NetLog::Source()));
   }
-
   int result = server_socket_->ListenWithAddressAndPort(address, port, backlog);
   if (result)
     *error_msg = kSocketListenError;

mojo/spy/websocket_server.cc

@@ -14,7 +14,7 @@
 #include "net/base/net_errors.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 #include "url/gurl.h"
 
 namespace mojo {
@@ -42,10 +42,8 @@ WebSocketServer::~WebSocketServer() {
 }
 
 bool WebSocketServer::Start() {
-  scoped_ptr<net::ServerSocket> server_socket(
-      new net::TCPServerSocket(NULL, net::NetLog::Source()));
-  server_socket->ListenWithAddressAndPort("0.0.0.0", port_, 1);
-  web_server_.reset(new net::HttpServer(server_socket.Pass(), this));
+  net::TCPListenSocketFactory factory("0.0.0.0", port_);
+  web_server_ = new net::HttpServer(factory, this);
   net::IPEndPoint address;
   int error = web_server_->GetLocalAddress(&address);
   port_ = address.port();
@@ -93,7 +91,9 @@ void WebSocketServer::OnWebSocketRequest(
     const net::HttpServerRequestInfo& info) {
   if (connection_id_ != kNotConnected) {
     // Reject connection since we already have our client.
-    web_server_->Close(connection_id);
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&net::HttpServer::Close, web_server_, connection_id));
     return;
   }
   // Accept the connection.
@@ -157,3 +157,4 @@ bool WebSocketServer::Connected() const {
 }
 
 }  // namespace mojo
+

mojo/spy/websocket_server.h

@@ -66,7 +66,7 @@ class WebSocketServer : public net::HttpServer::Delegate,
  private:
   int port_;
   int connection_id_;
-  scoped_ptr<net::HttpServer> web_server_;
+  scoped_refptr<net::HttpServer> web_server_;
   spy_api::SpyServerPtr spy_server_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketServer);

net/net.gypi

@@ -1555,7 +1555,6 @@
       'quic/quic_utils_test.cc',
       'quic/quic_write_blocked_list_test.cc',
       'quic/reliable_quic_stream_test.cc',
-      'server/http_connection_unittest.cc',
       'server/http_server_response_info_unittest.cc',
       'server/http_server_unittest.cc',
       'socket/client_socket_pool_base_unittest.cc',

net/server/http_connection.cc

@@ -4,163 +4,44 @@
 
 #include "net/server/http_connection.h"
 
-#include "base/logging.h"
+#include "net/server/http_server.h"
+#include "net/server/http_server_response_info.h"
 #include "net/server/web_socket.h"
-#include "net/socket/stream_socket.h"
+#include "net/socket/stream_listen_socket.h"
 
 namespace net {
 
-HttpConnection::ReadIOBuffer::ReadIOBuffer()
-    : base_(new GrowableIOBuffer()),
-      max_buffer_size_(kDefaultMaxBufferSize) {
-  SetCapacity(kInitialBufSize);
-}
-
-HttpConnection::ReadIOBuffer::~ReadIOBuffer() {
-  data_ = NULL;  // base_ owns data_.
-}
-
-int HttpConnection::ReadIOBuffer::GetCapacity() const {
-  return base_->capacity();
-}
-
-void HttpConnection::ReadIOBuffer::SetCapacity(int capacity) {
-  DCHECK_LE(GetSize(), capacity);
-  base_->SetCapacity(capacity);
-  data_ = base_->data();
-}
-
-bool HttpConnection::ReadIOBuffer::IncreaseCapacity() {
-  if (GetCapacity() >= max_buffer_size_) {
-    LOG(ERROR) << "Too large read data is pending: capacity=" << GetCapacity()
-               << ", max_buffer_size=" << max_buffer_size_
-               << ", read=" << GetSize();
-    return false;
-  }
-
-  int new_capacity = GetCapacity() * kCapacityIncreaseFactor;
-  if (new_capacity > max_buffer_size_)
-    new_capacity = max_buffer_size_;
-  SetCapacity(new_capacity);
-  return true;
-}
-
-char* HttpConnection::ReadIOBuffer::StartOfBuffer() const {
-  return base_->StartOfBuffer();
-}
-
-int HttpConnection::ReadIOBuffer::GetSize() const {
-  return base_->offset();
-}
-
-void HttpConnection::ReadIOBuffer::DidRead(int bytes) {
-  DCHECK_GE(RemainingCapacity(), bytes);
-  base_->set_offset(base_->offset() + bytes);
-  data_ = base_->data();
-}
+int HttpConnection::last_id_ = 0;
 
-int HttpConnection::ReadIOBuffer::RemainingCapacity() const {
-  return base_->RemainingCapacity();
-}
-
-void HttpConnection::ReadIOBuffer::DidConsume(int bytes) {
-  int previous_size = GetSize();
-  int unconsumed_size = previous_size - bytes;
-  DCHECK_LE(0, unconsumed_size);
-  if (unconsumed_size > 0) {
-    // Move unconsumed data to the start of buffer.
-    memmove(StartOfBuffer(), StartOfBuffer() + bytes, unconsumed_size);
-  }
-  base_->set_offset(unconsumed_size);
-  data_ = base_->data();
-
-  // If capacity is too big, reduce it.
-  if (GetCapacity() > kMinimumBufSize &&
-      GetCapacity() > previous_size * kCapacityIncreaseFactor) {
-    int new_capacity = GetCapacity() / kCapacityIncreaseFactor;
-    if (new_capacity < kMinimumBufSize)
-      new_capacity = kMinimumBufSize;
-    // realloc() within GrowableIOBuffer::SetCapacity() could move data even
-    // when size is reduced. If unconsumed_size == 0, i.e. no data exists in
-    // the buffer, free internal buffer first to guarantee no data move.
-    if (!unconsumed_size)
-      base_->SetCapacity(0);
-    SetCapacity(new_capacity);
-  }
-}
-
-HttpConnection::QueuedWriteIOBuffer::QueuedWriteIOBuffer()
-    : total_size_(0),
-      max_buffer_size_(kDefaultMaxBufferSize) {
-}
-
-HttpConnection::QueuedWriteIOBuffer::~QueuedWriteIOBuffer() {
-  data_ = NULL;  // pending_data_ owns data_.
-}
-
-bool HttpConnection::QueuedWriteIOBuffer::IsEmpty() const {
-  return pending_data_.empty();
-}
-
-bool HttpConnection::QueuedWriteIOBuffer::Append(const std::string& data) {
-  if (data.empty())
-    return true;
-
-  if (total_size_ + static_cast<int>(data.size()) > max_buffer_size_) {
-    LOG(ERROR) << "Too large write data is pending: size="
-               << total_size_ + data.size()
-               << ", max_buffer_size=" << max_buffer_size_;
-    return false;
-  }
-
-  pending_data_.push(data);
-  total_size_ += data.size();
-
-  // If new data is the first pending data, updates data_.
-  if (pending_data_.size() == 1)
-    data_ = const_cast<char*>(pending_data_.front().data());
-  return true;
+void HttpConnection::Send(const std::string& data) {
+  if (!socket_.get())
+    return;
+  socket_->Send(data);
 }
 
-void HttpConnection::QueuedWriteIOBuffer::DidConsume(int size) {
-  DCHECK_GE(total_size_, size);
-  DCHECK_GE(GetSizeToWrite(), size);
-  if (size == 0)
+void HttpConnection::Send(const char* bytes, int len) {
+  if (!socket_.get())
     return;
-
-  if (size < GetSizeToWrite()) {
-    data_ += size;
-  } else {  // size == GetSizeToWrite(). Updates data_ to next pending data.
-    pending_data_.pop();
-    data_ = IsEmpty() ? NULL : const_cast<char*>(pending_data_.front().data());
-  }
-  total_size_ -= size;
+  socket_->Send(bytes, len);
 }
 
-int HttpConnection::QueuedWriteIOBuffer::GetSizeToWrite() const {
-  if (IsEmpty()) {
-    DCHECK_EQ(0, total_size_);
-    return 0;
-  }
-  DCHECK_GE(data_, pending_data_.front().data());
-  int consumed = static_cast<int>(data_ - pending_data_.front().data());
-  DCHECK_GT(static_cast<int>(pending_data_.front().size()), consumed);
-  return pending_data_.front().size() - consumed;
+void HttpConnection::Send(const HttpServerResponseInfo& response) {
+  Send(response.Serialize());
 }
 
-HttpConnection::HttpConnection(int id, scoped_ptr<StreamSocket> socket)
-    : id_(id),
-      socket_(socket.Pass()),
-      read_buf_(new ReadIOBuffer()),
-      write_buf_(new QueuedWriteIOBuffer()) {
+HttpConnection::HttpConnection(HttpServer* server,
+                               scoped_ptr<StreamListenSocket> sock)
+    : server_(server),
+      socket_(sock.Pass()) {
+  id_ = last_id_++;
 }
 
 HttpConnection::~HttpConnection() {
+  server_->delegate_->OnClose(id_);
 }
 
-void HttpConnection::SetWebSocket(scoped_ptr<WebSocket> web_socket) {
-  DCHECK(!web_socket_);
-  web_socket_ = web_socket.Pass();
+void HttpConnection::Shift(int num_bytes) {
+  recv_data_ = recv_data_.substr(num_bytes);
 }
 
 }  // namespace net

net/server/http_connection.h

@@ -5,130 +5,43 @@
 #ifndef NET_SERVER_HTTP_CONNECTION_H_
 #define NET_SERVER_HTTP_CONNECTION_H_
 
-#include <queue>
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "net/base/io_buffer.h"
+#include "net/http/http_status_code.h"
 
 namespace net {
 
-class StreamSocket;
+class HttpServer;
+class HttpServerResponseInfo;
+class StreamListenSocket;
 class WebSocket;
 
-// A container which has all information of an http connection. It includes
-// id, underlying socket, and pending read/write data.
 class HttpConnection {
  public:
-  // IOBuffer for data read.  It's a wrapper around GrowableIOBuffer, with more
-  // functions for buffer management.  It moves unconsumed data to the start of
-  // buffer.
-  class ReadIOBuffer : public IOBuffer {
-   public:
-    static const int kInitialBufSize = 1024;
-    static const int kMinimumBufSize = 128;
-    static const int kCapacityIncreaseFactor = 2;
-    static const int kDefaultMaxBufferSize = 1 * 1024 * 1024;  // 1 Mbytes.
-
-    ReadIOBuffer();
-
-    // Capacity.
-    int GetCapacity() const;
-    void SetCapacity(int capacity);
-    // Increases capacity and returns true if capacity is not beyond the limit.
-    bool IncreaseCapacity();
-
-    // Start of read data.
-    char* StartOfBuffer() const;
-    // Returns the bytes of read data.
-    int GetSize() const;
-    // More read data was appended.
-    void DidRead(int bytes);
-    // Capacity for which more read data can be appended.
-    int RemainingCapacity() const;
-
-    // Removes consumed data and moves unconsumed data to the start of buffer.
-    void DidConsume(int bytes);
-
-    // Limit of how much internal capacity can increase.
-    int max_buffer_size() const { return max_buffer_size_; }
-    void set_max_buffer_size(int max_buffer_size) {
-      max_buffer_size_ = max_buffer_size;
-    }
-
-   private:
-    virtual ~ReadIOBuffer();
-
-    scoped_refptr<GrowableIOBuffer> base_;
-    int max_buffer_size_;
-
-    DISALLOW_COPY_AND_ASSIGN(ReadIOBuffer);
-  };
-
-  // IOBuffer of pending data to write which has a queue of pending data. Each
-  // pending data is stored in std::string.  data() is the data of first
-  // std::string stored.
-  class QueuedWriteIOBuffer : public IOBuffer {
-   public:
-    static const int kDefaultMaxBufferSize = 1 * 1024 * 1024;  // 1 Mbytes.
-
-    QueuedWriteIOBuffer();
-
-    // Whether or not pending data exists.
-    bool IsEmpty() const;
-
-    // Appends new pending data and returns true if total size doesn't exceed
-    // the limit, |total_size_limit_|.  It would change data() if new data is
-    // the first pending data.
-    bool Append(const std::string& data);
-
-    // Consumes data and changes data() accordingly.  It cannot be more than
-    // GetSizeToWrite().
-    void DidConsume(int size);
-
-    // Gets size of data to write this time. It is NOT total data size.
-    int GetSizeToWrite() const;
-
-    // Total size of all pending data.
-    int total_size() const { return total_size_; }
-
-    // Limit of how much data can be pending.
-    int max_buffer_size() const { return max_buffer_size_; }
-    void set_max_buffer_size(int max_buffer_size) {
-      max_buffer_size_ = max_buffer_size;
-    }
-
-   private:
-    virtual ~QueuedWriteIOBuffer();
-
-    std::queue<std::string> pending_data_;
-    int total_size_;
-    int max_buffer_size_;
+  ~HttpConnection();
 
-    DISALLOW_COPY_AND_ASSIGN(QueuedWriteIOBuffer);
-  };
+  void Send(const std::string& data);
+  void Send(const char* bytes, int len);
+  void Send(const HttpServerResponseInfo& response);
 
-  HttpConnection(int id, scoped_ptr<StreamSocket> socket);
-  ~HttpConnection();
+  void Shift(int num_bytes);
 
+  const std::string& recv_data() const { return recv_data_; }
   int id() const { return id_; }
-  StreamSocket* socket() const { return socket_.get(); }
-  ReadIOBuffer* read_buf() const { return read_buf_.get(); }
-  QueuedWriteIOBuffer* write_buf() const { return write_buf_.get(); }
-
-  WebSocket* web_socket() const { return web_socket_.get(); }
-  void SetWebSocket(scoped_ptr<WebSocket> web_socket);
 
  private:
-  const int id_;
-  const scoped_ptr<StreamSocket> socket_;
-  const scoped_refptr<ReadIOBuffer> read_buf_;
-  const scoped_refptr<QueuedWriteIOBuffer> write_buf_;
+  friend class HttpServer;
+  static int last_id_;
 
-  scoped_ptr<WebSocket> web_socket_;
+  HttpConnection(HttpServer* server, scoped_ptr<StreamListenSocket> sock);
 
+  HttpServer* server_;
+  scoped_ptr<StreamListenSocket> socket_;
+  scoped_ptr<WebSocket> web_socket_;
+  std::string recv_data_;
+  int id_;
   DISALLOW_COPY_AND_ASSIGN(HttpConnection);
 };
 

net/server/http_server.h

@@ -5,14 +5,13 @@
 #ifndef NET_SERVER_HTTP_SERVER_H_
 #define NET_SERVER_HTTP_SERVER_H_
 
+#include <list>
 #include <map>
-#include <string>
 
 #include "base/basictypes.h"
-#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "net/http/http_status_code.h"
+#include "net/socket/stream_listen_socket.h"
 
 namespace net {
 
@@ -20,28 +19,30 @@ class HttpConnection;
 class HttpServerRequestInfo;
 class HttpServerResponseInfo;
 class IPEndPoint;
-class ServerSocket;
-class StreamSocket;
 class WebSocket;
 
-class HttpServer {
+class HttpServer : public StreamListenSocket::Delegate,
+                   public base::RefCountedThreadSafe<HttpServer> {
  public:
-  // Delegate to handle http/websocket events. Beware that it is not safe to
-  // destroy the HttpServer in any of these callbacks.
   class Delegate {
    public:
     virtual void OnHttpRequest(int connection_id,
                                const HttpServerRequestInfo& info) = 0;
+
     virtual void OnWebSocketRequest(int connection_id,
                                     const HttpServerRequestInfo& info) = 0;
+
     virtual void OnWebSocketMessage(int connection_id,
                                     const std::string& data) = 0;
+
     virtual void OnClose(int connection_id) = 0;
+
+   protected:
+    virtual ~Delegate() {}
   };
 
-  HttpServer(scoped_ptr<ServerSocket> server_socket,
+  HttpServer(const StreamListenSocketFactory& socket_factory,
              HttpServer::Delegate* delegate);
-  ~HttpServer();
 
   void AcceptWebSocket(int connection_id,
                        const HttpServerRequestInfo& request);
@@ -50,7 +51,6 @@ class HttpServer {
   // performed that data constitutes a valid HTTP response. A valid HTTP
   // response may be split across multiple calls to SendRaw.
   void SendRaw(int connection_id, const std::string& data);
-  // TODO(byungchul): Consider replacing function name with SendResponseInfo
   void SendResponse(int connection_id, const HttpServerResponseInfo& response);
   void Send(int connection_id,
             HttpStatusCode status_code,
@@ -64,50 +64,40 @@ class HttpServer {
 
   void Close(int connection_id);
 
-  void SetReceiveBufferSize(int connection_id, int32 size);
-  void SetSendBufferSize(int connection_id, int32 size);
-
   // Copies the local address to |address|. Returns a network error code.
   int GetLocalAddress(IPEndPoint* address);
 
- private:
-  friend class HttpServerTest;
-
-  typedef std::map<int, HttpConnection*> IdToConnectionMap;
-
-  void DoAcceptLoop();
-  void OnAcceptCompleted(int rv);
-  int HandleAcceptResult(int rv);
+  // ListenSocketDelegate
+  virtual void DidAccept(StreamListenSocket* server,
+                         scoped_ptr<StreamListenSocket> socket) OVERRIDE;
+  virtual void DidRead(StreamListenSocket* socket,
+                       const char* data,
+                       int len) OVERRIDE;
+  virtual void DidClose(StreamListenSocket* socket) OVERRIDE;
 
-  void DoReadLoop(HttpConnection* connection);
-  void OnReadCompleted(int connection_id, int rv);
-  int HandleReadResult(HttpConnection* connection, int rv);
+ protected:
+  virtual ~HttpServer();
 
-  void DoWriteLoop(HttpConnection* connection);
-  void OnWriteCompleted(int connection_id, int rv);
-  int HandleWriteResult(HttpConnection* connection, int rv);
+ private:
+  friend class base::RefCountedThreadSafe<HttpServer>;
+  friend class HttpConnection;
 
   // Expects the raw data to be stored in recv_data_. If parsing is successful,
   // will remove the data parsed from recv_data_, leaving only the unused
   // recv data.
-  bool ParseHeaders(const char* data,
-                    size_t data_len,
+  bool ParseHeaders(HttpConnection* connection,
                     HttpServerRequestInfo* info,
                     size_t* pos);
 
   HttpConnection* FindConnection(int connection_id);
+  HttpConnection* FindConnection(StreamListenSocket* socket);
 
-  // Whether or not Close() has been called during delegate callback processing.
-  bool HasClosedConnection(HttpConnection* connection);
-
-  const scoped_ptr<ServerSocket> server_socket_;
-  scoped_ptr<StreamSocket> accepted_socket_;
-  HttpServer::Delegate* const delegate_;
-
-  int last_id_;
+  HttpServer::Delegate* delegate_;
+  scoped_ptr<StreamListenSocket> server_;
+  typedef std::map<int, HttpConnection*> IdToConnectionMap;
   IdToConnectionMap id_to_connection_;
-
-  base::WeakPtrFactory<HttpServer> weak_ptr_factory_;
+  typedef std::map<StreamListenSocket*, HttpConnection*> SocketToConnectionMap;
+  SocketToConnectionMap socket_to_connection_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServer);
 };

net/server/http_server_response_info.cc

@@ -41,14 +41,8 @@ void HttpServerResponseInfo::SetBody(const std::string& body,
                                      const std::string& content_type) {
   DCHECK(body_.empty());
   body_ = body;
-  SetContentHeaders(body.length(), content_type);
-}
-
-void HttpServerResponseInfo::SetContentHeaders(
-    size_t content_length,
-    const std::string& content_type) {
   AddHeader(HttpRequestHeaders::kContentLength,
-            base::StringPrintf("%" PRIuS, content_length));
+            base::StringPrintf("%" PRIuS, body.length()));
   AddHeader(HttpRequestHeaders::kContentType, content_type);
 }
 

net/server/http_server_response_info.h

@@ -27,9 +27,6 @@ class HttpServerResponseInfo {
 
   // This also adds an appropriate Content-Length header.
   void SetBody(const std::string& body, const std::string& content_type);
-  // Sets content-length and content-type. Body should be sent separately.
-  void SetContentHeaders(size_t content_length,
-                         const std::string& content_type);
 
   std::string Serialize() const;
 

net/server/http_server_unittest.cc

@@ -2,13 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/memory/ref_counted.h"
@@ -26,12 +24,11 @@
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
-#include "net/base/net_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/socket/tcp_client_socket.h"
-#include "net/socket/tcp_server_socket.h"
+#include "net/socket/tcp_listen_socket.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
@@ -158,10 +155,8 @@ class HttpServerTest : public testing::Test,
   HttpServerTest() : quit_after_request_count_(0) {}
 
   virtual void SetUp() OVERRIDE {
-    scoped_ptr<ServerSocket> server_socket(
-        new TCPServerSocket(NULL, net::NetLog::Source()));
-    server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
-    server_.reset(new HttpServer(server_socket.Pass(), this));
+    TCPListenSocketFactory socket_factory("127.0.0.1", 0);
+    server_ = new HttpServer(socket_factory, this);
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
@@ -204,13 +199,8 @@ class HttpServerTest : public testing::Test,
     return requests_[request_index].second;
   }
 
-  void HandleAcceptResult(scoped_ptr<StreamSocket> socket) {
-    server_->accepted_socket_.reset(socket.release());
-    server_->HandleAcceptResult(OK);
-  }
-
  protected:
-  scoped_ptr<HttpServer> server_;
+  scoped_refptr<HttpServer> server_;
   IPEndPoint server_address_;
   base::Closure run_loop_quit_func_;
   std::vector<std::pair<HttpServerRequestInfo, int> > requests_;
@@ -439,105 +429,23 @@ TEST_F(HttpServerTest, SendRaw) {
 
 namespace {
 
-class MockStreamSocket : public StreamSocket {
+class MockStreamListenSocket : public StreamListenSocket {
  public:
-  MockStreamSocket()
-      : connected_(true),
-        read_buf_(NULL),
-        read_buf_len_(0) {}
-
-  // StreamSocket
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
-    return ERR_NOT_IMPLEMENTED;
-  }
-  virtual void Disconnect() OVERRIDE {
-    connected_ = false;
-    if (!read_callback_.is_null()) {
-      read_buf_ = NULL;
-      read_buf_len_ = 0;
-      base::ResetAndReturn(&read_callback_).Run(ERR_CONNECTION_CLOSED);
-    }
-  }
-  virtual bool IsConnected() const OVERRIDE { return connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return IsConnected(); }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
-    return ERR_NOT_IMPLEMENTED;
-  }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
-    return ERR_NOT_IMPLEMENTED;
-  }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return true; }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
-    return kProtoUnknown;
-  }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  MockStreamListenSocket(StreamListenSocket::Delegate* delegate)
+      : StreamListenSocket(kInvalidSocket, delegate) {}
 
-  // Socket
-  virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
-    if (!connected_) {
-      return ERR_SOCKET_NOT_CONNECTED;
-    }
-    if (pending_read_data_.empty()) {
-      read_buf_ = buf;
-      read_buf_len_ = buf_len;
-      read_callback_ = callback;
-      return ERR_IO_PENDING;
-    }
-    DCHECK_GT(buf_len, 0);
-    int read_len = std::min(static_cast<int>(pending_read_data_.size()),
-                            buf_len);
-    memcpy(buf->data(), pending_read_data_.data(), read_len);
-    pending_read_data_.erase(0, read_len);
-    return read_len;
-  }
-  virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
-    return ERR_NOT_IMPLEMENTED;
-  }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
-    return ERR_NOT_IMPLEMENTED;
-  }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE {
-    return ERR_NOT_IMPLEMENTED;
-  }
-
-  void DidRead(const char* data, int data_len) {
-    if (!read_buf_) {
-      pending_read_data_.append(data, data_len);
-      return;
-    }
-    int read_len = std::min(data_len, read_buf_len_);
-    memcpy(read_buf_->data(), data, read_len);
-    pending_read_data_.assign(data + read_len, data_len - read_len);
-    read_buf_ = NULL;
-    read_buf_len_ = 0;
-    base::ResetAndReturn(&read_callback_).Run(read_len);
-  }
+  virtual void Accept() OVERRIDE { NOTREACHED(); }
 
  private:
-  virtual ~MockStreamSocket() {}
-
-  bool connected_;
-  scoped_refptr<IOBuffer> read_buf_;
-  int read_buf_len_;
-  CompletionCallback read_callback_;
-  std::string pending_read_data_;
-  BoundNetLog net_log_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockStreamSocket);
+  virtual ~MockStreamListenSocket() {}
 };
 
 }  // namespace
 
 TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
-  MockStreamSocket* socket = new MockStreamSocket();
-  HandleAcceptResult(make_scoped_ptr<StreamSocket>(socket));
+  StreamListenSocket* socket =
+      new MockStreamListenSocket(server_.get());
+  server_->DidAccept(NULL, make_scoped_ptr(socket));
   std::string body("body");
   std::string request_text = base::StringPrintf(
       "GET /test HTTP/1.1\r\n"
@@ -545,9 +453,9 @@ TEST_F(HttpServerTest, RequestWithBodySplitAcrossPackets) {
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str());
-  socket->DidRead(request_text.c_str(), request_text.length() - 2);
+  server_->DidRead(socket, request_text.c_str(), request_text.length() - 2);
   ASSERT_EQ(0u, requests_.size());
-  socket->DidRead(request_text.c_str() + request_text.length() - 2, 2);
+  server_->DidRead(socket, request_text.c_str() + request_text.length() - 2, 2);
   ASSERT_EQ(1u, requests_.size());
   ASSERT_EQ(body, GetRequest(0).data);
 }

net/server/web_socket.h

@@ -8,12 +8,10 @@
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/strings/string_piece.h"
 
 namespace net {
 
 class HttpConnection;
-class HttpServer;
 class HttpServerRequestInfo;
 
 class WebSocket {
@@ -25,12 +23,11 @@ class WebSocket {
     FRAME_ERROR
   };
 
-  static WebSocket* CreateWebSocket(HttpServer* server,
-                                    HttpConnection* connection,
+  static WebSocket* CreateWebSocket(HttpConnection* connection,
                                     const HttpServerRequestInfo& request,
                                     size_t* pos);
 
-  static ParseResult DecodeFrameHybi17(const base::StringPiece& frame,
+  static ParseResult DecodeFrameHybi17(const std::string& frame,
                                        bool client_frame,
                                        int* bytes_consumed,
                                        std::string* output);
@@ -44,10 +41,8 @@ class WebSocket {
   virtual ~WebSocket() {}
 
  protected:
-  WebSocket(HttpServer* server, HttpConnection* connection);
-
-  HttpServer* const server_;
-  HttpConnection* const connection_;
+  explicit WebSocket(HttpConnection* connection);
+  HttpConnection* connection_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebSocket);

net/socket/server_socket.h

@@ -21,7 +21,7 @@ class NET_EXPORT ServerSocket {
   ServerSocket();
   virtual ~ServerSocket();
 
-  // Binds the socket and starts listening. Destroys the socket to stop
+  // Binds the socket and starts listening. Destroy the socket to stop
   // listening.
   virtual int Listen(const IPEndPoint& address, int backlog) = 0;