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