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

chrome/browser/component_updater/background_downloader_win.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 "chrome/browser/component_updater/background_downloader_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 
 #include <functional>
 #include <iomanip>
 #include <vector>
 
 #include "base/file_util.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "chrome/browser/component_updater/component_updater_utils.h"
-#include "content/public/browser/browser_thread.h"
 #include "ui/base/win/atl_module.h"
 #include "url/gurl.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
-using content::BrowserThread;
 
 // The class BackgroundDownloader in this module is an adapter between
 // the CrxDownloader interface and the BITS service interfaces.
-// The interface exposed on the CrxDownloader code runs on the UI thread, while
-// the BITS specific code runs in a single threaded apartment on the FILE
-// thread.
+// The interface exposed on the CrxDownloader code runs on the main thread,
+// while the BITS specific code runs on a single thread task runner.

[blundell, 2014/07/15 08:45:20]

I would say something like "a separate thread passed in by the client".

[tommycli, 2014/07/15 18:58:25]

Done.

 // For every url to download, a BITS job is created, unless there is already
 // an existing job for that url, in which case, the downloader connects to it.
 // Once a job is associated with the url, the code looks for changes in the
 // BITS job state. The checks are triggered by a timer.
 // The BITS job contains just one file to download. There could only be one
 // download in progress at a time. If Chrome closes down before the download is
 // complete, the BITS job remains active and finishes in the background, without
 // any intervention. The job can be completed next time the code runs, if the
 // file is still needed, otherwise it will be cleaned up on a periodic basis.
 //
@@ skipping 339 matching lines @@
   }
 
   return S_OK;
 }
 
 }  // namespace
 
 BackgroundDownloader::BackgroundDownloader(
     scoped_ptr<CrxDownloader> successor,
     net::URLRequestContextGetter* context_getter,
-    scoped_refptr<base::SequencedTaskRunner> task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : CrxDownloader(successor.Pass()),
+      main_loop_(base::MessageLoopProxy::current()),
       context_getter_(context_getter),
       task_runner_(task_runner),
       is_completed_(false) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());

[blundell, 2014/07/15 08:45:20]

this DCHECK is meaningless I think as thread_checker_ has just been attached to
this thread in its initialization.

[tommycli, 2014/07/15 18:58:25]

Done.

 }
 
 BackgroundDownloader::~BackgroundDownloader() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   // The following objects have thread affinity and can't be destroyed on the
-  // UI thread. The resources managed by these objects are acquired at the
+  // main thread. The resources managed by these objects are acquired at the
   // beginning of a download and released at the end of the download. Most of
   // the time, when this destructor is called, these resources have been already
   // disposed by. Releasing the ownership here is a NOP. However, if the browser
   // is shutting down while a download is in progress, the timer is active and
   // the interface pointers are valid. Releasing the ownership means leaking
   // these objects and their associated resources.
   timer_.release();
   bits_manager_.Detach();
   job_.Detach();
 }
 
 void BackgroundDownloader::DoStartDownload(const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
+  task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &BackgroundDownloader::BeginDownload, base::Unretained(this), url));
 }
 
 // Called once when this class is asked to do a download. Creates or opens
 // an existing bits job, hooks up the notifications, and starts the timer.
 void BackgroundDownloader::BeginDownload(const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   DCHECK(!timer_);
 
   is_completed_ = false;
   download_start_time_ = base::Time::Now();
   job_stuck_begin_time_ = download_start_time_;
 
   HRESULT hr = QueueBitsJob(url);
   if (FAILED(hr)) {
     EndDownload(hr);
     return;
   }
 
   // A repeating timer retains the user task. This timer can be stopped and
   // reset multiple times.
   timer_.reset(new base::RepeatingTimer<BackgroundDownloader>);
   timer_->Start(FROM_HERE,
                 base::TimeDelta::FromSeconds(kJobPollingIntervalSec),
                 this,
                 &BackgroundDownloader::OnDownloading);
 }
 
 // Called any time the timer fires.
 void BackgroundDownloader::OnDownloading() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   DCHECK(job_);
 
   DCHECK(!is_completed_);
   if (is_completed_)
     return;
 
   BG_JOB_STATE job_state = BG_JOB_STATE_ERROR;
   HRESULT hr = job_->GetState(&job_state);
   if (FAILED(hr)) {
@@ skipping 35 matching lines @@
       break;
 
     default:
       break;
   }
 }
 
 // Completes the BITS download, picks up the file path of the response, and
 // notifies the CrxDownloader. The function should be called only once.
 void BackgroundDownloader::EndDownload(HRESULT error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   DCHECK(!is_completed_);
   is_completed_ = true;
 
   timer_.reset();
 
   const base::Time download_end_time(base::Time::Now());
   const base::TimeDelta download_time =
       download_end_time >= download_start_time_
           ? download_end_time - download_start_time_
@@ skipping 26 matching lines @@
   download_metrics.error = error_to_report;
   download_metrics.downloaded_bytes = downloaded_bytes;
   download_metrics.total_bytes = total_bytes;
   download_metrics.download_time_ms = download_time.InMilliseconds();
 
   Result result;
   result.error = error_to_report;
   result.response = response_;
   result.downloaded_bytes = downloaded_bytes;
   result.total_bytes = total_bytes;
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&BackgroundDownloader::OnDownloadComplete,
-                                     base::Unretained(this),
-                                     is_handled,
-                                     result,
-                                     download_metrics));
+  main_loop_->PostTask(FROM_HERE,
+                       base::Bind(&BackgroundDownloader::OnDownloadComplete,
+                                  base::Unretained(this),
+                                  is_handled,
+                                  result,
+                                  download_metrics));
 
