RefCounted types should not have public destructors, net/

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"
 #include "base/sys_byteorder.h"
 #include "build/build_config.h"
 #include "net/base/tcp_listen_socket.h"
 #include "net/server/http_connection.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/web_socket.h"
 
 namespace net {
 
 HttpServer::HttpServer(const std::string& host,
                        int port,
                        HttpServer::Delegate* del)
     : delegate_(del) {
   server_ = TCPListenSocket::CreateAndListen(host, port, this);
 }
 
-HttpServer::~HttpServer() {
-  IdToConnectionMap copy = id_to_connection_;
-  for (IdToConnectionMap::iterator it = copy.begin(); it != copy.end(); ++it)
-    delete it->second;
+void HttpServer::AcceptWebSocket(
+    int connection_id,
+    const HttpServerRequestInfo& request) {
+  HttpConnection* connection = FindConnection(connection_id);
+  if (connection == NULL)
+    return;
 
-  server_ = NULL;
+  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);
 }
 
 void HttpServer::Send(int connection_id, const std::string& data) {
   HttpConnection* connection = FindConnection(connection_id);
   if (connection == NULL)
     return;
   connection->Send(data);
 }
 
 void HttpServer::Send(int connection_id, const char* bytes, int len) {
@@ skipping 31 matching lines @@
 {
   HttpConnection* connection = FindConnection(connection_id);
   if (connection == NULL)
     return;
 
   // Initiating close from server-side does not lead to the DidClose call.
   // Do it manually here.
   DidClose(connection->socket_);
 }
 
+void HttpServer::DidAccept(ListenSocket* server,
+                           ListenSocket* socket) {
+  HttpConnection* connection = new HttpConnection(this, socket);
+  id_to_connection_[connection->id()] = connection;
+  socket_to_connection_[socket] = connection;
+}
+
+void HttpServer::DidRead(ListenSocket* 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()) {
+      std::string message;
+      WebSocket::ParseResult result = connection->web_socket_->Read(&message);
+      if (result == WebSocket::FRAME_INCOMPLETE)
+        break;
+
+      if (result == WebSocket::FRAME_CLOSE ||
+          result == WebSocket::FRAME_ERROR) {
+        Close(connection->id());
+        break;
+      }
+      delegate_->OnWebSocketMessage(connection->id(), message);
+      continue;
+    }
+
+    HttpServerRequestInfo request;
+    size_t pos = 0;
+    if (!ParseHeaders(connection, &request, &pos))
+      break;
+
+    std::string connection_header = request.GetHeaderValue("Connection");
+    if (connection_header == "Upgrade") {
+      connection->web_socket_.reset(WebSocket::CreateWebSocket(connection,
+                                                               request,
+                                                               &pos));
+
+      if (!connection->web_socket_.get())  // Not enought data was received.
+        break;
+      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) {
+  HttpConnection* connection = FindConnection(socket);
+  DCHECK(connection != NULL);
+  id_to_connection_.erase(connection->id());
+  socket_to_connection_.erase(connection->socket_);
+  delete connection;
+}
+
+HttpServer::~HttpServer() {
+  IdToConnectionMap copy = id_to_connection_;
+  for (IdToConnectionMap::iterator it = copy.begin(); it != copy.end(); ++it)
+    delete it->second;
+
+  server_ = NULL;
+}
+
 //
 // HTTP Request Parser
 // This HTTP request parser uses a simple state machine to quickly parse
 // through the headers.  The parser is not 100% complete, as it is designed
 // for use in this simple test driver.
 //
 // Known issues:
 //   - does not handle whitespace on first HTTP line correctly.  Expects
 //     a single space between the method/url and url/protocol.
 
@@ skipping 111 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) {
-  HttpConnection* connection = new HttpConnection(this, socket);
-  id_to_connection_[connection->id()] = connection;
-  socket_to_connection_[socket] = connection;
-}
-
-void HttpServer::DidRead(ListenSocket* 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()) {
-      std::string message;
-      WebSocket::ParseResult result = connection->web_socket_->Read(&message);
-      if (result == WebSocket::FRAME_INCOMPLETE)
-        break;
-
-      if (result == WebSocket::FRAME_CLOSE ||
-          result == WebSocket::FRAME_ERROR) {
-        Close(connection->id());
-        break;
-      }
-      delegate_->OnWebSocketMessage(connection->id(), message);
-      continue;
-    }
-
-    HttpServerRequestInfo request;
-    size_t pos = 0;
-    if (!ParseHeaders(connection, &request, &pos))
-      break;
-
-    std::string connection_header = request.GetHeaderValue("Connection");
-    if (connection_header == "Upgrade") {
-      connection->web_socket_.reset(WebSocket::CreateWebSocket(connection,
-                                                               request,
-                                                               &pos));
-
-      if (!connection->web_socket_.get())  // Not enought data was received.
-        break;
-      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) {
-  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) {
   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