HTTP server for testing Google Drive.

chrome/browser/chromeos/gdata/test_servers/http_test_server.cc

Index: chrome/browser/chromeos/gdata/test_servers/http_test_server.cc
diff --git a/chrome/browser/chromeos/gdata/test_servers/http_test_server.cc b/chrome/browser/chromeos/gdata/test_servers/http_test_server.cc
new file mode 100644
index 0000000000000000000000000000000000000000..79417a36e802b0a4eaf89b9b7cf301384d00aa4b
--- /dev/null
+++ b/chrome/browser/chromeos/gdata/test_servers/http_test_server.cc
@@ -0,0 +1,191 @@
+// 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 "chrome/browser/chromeos/gdata/test_servers/http_test_server.h"
+
+#include "base/stl_util.h"
+#include "base/file_util.h"
+#include "chrome/browser/chromeos/gdata/test_servers/http_request.h"
+#include "chrome/browser/chromeos/gdata/test_servers/http_response.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/tools/fetch/http_listen_socket.h"
+
+#include <sstream>
+
+namespace gdata {
+namespace test_servers {
+
+using content::BrowserThread;
+
+namespace {
+const int kPort = 8040;

[satorux1, 2012/10/12 08:29:18]

The port may already be in use by another test instance. We should be able to
pick an unused port.

[mtomasz, 2012/10/12 11:09:46]

It is already implemented. The server tries succeeding ports if this one is not
available.

+const std::string kIp = "127.0.0.1";
+const int kRetries = 10;
+}  // namespace
+
+DefaultResponseProvider::DefaultResponseProvider(
+    const GURL& request_url,
+    const HttpResponse& default_response) :
+        request_url_(request_url),
+        default_response_(default_response) {
+}
+
+DefaultResponseProvider::~DefaultResponseProvider() {
+}
+
+bool DefaultResponseProvider::CanHandleRequest(HttpRequest* request) {
+  // TODO(mtomasz): We ignore a query string here. Is it fine?
+  // TODO(mtomasz): We do not verify a host here, is it ok?
+  // TODO(mtomasz): How about proxy?
+  return request->url.path() == request_url_.path();
+}
+
+scoped_ptr<HttpResponse> DefaultResponseProvider::ProcessRequest(
+    HttpRequest* request) {
+  return scoped_ptr<HttpResponse>(
+      new HttpResponse(default_response_)).Pass();
+}
+
+HttpTestServer::HttpTestServer(bool start_on_create) : port_(-1),
+                                                       last_unique_id_(0) {
+  if (start_on_create) {
+    Start();
+  }
+}
+
+HttpTestServer::~HttpTestServer() {
+  STLDeleteContainerPointers(response_providers_.begin(),
+                             response_providers_.end());
+}
+
+bool HttpTestServer::Start() {
+  if (server_.get() != NULL) {
+    LOG(ERROR) << "Server already started.";
+    return false;
+  }
+
+  int port = kPort;
+  int tries_left = kRetries + 1;
+
+  // Try to create a listening socket.
+  while (tries_left) {
+    server_ = HttpServer::CreateServer(kIp, port, this);
+    if (server_.get() != NULL) {
+      port_ = port;
+      std::stringstream base_url_builder;
+      base_url_builder << "http://" << kIp << ":" << port;
+      base_url_ = GURL(base_url_builder.str());
+      return true;
+    }
+    port++;
+    tries_left--;
+  }
+
+  LOG(ERROR) << "Unabled to start the server.";
+  return false;
+}
+
+bool HttpTestServer::HandleRequest(HttpConnection& connection,
+                                   scoped_ptr<HttpRequest> request) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  std::vector<ResponseProviderInterface*>::iterator current_provider =
+      response_providers_.begin();
+  while (current_provider != response_providers_.end()) {
+    if ((*current_provider)->CanHandleRequest(request.get())) {
+      scoped_ptr<HttpResponse> response =
+          (*current_provider)->ProcessRequest(request.get());
+      connection.SendResponse(response.Pass());
+      return true;
+    }
+    current_provider++;
+  }
+
+  // TODO(mtomasz): Important. Return 404 here instead of just closing
+  // the socket.
+  LOG(ERROR) << "Request not handled. Closing the connection.";
+  return false;
+}
+
+GURL HttpTestServer::GetBaseURL() {
+  return base_url_;
+}
+
+GURL HttpTestServer::GetErrorURL(RESPONSE_CODE code) {
+  // TODO(mtomasz): Implement this.
+  return base_url_;
+}
+
+void HttpTestServer::RegisterResponseProvider(
+    ResponseProviderInterface& provider) {
+  response_providers_.push_back(&provider);
+}
+
+GURL HttpTestServer::RegisterDefaultResponse(
+    const std::string& relative_path,
+    const HttpResponse& default_response) {
+  GURL request_url = base_url_.Resolve(relative_path);
+  response_providers_.push_back(new DefaultResponseProvider(request_url,
+                                                            default_response));
+  return request_url;
+}
+
+GURL HttpTestServer::RegisterTextResponse(
+     const std::string& relative_path,
+     const std::string& content,
+     const std::string& content_type,
+     const RESPONSE_CODE response_code) {
+  HttpResponse default_response;
+  // TODO(mtomasz): Handle content.
+  default_response.content_type = content_type;
+  default_response.code = response_code;
+
+  return RegisterDefaultResponse(relative_path,
+                                 default_response);
+}
+
+GURL HttpTestServer::RegisterTextResponse(
+    const std::string& content,
+    const std::string& content_type) {
+  return RegisterTextResponse(GenerateUniqueIdentifier(),
+                              content,
+                              content_type,
+                              SUCCESS);
+}
+
+GURL HttpTestServer::RegisterFileResponse(
+     const std::string& relative_path,
+     const FilePath& file_path,
+     const std::string& content_type,
+     const RESPONSE_CODE response_code) {
+  HttpResponse default_response;
+
+  // TODO(mtomasz): Handle errors.
+  file_util::ReadFileToString(file_path, &default_response.content);
+
+  default_response.content_type = content_type;
+  default_response.code = response_code;
+
+  return RegisterDefaultResponse(relative_path,
+                                 default_response);
+}
+
+GURL HttpTestServer::RegisterFileResponse(
+     const FilePath& file_path,
+     const std::string& content_type) {
+  return RegisterFileResponse(
+      GenerateUniqueIdentifier() + "/" + file_path.BaseName().value(),
+      file_path,
+      content_type,
+      SUCCESS);
+}
+
+std::string HttpTestServer::GenerateUniqueIdentifier() {
+  std::stringstream result_builder;
+  result_builder << ++last_unique_id_;
+  return result_builder.str();
+}
+
+}  // namespace test_servers
+}  // namespace gdata