Move url_request_mock_http_job to net/test/url_request/

net/test/url_request/url_request_mock_http_job.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 "content/test/net/url_request_mock_http_job.h"
+#include "net/test/url_request/url_request_mock_http_job.h"
 
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/url_constants.h"
 #include "net/base/filename_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 
 const char kMockHostname[] = "mock.http";
 const base::FilePath::CharType kMockHeaderFileSuffix[] =
     FILE_PATH_LITERAL(".mock-http-headers");
 
-namespace content {
+namespace net {
 
 namespace {
 
 class MockJobInterceptor : public net::URLRequestInterceptor {
  public:
   // When |map_all_requests_to_base_path| is true, all request should return the
   // contents of the file at |base_path|. When |map_all_requests_to_base_path|
   // is false, |base_path| is the file path leading to the root of the directory
   // to use as the root of the HTTP server.
-  MockJobInterceptor(const base::FilePath& base_path,
-                     bool map_all_requests_to_base_path)
+  MockJobInterceptor(
+      const base::FilePath& base_path,
+      bool map_all_requests_to_base_path,
+      const scoped_refptr<base::SequencedWorkerPool>& worker_pool)
       : base_path_(base_path),
-        map_all_requests_to_base_path_(map_all_requests_to_base_path) {}
+        map_all_requests_to_base_path_(map_all_requests_to_base_path),
+        worker_pool_(worker_pool) {}
   virtual ~MockJobInterceptor() {}
 
   // net::URLRequestJobFactory::ProtocolHandler implementation
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
     return new URLRequestMockHTTPJob(request, network_delegate,
-        map_all_requests_to_base_path_ ? base_path_ : GetOnDiskPath(request));
+        map_all_requests_to_base_path_ ? base_path_ : GetOnDiskPath(request),
+        worker_pool_);
   }
 
  private:
   base::FilePath GetOnDiskPath(net::URLRequest* request) const {
     // Conceptually we just want to "return base_path_ + request->url().path()".
     // But path in the request URL is in URL space (i.e. %-encoded spaces).
     // So first we convert base FilePath to a URL, then append the URL
     // path to that, and convert the final URL back to a FilePath.
     GURL file_url(net::FilePathToFileURL(base_path_));
     std::string url = file_url.spec() + request->url().path();
     base::FilePath file_path;
     net::FileURLToFilePath(GURL(url), &file_path);
     return file_path;
   }
 
   const base::FilePath base_path_;
   const bool map_all_requests_to_base_path_;
+  const scoped_refptr<base::SequencedWorkerPool> worker_pool_;
 
   DISALLOW_COPY_AND_ASSIGN(MockJobInterceptor);
 };
 
 }  // namespace
 
 // static
-void URLRequestMockHTTPJob::AddUrlHandler(const base::FilePath& base_path) {
+void URLRequestMockHTTPJob::AddUrlHandler(
+    const base::FilePath& base_path,
+    const scoped_refptr<base::SequencedWorkerPool>& worker_pool) {
   // Add kMockHostname to net::URLRequestFilter.
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   filter->AddHostnameInterceptor(
-      "http", kMockHostname, CreateInterceptor(base_path));
+      "http", kMockHostname, CreateInterceptor(base_path, worker_pool));
 }
 
 // static
 void URLRequestMockHTTPJob::AddHostnameToFileHandler(
     const std::string& hostname,
-    const base::FilePath& file) {
+    const base::FilePath& file,
+    const scoped_refptr<base::SequencedWorkerPool>& worker_pool) {
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   filter->AddHostnameInterceptor(
-      "http", hostname, CreateInterceptorForSingleFile(file));
+      "http", hostname,
+      CreateInterceptorForSingleFile(file, worker_pool));
 }
 
 // static
 GURL URLRequestMockHTTPJob::GetMockUrl(const base::FilePath& path) {
   std::string url = "http://";
   url.append(kMockHostname);
   url.append("/");
   std::string path_str = path.MaybeAsASCII();
   DCHECK(!path_str.empty());  // We only expect ASCII paths in tests.
   url.append(path_str);
   return GURL(url);
 }
 
 // static
-GURL URLRequestMockHTTPJob::GetMockViewSourceUrl(const base::FilePath& path) {
-  std::string url = kViewSourceScheme;
-  url.append(":");
-  url.append(GetMockUrl(path).spec());
-  return GURL(url);
-}
-
-// static
 scoped_ptr<net::URLRequestInterceptor>
-URLRequestMockHTTPJob::CreateInterceptor(const base::FilePath& base_path) {
+URLRequestMockHTTPJob::CreateInterceptor(
+    const base::FilePath& base_path,
+    const scoped_refptr<base::SequencedWorkerPool>& worker_pool) {
   return scoped_ptr<net::URLRequestInterceptor>(
-      new MockJobInterceptor(base_path, false));
+      new MockJobInterceptor(base_path, false, worker_pool));
 }
 
 // static
 scoped_ptr<net::URLRequestInterceptor>
 URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
