Componentize component_updater: Break content/ dependency for rest of component_updater tests.

components/component_updater/test/url_request_post_interceptor.cc

 // Copyright 2013 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 "components/component_updater/test/url_request_post_interceptor.h"
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "components/component_updater/test/test_configurator.h"
-#include "content/public/test/test_browser_thread.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/url_request_test_util.h"
 
-using content::BrowserThread;
-
 namespace component_updater {
 
 // Returns a canned response.
 class URLRequestMockJob : public net::URLRequestSimpleJob {
  public:
   URLRequestMockJob(net::URLRequest* request,
                     net::NetworkDelegate* network_delegate,
                     const std::string& response)
       : net::URLRequestSimpleJob(request, network_delegate),
         response_(response) {}
@@ skipping 11 matching lines @@
     return net::OK;
   }
 
  private:
   virtual ~URLRequestMockJob() {}
 
   std::string response_;
   DISALLOW_COPY_AND_ASSIGN(URLRequestMockJob);
 };
 
-URLRequestPostInterceptor::URLRequestPostInterceptor(const GURL& url)
-    : url_(url), hit_count_(0) {
+URLRequestPostInterceptor::URLRequestPostInterceptor(
+    const GURL& url,
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
+    : url_(url), io_task_runner_(io_task_runner), hit_count_(0) {
 }
 
 URLRequestPostInterceptor::~URLRequestPostInterceptor() {
-  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   ClearExpectations();
 }
 
 void URLRequestPostInterceptor::ClearExpectations() {
   while (!expectations_.empty()) {
     Expectation expectation(expectations_.front());
     delete expectation.first;
     expectations_.pop();
   }
 }
@@ skipping 50 matching lines @@
 
 void URLRequestPostInterceptor::Reset() {
   base::AutoLock auto_lock(interceptor_lock_);
   hit_count_ = 0;
   requests_.clear();
   ClearExpectations();
 }
 
 class URLRequestPostInterceptor::Delegate : public net::URLRequestInterceptor {
  public:
-  Delegate(const std::string& scheme, const std::string& hostname)
-      : scheme_(scheme), hostname_(hostname) {}
+  Delegate(const std::string& scheme,
+           const std::string& hostname,
+           const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
+      : scheme_(scheme), hostname_(hostname), io_task_runner_(io_task_runner) {}
 
   void Register() {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     net::URLRequestFilter::GetInstance()->AddHostnameInterceptor(
         scheme_, hostname_, scoped_ptr<net::URLRequestInterceptor>(this));
   }
 
   void Unregister() {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     for (InterceptorMap::iterator it = interceptors_.begin();
          it != interceptors_.end();
          ++it)
       delete (*it).second;
     net::URLRequestFilter::GetInstance()->RemoveHostnameHandler(scheme_,
                                                                 hostname_);
   }
 
   void OnCreateInterceptor(URLRequestPostInterceptor* interceptor) {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     CHECK(interceptors_.find(interceptor->GetUrl()) == interceptors_.end());
 
     interceptors_.insert(std::make_pair(interceptor->GetUrl(), interceptor));
   }
 
  private:
   virtual ~Delegate() {}
 
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const OVERRIDE {
-    CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
     // Only intercepts POST.
     if (!request->has_upload())
       return NULL;
 
     GURL url = request->url();
     if (url.has_query()) {
       GURL::Replacements replacements;
       replacements.ClearQuery();
       url = url.ReplaceComponents(replacements);
@@ skipping 34 matching lines @@
     }
 
     return NULL;
   }
 
   typedef std::map<GURL, URLRequestPostInterceptor*> InterceptorMap;
   InterceptorMap interceptors_;
 
   const std::string scheme_;
   const std::string hostname_;
+  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 URLRequestPostInterceptorFactory::URLRequestPostInterceptorFactory(
     const std::string& scheme,
-    const std::string& hostname)
+    const std::string& hostname,
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : scheme_(scheme),
       hostname_(hostname),
-      delegate_(new URLRequestPostInterceptor::Delegate(scheme, hostname)) {
-  BrowserThread::PostTask(
-      BrowserThread::IO,
+      io_task_runner_(io_task_runner),
+      delegate_(new URLRequestPostInterceptor::Delegate(scheme,
+                                                        hostname,
+                                                        io_task_runner)) {
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestPostInterceptor::Delegate::Register,
                  base::Unretained(delegate_)));
 }
 
 URLRequestPostInterceptorFactory::~URLRequestPostInterceptorFactory() {
-  BrowserThread::PostTask(
-      BrowserThread::IO,
+  io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestPostInterceptor::Delegate::Unregister,
                  base::Unretained(delegate_)));
 }
 
 URLRequestPostInterceptor* URLRequestPostInterceptorFactory::CreateInterceptor(
     const base::FilePath& filepath) {
   const GURL base_url(
       base::StringPrintf("%s://%s", scheme_.c_str(), hostname_.c_str()));
   GURL absolute_url(base_url.Resolve(filepath.MaybeAsASCII()));
   URLRequestPostInterceptor* interceptor(
-      new URLRequestPostInterceptor(absolute_url));
-  bool res = BrowserThread::PostTask(
-      BrowserThread::IO,
+      new URLRequestPostInterceptor(absolute_url, io_task_runner_));
+  bool res = io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&URLRequestPostInterceptor::Delegate::OnCreateInterceptor,
                  base::Unretained(delegate_),
                  base::Unretained(interceptor)));
   if (!res) {
     delete interceptor;
     return NULL;
   }
 
   return interceptor;
 }
 
 bool PartialMatch::Match(const std::string& actual) const {
   return actual.find(expected_) != std::string::npos;
 }
 
-InterceptorFactory::InterceptorFactory()
+InterceptorFactory::InterceptorFactory(
+    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner)
     : URLRequestPostInterceptorFactory(POST_INTERCEPT_SCHEME,
-                                       POST_INTERCEPT_HOSTNAME) {
+                                       POST_INTERCEPT_HOSTNAME,
+                                       io_task_runner) {
 }
 
 InterceptorFactory::~InterceptorFactory() {
 }
 
 URLRequestPostInterceptor* InterceptorFactory::CreateInterceptor() {
   return URLRequestPostInterceptorFactory::CreateInterceptor(
       base::FilePath::FromUTF8Unsafe(POST_INTERCEPT_PATH));
 }
 
 }  // namespace component_updater