Add DefaultListenSocket.

chrome_frame/test/test_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 <windows.h>
 #include <objbase.h>
 #include <urlmon.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 57 matching lines @@
     if (index != std::string::npos) {
       // Parse the headers before returning and chop them of the
       // data buffer we've already received.
       std::string headers(content_.substr(0, index + 2));
       ParseHeaders(headers);
       content_.erase(0, index + 4);
     }
   }
 }
 
+ResponseForPath::~ResponseForPath() {
+}
+
+SimpleResponse::~SimpleResponse() {
+}
+
 bool FileResponse::GetContentType(std::string* content_type) const {
   size_t length = ContentLength();
   char buffer[4096];
   void* data = NULL;
 
   if (length) {
     // Create a copy of the first few bytes of the file.
     // If we try and use the mapped file directly, FindMimeFromData will crash
     // 'cause it cheats and temporarily tries to write to the buffer!
     length = std::min(arraysize(buffer), length);
     memcpy(buffer, file_->data(), length);
     data = buffer;
   }
 
   LPOLESTR mime_type = NULL;
   FindMimeFromData(NULL, file_path_.value().c_str(), data, length, NULL,
                    FMFD_DEFAULT, &mime_type, 0);
   if (mime_type) {
     *content_type = WideToASCII(mime_type);
     ::CoTaskMemFree(mime_type);
   }
 
   return content_type->length() > 0;
 }
 
