Add DefaultListenSocket.

net/server/http_server.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 "net/server/http_server.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 194 matching lines @@
           return true;
         case ST_ERR:
           return false;
       }
     }
   }
   // No more characters, but we haven't finished parsing yet.
   return false;
 }
 
-void HttpServer::DidAccept(ListenSocket* server,
-                           ListenSocket* socket) {
+void HttpServer::DidAccept(StreamListenSocket* server,
+                           StreamListenSocket* socket) {
   HttpConnection* connection = new HttpConnection(this, socket);
   id_to_connection_[connection->id()] = connection;
   socket_to_connection_[socket] = connection;
 }
 
-void HttpServer::DidRead(ListenSocket* socket,
+void HttpServer::DidRead(StreamListenSocket* socket,
                          const char* data,
                          int len) {
   HttpConnection* connection = FindConnection(socket);
   DCHECK(connection != NULL);
   if (connection == NULL)
     return;
 
   connection->recv_data_.append(data, len);
   while (connection->recv_data_.length()) {
     if (connection->web_socket_.get()) {
@@ skipping 27 matching lines @@
       delegate_->OnWebSocketRequest(connection->id(), request);
       connection->Shift(pos);
       continue;
     }
     // Request body is not supported. It is always empty.
     delegate_->OnHttpRequest(connection->id(), request);
     connection->Shift(pos);
   }
 }
 
-void HttpServer::DidClose(ListenSocket* socket) {
+void HttpServer::DidClose(StreamListenSocket* socket) {
   HttpConnection* connection = FindConnection(socket);
   DCHECK(connection != NULL);
   id_to_connection_.erase(connection->id());
   socket_to_connection_.erase(connection->socket_);
   delete connection;
 }
 
 HttpConnection* HttpServer::FindConnection(int connection_id) {
   IdToConnectionMap::iterator it = id_to_connection_.find(connection_id);
   if (it == id_to_connection_.end())
     return NULL;
   return it->second;
 }
 
-HttpConnection* HttpServer::FindConnection(ListenSocket* socket) {
+HttpConnection* HttpServer::FindConnection(StreamListenSocket* socket) {
   SocketToConnectionMap::iterator it = socket_to_connection_.find(socket);
   if (it == socket_to_connection_.end())
     return NULL;
   return it->second;
 }
 
 void HttpServer::AcceptWebSocket(
     int connection_id,
     const HttpServerRequestInfo& request) {
   HttpConnection* connection = FindConnection(connection_id);
   if (connection == NULL)
     return;
 
   DCHECK(connection->web_socket_.get());
   connection->web_socket_->Accept(request);
 }
 
 void HttpServer::SendOverWebSocket(int connection_id,
                                    const std::string& data) {
   HttpConnection* connection = FindConnection(connection_id);
   if (connection == NULL)
     return;
   DCHECK(connection->web_socket_.get());
   connection->web_socket_->Send(data);
 }
 
 }  // namespace net