-  // Once the task is posted to the the UI thread, this object may be deleted
+  // Once the task is posted to the the main thread, this object may be deleted
   // by its owner. It is not safe to access members of this object on the
-  // FILE thread from this point on. The timer is stopped and all BITS
+  // task runner from this point on. The timer is stopped and all BITS
   // interface pointers have been released.
 }
 
 // Called when the BITS job has been transferred successfully. Completes the
 // BITS job by removing it from the BITS queue and making the download
 // available to the caller.
 void BackgroundDownloader::OnStateTransferred() {
   EndDownload(CompleteJob());
 }
 
@@ skipping 42 matching lines @@
   int64 downloaded_bytes = -1;
   int64 total_bytes = -1;
   HRESULT hr = GetJobByteCount(job_, &downloaded_bytes, &total_bytes);
   if (FAILED(hr))
     return;
 
   Result result;
   result.downloaded_bytes = downloaded_bytes;
   result.total_bytes = total_bytes;
 
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(&BackgroundDownloader::OnDownloadProgress,
-                                     base::Unretained(this),
-                                     result));
+  main_loop_->PostTask(FROM_HERE,
+                       base::Bind(&BackgroundDownloader::OnDownloadProgress,
+                                  base::Unretained(this),
+                                  result));
 }
 
 // Called when the download was cancelled. Since the observer should have
 // been disconnected by now, this notification must not be seen.
 void BackgroundDownloader::OnStateCancelled() {
   EndDownload(E_UNEXPECTED);
 }
 
 // Called when the download was completed. Same as above.
 void BackgroundDownloader::OnStateAcknowledged() {
   EndDownload(E_UNEXPECTED);
 }
 
 // Creates or opens a job for the given url and queues it up. Tries to
 // install a job observer but continues on if an observer can't be set up.
 HRESULT BackgroundDownloader::QueueBitsJob(const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   HRESULT hr = S_OK;
   if (bits_manager_ == NULL) {
     hr = GetBitsManager(bits_manager_.Receive());
     if (FAILED(hr))
       return hr;
   }
 
   hr = CreateOrOpenJob(url);
   if (FAILED(hr))
@@ skipping 99 matching lines @@
   // must match as a job only contains one file.
   DCHECK(progress.Completed);
   DCHECK_EQ(progress.BytesTotal, progress.BytesTransferred);
 
   response_ = base::FilePath(local_name);
 
   return S_OK;
 }
 
 }  // namespace component_updater