-void FileResponse::WriteContents(net::ListenSocket* socket) const {
+void FileResponse::WriteContents(net::StreamListenSocket* socket) const {
   DCHECK(file_.get());
   if (file_.get()) {
     socket->Send(reinterpret_cast<const char*>(file_->data()),
                  file_->length(), false);
   }
 }
 
 size_t FileResponse::ContentLength() const {
   if (file_.get() == NULL) {
     file_.reset(new file_util::MemoryMappedFile());
@@ skipping 47 matching lines @@
   for (it = responses_.begin(); it != responses_.end(); it++) {
     Response* response = (*it);
     if (response->Matches(request)) {
       return response;
     }
   }
   return NULL;
 }
 
 Connection* SimpleWebServer::FindConnection(
-    const net::ListenSocket* socket) const {
+    const net::StreamListenSocket* socket) const {
   ConnectionList::const_iterator it;
   for (it = connections_.begin(); it != connections_.end(); it++) {
     if ((*it)->IsSame(socket)) {
       return (*it);
     }
   }
   return NULL;
 }
 
-void SimpleWebServer::DidAccept(net::ListenSocket* server,
-                                net::ListenSocket* connection) {
+void SimpleWebServer::DidAccept(net::StreamListenSocket* server,
+                                net::StreamListenSocket* connection) {
   connections_.push_back(new Connection(connection));
 }
 
-void SimpleWebServer::DidRead(net::ListenSocket* connection,
+void SimpleWebServer::DidRead(net::StreamListenSocket* connection,
                               const char* data,
                               int len) {
   Connection* c = FindConnection(connection);
   DCHECK(c);
   Request& r = c->request();
   std::string str(data, len);
   r.OnDataReceived(str);
   if (r.AllContentReceived()) {
     const Request& request = c->request();
     Response* response = FindResponse(request);
@@ skipping 16 matching lines @@
       std::string headers(base::StringPrintf(kDefaultHeaderTemplate,
                                              kStatusNotFound,
                                              kDefaultContentType,
                                              payload.length()));
       connection->Send(headers, false);
       connection->Send(payload, false);
     }
   }
 }
 
-void SimpleWebServer::DidClose(net::ListenSocket* sock) {
+void SimpleWebServer::DidClose(net::StreamListenSocket* sock) {
   // To keep the historical list of connections reasonably tidy, we delete
   // 404's when the connection ends.
   Connection* c = FindConnection(sock);
   DCHECK(c);
   c->OnSocketClosed();
   if (!FindResponse(c->request())) {
     // extremely inefficient, but in one line and not that common... :)
     connections_.erase(std::find(connections_.begin(), connections_.end(), c));
     delete c;
   }
 }
 
 HTTPTestServer::HTTPTestServer(int port, const std::wstring& address,
                                FilePath root_dir)
     : port_(port), address_(address), root_dir_(root_dir) {
   net::EnsureWinsockInit();
   server_ =
       net::TCPListenSocket::CreateAndListen(WideToUTF8(address), port, this);
 }
 
 HTTPTestServer::~HTTPTestServer() {
   server_ = NULL;
 }
 
 std::list<scoped_refptr<ConfigurableConnection>>::iterator
-HTTPTestServer::FindConnection(const net::ListenSocket* socket) {
+HTTPTestServer::FindConnection(const net::StreamListenSocket* socket) {
   ConnectionList::iterator it;
   // Scan through the list searching for the desired socket. Along the way,
   // erase any connections for which the corresponding socket has already been
   // forgotten about as a result of all data having been sent.
   for (it = connection_list_.begin(); it != connection_list_.end(); ) {
     ConfigurableConnection* connection = it->get();
     if (connection->socket_ == NULL) {
       connection_list_.erase(it++);
       continue;
     }
     if (connection->socket_ == socket)
       break;
     ++it;
   }
 
   return it;
 }
 
 scoped_refptr<ConfigurableConnection> HTTPTestServer::ConnectionFromSocket(
-    const net::ListenSocket* socket) {
+    const net::StreamListenSocket* socket) {
   ConnectionList::iterator it = FindConnection(socket);
   if (it != connection_list_.end())
     return *it;
   return NULL;
 }
 
-void HTTPTestServer::DidAccept(net::ListenSocket* server,
-                               net::ListenSocket* socket) {
+void HTTPTestServer::DidAccept(net::StreamListenSocket* server,
+                               net::StreamListenSocket* socket) {
   connection_list_.push_back(new ConfigurableConnection(socket));
 }
 
-void HTTPTestServer::DidRead(net::ListenSocket* socket,
+void HTTPTestServer::DidRead(net::StreamListenSocket* socket,
                              const char* data,
                              int len) {
   scoped_refptr<ConfigurableConnection> connection =
       ConnectionFromSocket(socket);
   if (connection) {
     std::string str(data, len);
     connection->r_.OnDataReceived(str);
     if (connection->r_.AllContentReceived()) {
       VLOG(1) << __FUNCTION__ << ": " << connection->r_.method() << " "
               << connection->r_.path();
       std::wstring path = UTF8ToWide(connection->r_.path());
       if (LowerCaseEqualsASCII(connection->r_.method(), "post"))
         this->Post(connection, path, connection->r_);
       else
         this->Get(connection, path, connection->r_);
     }
   }
 }
 
-void HTTPTestServer::DidClose(net::ListenSocket* socket) {
+void HTTPTestServer::DidClose(net::StreamListenSocket* socket) {
   ConnectionList::iterator it = FindConnection(socket);
   if (it != connection_list_.end())
     connection_list_.erase(it);
 }
 
 std::wstring HTTPTestServer::Resolve(const std::wstring& path) {
   // Remove the first '/' if needed.
   std::wstring stripped_path = path;
   if (path.size() && path[0] == L'/')
     stripped_path = path.substr(1);
@@ skipping 54 matching lines @@
                                                content.size());
   }
 
   // Save the options.
   options_ = options;
 
   if (options_.speed_ == SendOptions::IMMEDIATE) {
     socket_->Send(headers);
     socket_->Send(content_length_header, true);
     socket_->Send(content);
-    // Post a task to close the socket since ListenSocket doesn't like instances
-    // to go away from within its callbacks.
+    // Post a task to close the socket since StreamListenSocket doesn't like
+    // instances to go away from within its callbacks.
     MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&ConfigurableConnection::Close, this));
 
     return;
   }
 
   if (options_.speed_ == SendOptions::IMMEDIATE_HEADERS_DELAYED_CONTENT) {
     socket_->Send(headers);
     socket_->Send(content_length_header, true);
     VLOG(1) << "Headers sent: " << headers << content_length_header;
     data_.append(content);
   }
 
   if (options_.speed_ == SendOptions::DELAYED) {
     data_ = headers;
     data_.append(content_length_header);
     data_.append("\r\n");
   }
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(&ConfigurableConnection::SendChunk, this),
       base::TimeDelta::FromMilliseconds(options.timeout_));
 }
 
 }  // namespace test_server