Decouple DevTools from socket implementation.

content/browser/debugger/devtools_http_handler_impl.cc

 // 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 "content/browser/debugger/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 110 matching lines @@
 int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
   for (size_t i = 0; i < kDevtoolsResourcesSize; ++i) {
     if (name == kDevtoolsResources[i].name)
       return kDevtoolsResources[i].value;
   }
   return -1;
 }
 
 // static
 DevToolsHttpHandler* DevToolsHttpHandler::Start(
-    const std::string& ip,
-    int port,
     const std::string& frontend_url,
+    net::StreamListenSocketFactory* socket_factory,
     net::URLRequestContextGetter* request_context_getter,
     DevToolsHttpHandlerDelegate* delegate) {
   DevToolsHttpHandlerImpl* http_handler =
-      new DevToolsHttpHandlerImpl(ip,
-                                  port,
-                                  frontend_url,
+      new DevToolsHttpHandlerImpl(frontend_url,

[pfeldman, 2012/05/14 11:12:00]

socket_factory should probably go first (as it was before)

[Philippe, 2012/05/14 12:36:52]

I made it second to keep the mutable state last. frontend_url is now the only
immutable parameter.

[mmenke, 2012/05/14 20:45:19]

The factory doesn't look terribly mutable to me.

[Philippe, 2012/05/15 14:39:09]

In practice (in TCPListenSocketFactory::CreateAndListen()) it is not mutable
indeed although nothing prevents it from being since the CreateAndListen()
method is not marked as const. Making it const seemed to me unnecessarily
restrictive conceptually for a factory.
However since we know and own all the (immutable) implementations of the
interface, there is no reason not to prefer immutable implementation. I made it
immutable. If later for some unlikely reason we need to have a mutable factory
implementation, we can still make the change.

+                                  socket_factory,
                                   request_context_getter,
                                   delegate);
   http_handler->Start();
   return http_handler;
 }
 
 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
   // Stop() must be called prior to this being called
   DCHECK(server_.get() == NULL);
 }
@@ skipping 371 matching lines @@
 
 
   // See comments re: HEAD requests in OnResponseStarted().
   if (!request->status().is_io_pending()) {
     server_->Send(connection_id, "0\r\n\r\n");
     RequestCompleted(request);
   }
 }
 
 DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
-    const std::string& ip,
-    int port,
     const std::string& frontend_url,
+    net::StreamListenSocketFactory* socket_factory,
     net::URLRequestContextGetter* request_context_getter,
     DevToolsHttpHandlerDelegate* delegate)
-    : ip_(ip),
-      port_(port),
-      overridden_frontend_url_(frontend_url),
+    : overridden_frontend_url_(frontend_url),
+      socket_factory_(socket_factory),
       request_context_getter_(request_context_getter),
       delegate_(delegate) {
   if (overridden_frontend_url_.empty())
       overridden_frontend_url_ = "/devtools/devtools.html";
 
   default_binding_.reset(new DevToolsDefaultBindingHandler);
   binding_ = default_binding_.get();
 
   AddRef();
 }
 
 void DevToolsHttpHandlerImpl::Init() {
-  server_ = new net::HttpServer(ip_, port_, this);
+  server_ = new net::HttpServer(this, socket_factory_.get());
 }
 
 // Run on I/O thread
 void DevToolsHttpHandlerImpl::TeardownAndRelease() {
   server_ = NULL;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DevToolsHttpHandlerImpl::Release, this));
 }
 
@@ skipping 55 matching lines @@
 void DevToolsHttpHandlerImpl::AcceptWebSocket(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }
 
 }  // namespace content