Componentize component_updater: Replace content::BrowserThread usage with task runners

chrome/browser/component_updater/crx_downloader.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 "base/sequenced_task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "chrome/browser/component_updater/crx_downloader.h"

[Sorin Jianu, 2014/07/21 21:42:14]

crx_downloader.h must be the first header to include.

[tommycli, 2014/07/21 22:00:07]

Done.

 #include "chrome/browser/component_updater/url_fetcher_downloader.h"
-#include "content/public/browser/browser_thread.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/component_updater/background_downloader_win.h"
 #endif
 
-using content::BrowserThread;
-
 namespace component_updater {
 
 CrxDownloader::Result::Result()
     : error(0), downloaded_bytes(-1), total_bytes(-1) {
 }
 
 CrxDownloader::DownloadMetrics::DownloadMetrics()
     : downloader(kNone),
       error(0),
       downloaded_bytes(-1),
       total_bytes(-1),
       download_time_ms(0) {
 }
 
 // On Windows, the first downloader in the chain is a background downloader,
 // which uses the BITS service.
 CrxDownloader* CrxDownloader::Create(
     bool is_background_download,
     net::URLRequestContextGetter* context_getter,
-    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+    scoped_refptr<base::SequencedTaskRunner> url_fetcher_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> background_task_runner) {
   scoped_ptr<CrxDownloader> url_fetcher_downloader(
       new UrlFetcherDownloader(scoped_ptr<CrxDownloader>().Pass(),
                                context_getter,
-                               task_runner));
+                               url_fetcher_task_runner));
 #if defined(OS_WIN)
   if (is_background_download) {
     return new BackgroundDownloader(url_fetcher_downloader.Pass(),
                                     context_getter,
-                                    task_runner);
+                                    background_task_runner);
   }
 #endif
 
   return url_fetcher_downloader.release();
 }
 
 CrxDownloader::CrxDownloader(scoped_ptr<CrxDownloader> successor)
     : successor_(successor.Pass()) {

[Sorin Jianu, 2014/07/21 21:42:13]

Maybe keep the thread checker assert.

[tommycli, 2014/07/21 22:00:07]

Would always pass.

-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 CrxDownloader::~CrxDownloader() {
 }
 
 void CrxDownloader::set_progress_callback(
     const ProgressCallback& progress_callback) {
   progress_callback_ = progress_callback;
 }
 
@@ skipping 15 matching lines @@
 void CrxDownloader::StartDownloadFromUrl(
     const GURL& url,
     const DownloadCallback& download_callback) {
   std::vector<GURL> urls;
   urls.push_back(url);
   StartDownload(urls, download_callback);
 }
 
 void CrxDownloader::StartDownload(const std::vector<GURL>& urls,
                                   const DownloadCallback& download_callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   if (urls.empty()) {
     // Make a result and complete the download with a generic error for now.
     Result result;
     result.error = -1;
     download_callback.Run(result);
     return;
   }
 
   // If the urls are mutated while this downloader is active, then the
   // behavior is undefined in the sense that the outcome of the download could
   // be inconsistent for the list of urls. At any rate, the |current_url_| is
   // reset at this point, and the iterator will be valid in all conditions.
   urls_ = urls;
   current_url_ = urls_.begin();
   download_callback_ = download_callback;
 
   DoStartDownload(*current_url_);
 }
 
 void CrxDownloader::OnDownloadComplete(
     bool is_handled,
     const Result& result,
     const DownloadMetrics& download_metrics) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   download_metrics_.push_back(download_metrics);
 
   if (result.error) {
     // If an error has occured, in general try the next url if there is any,
     // then move on to the successor in the chain if there is any successor.
     // If this downloader has received a 5xx error for the current url,
     // as indicated by the |is_handled| flag, remove that url from the list of
     // urls so the url is never retried. In both cases, move on to the
     // next url.
@@ skipping 16 matching lines @@
     if (successor_ && !urls_.empty()) {
       successor_->StartDownload(urls_, download_callback_);
       return;
     }
   }
 
   download_callback_.Run(result);
 }
 
 void CrxDownloader::OnDownloadProgress(const Result& result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   if (progress_callback_.is_null())
     return;
 
   progress_callback_.Run(result);
 }
 
 }  // namespace component_updater