Componentize component_updater: Move URLRequestPrepackagedInterceptor from content/ to net/

net/url_request/test_url_request_interceptor.cc

Index: net/url_request/test_url_request_interceptor.cc
diff --git a/content/test/net/url_request_prepackaged_interceptor.cc b/net/url_request/test_url_request_interceptor.cc
similarity index 50%
rename from content/test/net/url_request_prepackaged_interceptor.cc
rename to net/url_request/test_url_request_interceptor.cc
index 8e821b9408d3c87180289ccd963b8564a10c693d..bea26ba896a298bc9d1d601f58e0e49e0c8c34d5 100644
--- a/content/test/net/url_request_prepackaged_interceptor.cc
+++ b/net/url_request/test_url_request_interceptor.cc
@@ -2,34 +2,32 @@
 // 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_prepackaged_interceptor.h"
+#include "net/url_request/test_url_request_interceptor.h"
 
 #include "base/file_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_restrictions.h"
-#include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using content::BrowserThread;
-
-namespace content {
+namespace net {
 
 namespace {
 
 class URLRequestPrepackagedJob : public net::URLRequestFileJob {
  public:
-  URLRequestPrepackagedJob(net::URLRequest* request,
-                           net::NetworkDelegate* network_delegate,
-                           const base::FilePath& file_path)
-      : net::URLRequestFileJob(
-            request, network_delegate, file_path,
-            content::BrowserThread::GetBlockingPool()->
-                GetTaskRunnerWithShutdownBehavior(
-                    base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {}
+  URLRequestPrepackagedJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate,
+      const base::FilePath& file_path,
+      const scoped_refptr<base::TaskRunner>& worker_task_runner)
+      : net::URLRequestFileJob(request,
+                               network_delegate,
+                               file_path,
+                               worker_task_runner) {}
 
   virtual int GetResponseCode() const OVERRIDE { return 200; }
 
@@ -41,22 +39,26 @@ class URLRequestPrepackagedJob : public net::URLRequestFileJob {
 
 }  // namespace
 
-class URLRequestPrepackagedInterceptor::Delegate
-    : public net::URLRequestInterceptor {
+class TestURLRequestInterceptor::Delegate : public net::URLRequestInterceptor {
  public:
-  Delegate(const std::string& scheme, const std::string& hostname)
-    : scheme_(scheme), hostname_(hostname), hit_count_(0) {}
+  Delegate(const std::string& scheme,
+           const std::string& hostname,
+           const scoped_refptr<base::TaskRunner>& io_task_runner,
+           const scoped_refptr<base::TaskRunner>& worker_task_runner)
+      : scheme_(scheme),
+        hostname_(hostname),
+        io_task_runner_(io_task_runner),
+        worker_task_runner_(worker_task_runner),
+        hit_count_(0) {}
   virtual ~Delegate() {}
 
   void Register() {
     net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
-        scheme_, hostname_,
-        scoped_ptr<net::URLRequestInterceptor>(this));
+        scheme_, hostname_, scoped_ptr<net::URLRequestInterceptor>(this));
   }
 
-  static void Unregister(
-      const std::string& scheme,
-      const std::string& hostname) {
+  static void Unregister(const std::string& scheme,
+                         const std::string& hostname) {
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(scheme,
                                                                 hostname);
   }
@@ -67,7 +69,7 @@ class URLRequestPrepackagedInterceptor::Delegate
   void SetResponse(const GURL& url,
                    const base::FilePath& path,
                    bool ignore_query) {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());

[tommycli, 2014/08/26 22:40:23]

This used to be a CHECK. Changed to DCHECK. This correct?

     // It's ok to do a blocking disk access on this thread; this class
     // is just used for tests.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
@@ -92,7 +94,7 @@ class URLRequestPrepackagedInterceptor::Delegate
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());

[tommycli, 2014/08/26 22:40:23]

And here.

     if (request->url().scheme() != scheme_ ||
         request->url().host() != hostname_) {
       return NULL;
@@ -116,14 +118,16 @@ class URLRequestPrepackagedInterceptor::Delegate
       ++hit_count_;
     }
 
-    return new URLRequestPrepackagedJob(request,
-                                        network_delegate,
-                                        it->second);
+    return new URLRequestPrepackagedJob(
+        request, network_delegate, it->second, worker_task_runner_);
   }
 
   const std::string scheme_;
   const std::string hostname_;
 
+  const scoped_refptr<base::TaskRunner> io_task_runner_;
+  const scoped_refptr<base::TaskRunner> worker_task_runner_;
+
   ResponseMap responses_;
   ResponseMap ignore_query_responses_;
 
@@ -133,55 +137,61 @@ class URLRequestPrepackagedInterceptor::Delegate
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
-
-URLRequestPrepackagedInterceptor::URLRequestPrepackagedInterceptor(
+TestURLRequestInterceptor::TestURLRequestInterceptor(
     const std::string& scheme,
-    const std::string& hostname)
+    const std::string& hostname,
+    const scoped_refptr<base::TaskRunner>& io_task_runner,
+    const scoped_refptr<base::TaskRunner>& worker_task_runner)
     : scheme_(scheme),
       hostname_(hostname),
-      delegate_(new Delegate(scheme, hostname)) {
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&Delegate::Register,
-                                     base::Unretained(delegate_)));
+      io_task_runner_(io_task_runner),
+      delegate_(
+          new Delegate(scheme, hostname, io_task_runner_, worker_task_runner)) {
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Delegate::Register, base::Unretained(delegate_)));
 }
 
-URLRequestPrepackagedInterceptor::~URLRequestPrepackagedInterceptor() {
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&Delegate::Unregister,
-                                     scheme_,
-                                     hostname_));
+TestURLRequestInterceptor::~TestURLRequestInterceptor() {
+  io_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Delegate::Unregister, scheme_, hostname_));
 }
 
