src/content/test/net/url_request_mock_http_job.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/test/net/url_request_mock_http_job.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/threading/sequenced_worker_pool.h"
  12 #include "base/threading/thread_restrictions.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "content/public/common/url_constants.h"
  15 #include "net/base/filename_util.h"
  16 #include "net/http/http_response_headers.h"
  17 #include "net/url_request/url_request_filter.h"
  18 #include "net/url_request/url_request_interceptor.h"
  19
  20 const char kMockHostname[] = "mock.http";
  21 const base::FilePath::CharType kMockHeaderFileSuffix[] =
  22     FILE_PATH_LITERAL(".mock-http-headers");
  23
  24 namespace content {
  25
  26 namespace {
  27
  28 class MockJobInterceptor : public net::URLRequestInterceptor {
  29  public:
  30   // When |map_all_requests_to_base_path| is true, all request should return the
  31   // contents of the file at |base_path|. When |map_all_requests_to_base_path|
  32   // is false, |base_path| is the file path leading to the root of the directory
  33   // to use as the root of the HTTP server.
  34   MockJobInterceptor(const base::FilePath& base_path,
  35                      bool map_all_requests_to_base_path)
  36       : base_path_(base_path),
  37         map_all_requests_to_base_path_(map_all_requests_to_base_path) {}
  38   virtual ~MockJobInterceptor() {}
  39
  40   // net::URLRequestJobFactory::ProtocolHandler implementation
  41   virtual net::URLRequestJob* MaybeInterceptRequest(
  42       net::URLRequest* request,
  43       net::NetworkDelegate* network_delegate) const OVERRIDE {
  44     return new URLRequestMockHTTPJob(request, network_delegate,
  45         map_all_requests_to_base_path_ ? base_path_ : GetOnDiskPath(request));
  46   }
  47
  48  private:
  49   base::FilePath GetOnDiskPath(net::URLRequest* request) const {
  50     // Conceptually we just want to "return base_path_ + request->url().path()".
  51     // But path in the request URL is in URL space (i.e. %-encoded spaces).
  52     // So first we convert base FilePath to a URL, then append the URL
  53     // path to that, and convert the final URL back to a FilePath.
  54     GURL file_url(net::FilePathToFileURL(base_path_));
  55     std::string url = file_url.spec() + request->url().path();
  56     base::FilePath file_path;
  57     net::FileURLToFilePath(GURL(url), &file_path);
  58     return file_path;
  59   }
  60
  61   const base::FilePath base_path_;
  62   const bool map_all_requests_to_base_path_;
  63
  64   DISALLOW_COPY_AND_ASSIGN(MockJobInterceptor);
  65 };
  66
  67 }  // namespace
  68
  69 // static
  70 void URLRequestMockHTTPJob::AddUrlHandler(const base::FilePath& base_path) {
  71   // Add kMockHostname to net::URLRequestFilter.
  72   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
  73   filter->AddHostnameInterceptor(
  74       "http", kMockHostname, CreateInterceptor(base_path));
  75 }
  76
  77 // static
  78 void URLRequestMockHTTPJob::AddHostnameToFileHandler(
  79     const std::string& hostname,
  80     const base::FilePath& file) {
  81   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
  82   filter->AddHostnameInterceptor(
  83       "http", hostname, CreateInterceptorForSingleFile(file));
  84 }
  85
  86 // static
  87 GURL URLRequestMockHTTPJob::GetMockUrl(const base::FilePath& path) {
  88   std::string url = "http://";
  89   url.append(kMockHostname);
  90   url.append("/");
  91   std::string path_str = path.MaybeAsASCII();
  92   DCHECK(!path_str.empty());  // We only expect ASCII paths in tests.
  93   url.append(path_str);
  94   return GURL(url);
  95 }
  96
  97 // static
  98 GURL URLRequestMockHTTPJob::GetMockViewSourceUrl(const base::FilePath& path) {
  99   std::string url = kViewSourceScheme;
 100   url.append(":");
 101   url.append(GetMockUrl(path).spec());
 102   return GURL(url);
 103 }
 104
 105 // static
 106 scoped_ptr<net::URLRequestInterceptor>
 107 URLRequestMockHTTPJob::CreateInterceptor(const base::FilePath& base_path) {
 108   return scoped_ptr<net::URLRequestInterceptor>(
 109       new MockJobInterceptor(base_path, false));
 110 }
 111
 112 // static
 113 scoped_ptr<net::URLRequestInterceptor>
 114 URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
 115     const base::FilePath& file) {
 116   return scoped_ptr<net::URLRequestInterceptor>(
 117       new MockJobInterceptor(file, true));
 118 }
 119
 120 URLRequestMockHTTPJob::URLRequestMockHTTPJob(
 121     net::URLRequest* request, net::NetworkDelegate* network_delegate,
 122     const base::FilePath& file_path)
 123     : net::URLRequestFileJob(
 124           request, network_delegate, file_path,
 125           content::BrowserThread::GetBlockingPool()->
 126               GetTaskRunnerWithShutdownBehavior(
 127                   base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {}
 128
 129 URLRequestMockHTTPJob::~URLRequestMockHTTPJob() { }
 130
 131 // Public virtual version.
 132 void URLRequestMockHTTPJob::GetResponseInfo(net::HttpResponseInfo* info) {
 133   // Forward to private const version.
 134   GetResponseInfoConst(info);
 135 }
 136
 137 bool URLRequestMockHTTPJob::IsRedirectResponse(GURL* location,
 138                                                int* http_status_code) {
 139   // Override the net::URLRequestFileJob implementation to invoke the default
 140   // one based on HttpResponseInfo.
 141   return net::URLRequestJob::IsRedirectResponse(location, http_status_code);
 142 }
 143
 144 // Private const version.
 145 void URLRequestMockHTTPJob::GetResponseInfoConst(
 146     net::HttpResponseInfo* info) const {
 147   // We have to load our headers from disk, but we only use this class
 148   // from tests, so allow these IO operations to happen on any thread.
 149   base::ThreadRestrictions::ScopedAllowIO allow_io;
 150
 151   base::FilePath header_file =
 152       base::FilePath(file_path_.value() + kMockHeaderFileSuffix);
 153   std::string raw_headers;
 154   if (!base::PathExists(header_file)) {
 155     // If there is no mock-http-headers file, fake a 200 OK.
 156     raw_headers = "HTTP/1.0 200 OK\n";
 157   } else {
 158     if (!base::ReadFileToString(header_file, &raw_headers))
 159       return;
 160   }
 161
 162   // Handle CRLF line-endings.
 163   ReplaceSubstringsAfterOffset(&raw_headers, 0, "\r\n", "\n");
 164   // ParseRawHeaders expects \0 to end each header line.
 165   ReplaceSubstringsAfterOffset(&raw_headers, 0, "\n", std::string("\0", 1));
 166   info->headers = new net::HttpResponseHeaders(raw_headers);
 167 }
 168
 169 bool URLRequestMockHTTPJob::GetMimeType(std::string* mime_type) const {
 170   net::HttpResponseInfo info;
 171   GetResponseInfoConst(&info);
 172   return info.headers.get() && info.headers->GetMimeType(mime_type);
 173 }
 174
 175 int URLRequestMockHTTPJob::GetResponseCode() const {
 176   net::HttpResponseInfo info;
 177   GetResponseInfoConst(&info);
 178   // If we have headers, get the response code from them.
 179   if (info.headers.get())
 180     return info.headers->response_code();
 181   return net::URLRequestJob::GetResponseCode();
 182 }
 183
 184 bool URLRequestMockHTTPJob::GetCharset(std::string* charset) {
 185   net::HttpResponseInfo info;
 186   GetResponseInfo(&info);
 187   return info.headers.get() && info.headers->GetCharset(charset);
 188 }
 189
 190 }  // namespace content