Revert of Replace StreamListenSocket with StreamSocket in HttpServer.

chrome/test/chromedriver/server/chromedriver_server.cc

 // Copyright (c) 2013 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 <stdio.h>
 #include <locale>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 15 matching lines @@
 #include "base/threading/thread_local.h"
 #include "chrome/test/chromedriver/logging.h"
 #include "chrome/test/chromedriver/net/port_server.h"
 #include "chrome/test/chromedriver/server/http_handler.h"
 #include "chrome/test/chromedriver/version.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #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 {
 
 const char* kLocalHostAddress = "127.0.0.1";
 
 typedef base::Callback<
     void(const net::HttpServerRequestInfo&, const HttpResponseSenderFunc&)>
     HttpRequestHandlerFunc;
 
 class HttpServer : public net::HttpServer::Delegate {
  public:
   explicit HttpServer(const HttpRequestHandlerFunc& handle_request_func)
       : handle_request_func_(handle_request_func),
         weak_factory_(this) {}
 
   virtual ~HttpServer() {}
 
   bool Start(int port, bool allow_remote) {
     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;
   }
 
   // Overridden from net::HttpServer::Delegate:
   virtual void OnHttpRequest(int connection_id,
                              const net::HttpServerRequestInfo& info) OVERRIDE {
     handle_request_func_.Run(
         info,
         base::Bind(&HttpServer::OnResponse,
@@ skipping 12 matching lines @@
                   scoped_ptr<net::HttpServerResponseInfo> response) {
     // Don't support keep-alive, since there's no way to detect if the
     // client is HTTP/1.0. In such cases, the client may hang waiting for
     // the connection to close (e.g., python 2.7 urllib).
     response->AddHeader("Connection", "close");
     server_->SendResponse(connection_id, *response);
     server_->Close(connection_id);
   }
 
   HttpRequestHandlerFunc handle_request_func_;
-  scoped_ptr<net::HttpServer> server_;
+  scoped_refptr<net::HttpServer> server_;
   base::WeakPtrFactory<HttpServer> weak_factory_;  // Should be last.
 };
 
 void SendResponseOnCmdThread(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const HttpResponseSenderFunc& send_response_on_io_func,
     scoped_ptr<net::HttpServerResponseInfo> response) {
   io_task_runner->PostTask(
       FROM_HERE, base::Bind(send_response_on_io_func, base::Passed(&response)));
 }
@@ skipping 197 matching lines @@
   }
 
   if (!InitLogging()) {
     printf("Unable to initialize logging. Exiting...\n");
     return 1;
   }
   RunServer(port, allow_remote, whitelisted_ips,
             url_base, adb_port, port_server.Pass());
   return 0;
 }