-    const base::FilePath& file) {
+    const base::FilePath& file,
+    const scoped_refptr<base::SequencedWorkerPool>& worker_pool) {
   return scoped_ptr<net::URLRequestInterceptor>(
-      new MockJobInterceptor(file, true));
+      new MockJobInterceptor(file, true, worker_pool));
 }
 
 URLRequestMockHTTPJob::URLRequestMockHTTPJob(
     net::URLRequest* request, net::NetworkDelegate* network_delegate,
-    const base::FilePath& file_path)
+    const base::FilePath& file_path,
+    const scoped_refptr<base::SequencedWorkerPool>& worker_pool)
     : net::URLRequestFileJob(
           request, network_delegate, file_path,
-          content::BrowserThread::GetBlockingPool()->
-              GetTaskRunnerWithShutdownBehavior(
-                  base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {}
+          worker_pool->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
+      task_runner_(
+          worker_pool->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),

[mmenke, 2014/09/05 20:06:15]

Rather than creating two TaskRunners, I think we should just create one in
MaybeInterceptRequest, and pass it in to the URLRequestMockHTTPJob constructor,
so the two classes can share a single TaskRunner.

[xunjieli, 2014/09/05 20:59:44]

Done.The callers of the URLRequestMockHTTPJob will now pass in a task runner
instead of a worker pool right?

[mmenke, 2014/09/05 21:10:29]

Yes, they will - I hadn't considered that.  Still think it's the way to go,
though.

+      weak_ptr_factory_(this) {
+}
 
 URLRequestMockHTTPJob::~URLRequestMockHTTPJob() { }
 
 // Public virtual version.
 void URLRequestMockHTTPJob::GetResponseInfo(net::HttpResponseInfo* info) {
   // Forward to private const version.
   GetResponseInfoConst(info);
 }
 
 bool URLRequestMockHTTPJob::IsRedirectResponse(GURL* location,
                                                int* http_status_code) {
   // Override the net::URLRequestFileJob implementation to invoke the default
   // one based on HttpResponseInfo.
   return net::URLRequestJob::IsRedirectResponse(location, http_status_code);
 }
 
+// Public virtual version.
+void URLRequestMockHTTPJob::Start() {
+  base::PostTaskAndReplyWithResult(
+      task_runner_.get(),
+      FROM_HERE,
+      base::Bind(&URLRequestMockHTTPJob::DoFileIO,
+          base::Unretained(this)),
+      base::Bind(&URLRequestMockHTTPJob::GetRawHeaders,
+          weak_ptr_factory_.GetWeakPtr()));
+}
+
+std::string URLRequestMockHTTPJob::DoFileIO() {
+  base::FilePath header_file =
+      base::FilePath(file_path_.value() + kMockHeaderFileSuffix);

[mmenke, 2014/09/05 20:06:15]

It's unsafe to dereference members of URLRequestMockHTTPJob on this thread - the
mock job may have been cancelled by the time this executes.  Instead, this
function should not be a member of URLRequestMockHTTPJob, it should be in the
anonymous namespace at the top of this file, and take in the FilePath as an
argument.  They way, it can still run after the destruction of the
URLRequestMockHTTPJob (The callback that's run on the source thread will then
notice it's been deleted when it's invoked, and safely do nothing).

[xunjieli, 2014/09/05 20:59:44]

Done.I will this in mind. Thanks for explaining!

+
+  if (!base::PathExists(header_file)) {
+    // If there is no mock-http-headers file, fake a 200 OK.
+    return "HTTP/1.0 200 OK\n";
+  }
+
+  std::string raw_headers;
+  base::ReadFileToString(header_file, &raw_headers);
+  return raw_headers;
+}
+
+void URLRequestMockHTTPJob::GetRawHeaders(std::string raw_headers) {
+  // Handle CRLF line-endings.
+  ReplaceSubstringsAfterOffset(&raw_headers_, 0, "\r\n", "\n");
+  // ParseRawHeaders expects \0 to end each header line.
+  ReplaceSubstringsAfterOffset(&raw_headers_, 0, "\n", std::string("\0", 1));
+  raw_headers_ = raw_headers;
+  URLRequestFileJob::Start();
+}
+
 // Private const version.
 void URLRequestMockHTTPJob::GetResponseInfoConst(
     net::HttpResponseInfo* info) const {
-  // We have to load our headers from disk, but we only use this class
-  // from tests, so allow these IO operations to happen on any thread.
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-
-  base::FilePath header_file =
-      base::FilePath(file_path_.value() + kMockHeaderFileSuffix);
-  std::string raw_headers;
-  if (!base::PathExists(header_file)) {
-    // If there is no mock-http-headers file, fake a 200 OK.
-    raw_headers = "HTTP/1.0 200 OK\n";
-  } else {
-    if (!base::ReadFileToString(header_file, &raw_headers))
-      return;
-  }
-
-  // Handle CRLF line-endings.
-  ReplaceSubstringsAfterOffset(&raw_headers, 0, "\r\n", "\n");
-  // ParseRawHeaders expects \0 to end each header line.
-  ReplaceSubstringsAfterOffset(&raw_headers, 0, "\n", std::string("\0", 1));
-  info->headers = new net::HttpResponseHeaders(raw_headers);
+  info->headers = new net::HttpResponseHeaders(raw_headers_);
 }
 
 bool URLRequestMockHTTPJob::GetMimeType(std::string* mime_type) const {
   net::HttpResponseInfo info;
   GetResponseInfoConst(&info);
   return info.headers.get() && info.headers->GetMimeType(mime_type);
 }
 
 int URLRequestMockHTTPJob::GetResponseCode() const {
   net::HttpResponseInfo info;
   GetResponseInfoConst(&info);
   // If we have headers, get the response code from them.
   if (info.headers.get())
     return info.headers->response_code();
   return net::URLRequestJob::GetResponseCode();
 }
 
 bool URLRequestMockHTTPJob::GetCharset(std::string* charset) {
   net::HttpResponseInfo info;
   GetResponseInfo(&info);
   return info.headers.get() && info.headers->GetCharset(charset);
 }
 
-}  // namespace content
+}  // namespace net