-void URLRequestPrepackagedInterceptor::SetResponse(
-    const GURL& url,
-    const base::FilePath& path) {
+void TestURLRequestInterceptor::SetResponse(const GURL& url,
+                                            const base::FilePath& path) {
   CHECK_EQ(scheme_, url.scheme());
   CHECK_EQ(hostname_, url.host());
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&Delegate::SetResponse,
-                                     base::Unretained(delegate_), url, path,
-                                     false));
+  io_task_runner_->PostTask(FROM_HERE,
+                            base::Bind(&Delegate::SetResponse,
+                                       base::Unretained(delegate_),
+                                       url,
+                                       path,
+                                       false));
 }
 
-void URLRequestPrepackagedInterceptor::SetResponseIgnoreQuery(
+void TestURLRequestInterceptor::SetResponseIgnoreQuery(
     const GURL& url,
     const base::FilePath& path) {
   CHECK_EQ(scheme_, url.scheme());
   CHECK_EQ(hostname_, url.host());
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&Delegate::SetResponse,
-                                     base::Unretained(delegate_), url, path,
-                                     true));
+  io_task_runner_->PostTask(FROM_HERE,
+                            base::Bind(&Delegate::SetResponse,
+                                       base::Unretained(delegate_),
+                                       url,
+                                       path,
+                                       true));
 }
 
-int URLRequestPrepackagedInterceptor::GetHitCount() {
+int TestURLRequestInterceptor::GetHitCount() {
   return delegate_->GetHitCount();
 }
 
-
-URLLocalHostRequestPrepackagedInterceptor
-  ::URLLocalHostRequestPrepackagedInterceptor()
-    : URLRequestPrepackagedInterceptor("http", "localhost") {
+LocalHostTestURLRequestInterceptor::LocalHostTestURLRequestInterceptor(
+    const scoped_refptr<base::TaskRunner>& io_task_runner,
+    const scoped_refptr<base::TaskRunner>& worker_task_runner)
+    : TestURLRequestInterceptor("http",
+                                "localhost",
+                                io_task_runner,
+                                worker_task_runner) {
 }
 
-}  // namespace content
+}  // namespace net