Replace StreamListenSocket with StreamSocket in HttpServer.

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_
 
 #include <list>

[mmenke, 2014/05/23 19:20:58]

I don't believe this is used?  (And wasn't before, either)

[byungchul, 2014/05/30 00:19:02]

Done.

 #include <map>
 
 #include "base/basictypes.h"

[mmenke, 2014/05/23 19:20:58]

Should use macros.h instead (To make sure we get both OVERRIDE and
DISALLOW_COPY_AND_ASSIGN)

[byungchul, 2014/05/30 00:19:02]

Done.

 #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"
+#include "net/server/http_connection.h"
 
 namespace net {
 
-class HttpConnection;
 class HttpServerRequestInfo;
 class HttpServerResponseInfo;
 class IPEndPoint;
+class ServerSocket;
+class StreamSocket;
 class WebSocket;
 
-class HttpServer : public StreamListenSocket::Delegate,
-                   public base::RefCountedThreadSafe<HttpServer> {
+class HttpServer : public HttpConnection::Delegate,
+                   public base::SupportsWeakPtr<HttpServer> {

[mmenke, 2014/05/23 19:20:58]

WeakPtrs shouldn't be exposed to external classes like this.  Use WeakPtrFactory
instead.

[mmenke, 2014/05/23 19:20:58]

This class should be declared with NEXT_EXPORT, shouldn't it?  I'm not entirely
sure why things are linking without that, actually.

[byungchul, 2014/05/28 01:19:35]

NEXT_EXPORT is only for shared lib. Not sure which platforms build all shared
libs separately (libbase.so, libnet.so, ...). Probably no platfroms do, and/so
this is not verified well.

[Ryan Sleevi, 2014/05/28 01:36:26]

All of our platforms do component builds on the waterfall. It's only Chrome
releases that do static builds.

So yes, Matt's comment applies - since you won't be able to pass trybots if this
class is used from a test (because net_unittests links against net.so)

[byungchul, 2014/05/30 00:19:02]

Done.

[byungchul, 2014/06/08 17:24:27]

Turned out that http_server is built as a static lib always. See
https://code.google.com/p/chromium/codesearch#chromium/src/net/net.gyp&l=1042 .
So, remove NET_EXPORT in lastest patch set.

  public:
   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(const StreamListenSocketFactory& socket_factory,
+  HttpServer(scoped_ptr<ServerSocket> server_socket,
              HttpServer::Delegate* delegate);
+  virtual ~HttpServer();
 
   void AcceptWebSocket(int connection_id,
                        const HttpServerRequestInfo& request);
   void SendOverWebSocket(int connection_id, const std::string& data);
   // Sends the provided data directly to the given connection. No validation is
   // 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);
   void SendResponse(int connection_id, const HttpServerResponseInfo& response);
   void Send(int connection_id,
             HttpStatusCode status_code,
             const std::string& data,
             const std::string& mime_type);
   void Send200(int connection_id,
                const std::string& data,
                const std::string& mime_type);
   void Send404(int connection_id);
   void Send500(int connection_id, const std::string& message);
 
   void Close(int connection_id);
 
   // Copies the local address to |address|. Returns a network error code.
   int GetLocalAddress(IPEndPoint* address);
 
-  // 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;
+ private:
+  friend class HttpServerTest;
 
- protected:
-  virtual ~HttpServer();
+  typedef std::map<int, HttpConnection*> IdToConnectionMap;
 
- private:
-  friend class base::RefCountedThreadSafe<HttpServer>;
-  friend class HttpConnection;
+  void DoAcceptLoop(int rv);
+  void OnAcceptCompleted(int rv);
+  int DidAccept(int rv);
+
+  // HttpConnection::Delegate
+  virtual void DidRead(HttpConnection* conn) OVERRIDE;
+  virtual void DidClose(HttpConnection* conn) OVERRIDE;
 
   // 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(HttpConnection* connection,
+  bool ParseHeaders(const char* data,
+                    size_t data_len,
                     HttpServerRequestInfo* info,
                     size_t* pos);
 
   HttpConnection* FindConnection(int connection_id);
-  HttpConnection* FindConnection(StreamListenSocket* socket);
 
-  HttpServer::Delegate* delegate_;
-  scoped_ptr<StreamListenSocket> server_;
-  typedef std::map<int, HttpConnection*> IdToConnectionMap;
+  const scoped_ptr<ServerSocket> server_socket_;
+  scoped_ptr<StreamSocket> accepted_socket_;
+  HttpServer::Delegate* const delegate_;
+
+  int last_id_;
   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_