[chrome_frame] Refactor/merge IE no interference tests with other mock event ...

chrome_frame/test/test_server.cc

 // Copyright (c) 2006-2008 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 "base/logging.h"
 #include "base/registry.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 
 #include "chrome_frame/test/test_server.h"
 
 #include "net/base/winsock_init.h"
 #include "net/http/http_util.h"
 
 namespace test_server {
 const char kDefaultHeaderTemplate[] =
     "HTTP/1.1 %hs\r\n"
     "Connection: close\r\n"
@@ skipping 190 matching lines @@
   // 404's when the connection ends.
   Connection* c = FindConnection(sock);
   DCHECK(c);
   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 char* address) {
+HTTPTestServer::HTTPTestServer(int port, const std::wstring& address,
+                               FilePath root_dir)
+    : port_(port), address_(address), root_dir_(root_dir) {
   net::EnsureWinsockInit();
-  server_ = ListenSocket::Listen(address, port, this);
+  server_ = ListenSocket::Listen(WideToUTF8(address), port, this);
 }
 
 HTTPTestServer::~HTTPTestServer() {
 }
 
 std::list<scoped_refptr<ConfigurableConnection>>::iterator
 HTTPTestServer::FindConnection(const ListenSocket* socket) {
   ConnectionList::iterator it;
   for (it = connection_list_.begin(); it != connection_list_.end(); ++it) {
     if ((*it)->socket_ == socket) {
@@ skipping 15 matching lines @@
 void HTTPTestServer::DidAccept(ListenSocket* server, ListenSocket* socket) {
   connection_list_.push_back(new ConfigurableConnection(socket));
 }
 
 void HTTPTestServer::DidRead(ListenSocket* socket, const std::string& data) {
   scoped_refptr<ConfigurableConnection> connection =
       ConnectionFromSocket(socket);
   if (connection) {
     connection->r_.OnDataReceived(data);
     if (connection->r_.AllContentReceived()) {
+      std::wstring path = UTF8ToWide(connection->r_.path());
       if (LowerCaseEqualsASCII(connection->r_.method(), "post"))
-        this->Post(connection, connection->r_.path(), connection->r_);
+        this->Post(connection, path, connection->r_);
       else
-        this->Get(connection, connection->r_.path(), connection->r_);
+        this->Get(connection, path, connection->r_);
     }
   }
 }
 
 void HTTPTestServer::DidClose(ListenSocket* socket) {
   ConnectionList::iterator it = FindConnection(socket);
   DCHECK(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);
+
+  if (port_ == 80) {
+    if (stripped_path.empty()) {
+      return StringPrintf(L"http://%ls", address_.c_str());
+    } else {
+      return StringPrintf(L"http://%ls/%ls", address_.c_str(),
+                          stripped_path.c_str());
+    }
+  } else {
+    if (stripped_path.empty()) {
+      return StringPrintf(L"http://%ls:%d", address_.c_str(), port_);
+    } else {
+      return StringPrintf(L"http://%ls:%d/%ls", address_.c_str(), port_,
+                          stripped_path.c_str());
+    }
+  }
+}
+
 void ConfigurableConnection::SendChunk() {
   int size = (int)data_.size();
   const char* chunk_ptr = data_.c_str() + cur_pos_;
   int bytes_to_send = std::min(options_.chunk_size_, size - cur_pos_);
 
   socket_->Send(chunk_ptr, bytes_to_send);
   DLOG(INFO) << "Sent(" << cur_pos_ << "," << bytes_to_send
       << "): " << base::StringPiece(chunk_ptr, bytes_to_send);
 
   cur_pos_ += bytes_to_send;
@@ skipping 42 matching lines @@
   if (options_.speed_ == SendOptions::DELAYED) {
     data_ = headers;
     data_.append(content_length_header);
     data_.append("\r\n");
   }
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       NewRunnableMethod(this, &ConfigurableConnection::SendChunk),
                         options.timeout_);
 }
-}  // namespace test_server
+
+}  // namespace test_server