Decouple DevTools from socket implementation.

net/server/http_server.h

 // 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_SERVER_HTTP_SERVER_H_
 #define NET_SERVER_HTTP_SERVER_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 21 matching lines @@
 
     virtual void OnWebSocketMessage(int connection_id,
                                     const std::string& data) = 0;
 
     virtual void OnClose(int connection_id) = 0;
 
    protected:
     virtual ~Delegate() {}
   };
 
-  HttpServer(const std::string& host, int port, HttpServer::Delegate* del);
+  // Note that the constructed HttpServer instance does not take ownership of
+  // the provided socket factory. The factory instance is only used here for
+  // construction which means that it does not need to live longer that the
+  // constructor duration.

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

Passing a server socket instance here would be self explanatory and would not
need such comment.

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

Indeed. The initial motivation (still valid in my opinion) for a socket factory
instance rather than a socket instance, is that the socket depends on the
delegate (provided here by HttpServer) at construction time (circular
dependency). A workaround would be to add a setter to StreamListenSocket to set
the delegate once the two objects are constructed. In my opinion the factory
approach is better since it prevents the socket from being in an "intermediate
state" (i.e. delegate_ == NULL). It would also force the user to call
SetDelegate() which he could forget.
If you really don't like this comment, I can also remove it. It's not that
useful.

What do you think?

+  HttpServer(HttpServer::Delegate* delegate,
+             StreamListenSocketFactory* socket_factory);
 
   void AcceptWebSocket(int connection_id,
                        const HttpServerRequestInfo& request);
   void SendOverWebSocket(int connection_id, const std::string& data);
   void Send(int connection_id, const std::string& data);
   void Send(int connection_id, const char* bytes, int len);
   void Send200(int connection_id,
                const std::string& data,
                const std::string& mime_type);
   void Send404(int connection_id);
@@ skipping 31 matching lines @@
   IdToConnectionMap id_to_connection_;
   typedef std::map<StreamListenSocket*, HttpConnection*> SocketToConnectionMap;
   SocketToConnectionMap socket_to_connection_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpServer);
 };
 
 }  // namespace net
 
 #endif // NET_SERVER_HTTP_SERVER_H_