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

chrome/browser/component_updater/component_updater_service.cc

 // Copyright 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 "chrome/browser/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_unpacker.h"
 #include "chrome/browser/component_updater/component_updater_configurator.h"
 #include "chrome/browser/component_updater/component_updater_ping_manager.h"
 #include "chrome/browser/component_updater/component_updater_utils.h"
 #include "chrome/browser/component_updater/crx_downloader.h"
 #include "chrome/browser/component_updater/crx_update_item.h"
 #include "chrome/browser/component_updater/update_checker.h"
 #include "chrome/browser/component_updater/update_response.h"
@@ skipping 100 matching lines @@
 //////////////////////////////////////////////////////////////////////////////
 // The one and only implementation of the ComponentUpdateService interface. In
 // charge of running the show. The main method is ProcessPendingItems() which
 // is called periodically to do the upgrades/installs or the update checks.
 // An important consideration here is to be as "low impact" as we can to the
 // rest of the browser, so even if we have many components registered and
 // eligible for update, we only do one thing at a time with pauses in between
 // the tasks. Also when we do network requests there is only one |url_fetcher_|
 // in flight at a time.
 // There are no locks in this code, the main structure |work_items_| is mutated
-// only from the UI thread. The unpack and installation is done in a blocking
+// only from the main thread. The unpack and installation is done in a blocking
 // pool thread. The network requests are done in the IO thread or in the file
 // thread.
 class CrxUpdateService : public ComponentUpdateService, public OnDemandUpdater {
  public:
   explicit CrxUpdateService(Configurator* config);
   virtual ~CrxUpdateService();
 
   // Overrides for ComponentUpdateService.
   virtual void AddObserver(Observer* observer) OVERRIDE;
   virtual void RemoveObserver(Observer* observer) OVERRIDE;
   virtual Status Start() OVERRIDE;
   virtual Status Stop() OVERRIDE;
   virtual Status RegisterComponent(const CrxComponent& component) OVERRIDE;
   virtual std::vector<std::string> GetComponentIDs() const OVERRIDE;
   virtual bool GetComponentDetails(const std::string& component_id,
                                    CrxUpdateItem* item) const OVERRIDE;
   virtual OnDemandUpdater& GetOnDemandUpdater() OVERRIDE;
+  virtual scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner()
+      OVERRIDE;
 
   // Overrides for OnDemandUpdater.
   virtual content::ResourceThrottle* GetOnDemandResourceThrottle(
       net::URLRequest* request,
       const std::string& crx_id) OVERRIDE;
   virtual Status OnDemandUpdate(const std::string& component_id) OVERRIDE;
 
   // Context for a crx download url request.
   struct CRXContext {
     ComponentInstaller* installer;
@@ skipping 83 matching lines @@
   scoped_refptr<ComponentUnpacker> unpacker_;
 
   scoped_ptr<CrxDownloader> crx_downloader_;
 
   // A collection of every work item.
   typedef std::vector<CrxUpdateItem*> UpdateItems;
   UpdateItems work_items_;
 
   base::OneShotTimer<CrxUpdateService> timer_;
 
+  base::ThreadChecker thread_checker_;
+
   scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
   bool running_;
 
   ObserverList<Observer> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(CrxUpdateService);
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 CrxUpdateService::CrxUpdateService(Configurator* config)
     : config_(config),
       ping_manager_(new PingManager(*config)),
-      blocking_task_runner_(
-          BrowserThread::GetBlockingPool()->
-              GetSequencedTaskRunnerWithShutdownBehavior(
-                  BrowserThread::GetBlockingPool()->GetSequenceToken(),
-                  base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)),
+      blocking_task_runner_(config->GetSequencedTaskRunner()),
       running_(false) {
 }
 
 CrxUpdateService::~CrxUpdateService() {
-  // Because we are a singleton, at this point only the UI thread should be
+  // Because we are a singleton, at this point only the main thread should be
   // alive, this simplifies the management of the work that could be in
   // flight in other threads.
   Stop();
   STLDeleteElements(&work_items_);
 }
 
 void CrxUpdateService::AddObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.AddObserver(observer);
 }
 
 void CrxUpdateService::RemoveObserver(Observer* observer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   observer_list_.RemoveObserver(observer);
 }
 
 ComponentUpdateService::Status CrxUpdateService::Start() {
   // Note that RegisterComponent will call Start() when the first
   // component is registered, so it can be called twice. This way
   // we avoid scheduling the timer if there is no work to do.
   VLOG(1) << "CrxUpdateService starting up";
   running_ = true;
   if (work_items_.empty())
@@ skipping 31 matching lines @@
 
 // This function sets the timer which will call ProcessPendingItems() or
 // ProcessRequestedItem() if there is an on_demand item.  There
 // are three kinds of waits:
 //  - a short delay, when there is immediate work to be done.
 //  - a medium delay, when there are updates to be applied within the current
 //    update cycle, or there are components that are still unchecked.
 //  - a long delay when a full check/update cycle has completed for all
 //    components.
 void CrxUpdateService::ScheduleNextRun(StepDelayInterval step_delay) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!update_checker_);
   CHECK(!timer_.IsRunning());
   // It could be the case that Stop() had been called while a url request
   // or unpacking was in flight, if so we arrive here but |running_| is
   // false. In that case do not loop again.
   if (!running_)
     return;
 
   // Keep the delay short if in the middle of an update (step_delay),
   // or there are new requested_work_items_ that have not been processed yet.
@@ skipping 25 matching lines @@
   VLOG(1) << "Scheduling next run to occur in " << delay_seconds << " seconds";
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromSeconds(delay_seconds),
                this,
                &CrxUpdateService::ProcessPendingItems);
 }
 
 // Given a extension-like component id, find the associated component.
 CrxUpdateItem* CrxUpdateService::FindUpdateItemById(
     const std::string& id) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   CrxUpdateItem::FindById finder(id);
   UpdateItems::const_iterator it =
       std::find_if(work_items_.begin(), work_items_.end(), finder);
   return it != work_items_.end() ? *it : NULL;
 }
 
 // Changes a component's status, clearing on_demand and firing notifications as
 // necessary. By convention, this is the only function that can change a
 // CrxUpdateItem's |status|.
 // TODO(waffles): Do we want to add DCHECKS for valid state transitions here?
 void CrxUpdateService::ChangeItemState(CrxUpdateItem* item,
                                        CrxUpdateItem::Status to) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (to == CrxUpdateItem::kNoUpdate || to == CrxUpdateItem::kUpdated ||
       to == CrxUpdateItem::kUpToDate) {
     item->on_demand = false;
   }
 
   item->status = to;
 
   switch (to) {
     case CrxUpdateItem::kCanUpdate:
       NotifyObservers(Observer::COMPONENT_UPDATE_FOUND, item->id);
@@ skipping 22 matching lines @@
   if ((to == CrxUpdateItem::kUpdated) || (to == CrxUpdateItem::kUpToDate) ||
       (to == CrxUpdateItem::kNoUpdate)) {
     UnblockandReapAllThrottles(&item->throttles);
   }
 }
 
 // Changes all the components in |work_items_| that have |from| status to
 // |to| status and returns how many have been changed.
 size_t CrxUpdateService::ChangeItemStatus(CrxUpdateItem::Status from,
                                           CrxUpdateItem::Status to) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   size_t count = 0;
   for (UpdateItems::iterator it = work_items_.begin();
        it != work_items_.end();
        ++it) {
     CrxUpdateItem* item = *it;
     if (item->status == from) {
       ChangeItemState(item, to);
       ++count;
     }
   }
   return count;
 }
 
 // Adds a component to be checked for upgrades. If the component exists it
 // it will be replaced and the return code is kReplaced.
 ComponentUpdateService::Status CrxUpdateService::RegisterComponent(
     const CrxComponent& component) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   if (component.pk_hash.empty() || !component.version.IsValid() ||
       !component.installer)
     return kError;
 
   std::string id(GetCrxComponentID(component));
   CrxUpdateItem* uit = FindUpdateItemById(id);
   if (uit) {
     uit->component = component;
     return kReplaced;
   }
@@ skipping 18 matching lines @@
                      base::TimeDelta::FromSeconds(config_->InitialDelay()),
                      this,
                      &CrxUpdateService::ProcessPendingItems);
     }
   }
 
   return kOk;
 }
 
 std::vector<std::string> CrxUpdateService::GetComponentIDs() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<std::string> component_ids;
   for (UpdateItems::const_iterator it = work_items_.begin();
        it != work_items_.end();
        ++it) {
     const CrxUpdateItem* item = *it;
     component_ids.push_back(item->id);
   }
   return component_ids;
 }
 
 bool CrxUpdateService::GetComponentDetails(const std::string& component_id,
                                            CrxUpdateItem* item) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   const CrxUpdateItem* crx_update_item(FindUpdateItemById(component_id));
   if (crx_update_item)
     *item = *crx_update_item;
   return crx_update_item != NULL;
 }
 
 OnDemandUpdater& CrxUpdateService::GetOnDemandUpdater() {
   return *this;
 }
 
+scoped_refptr<base::SequencedTaskRunner>
+CrxUpdateService::GetSequencedTaskRunner() {
+  return config_->GetSequencedTaskRunner();
+}
+
 // This is the main loop of the component updater. It updates one component
 // at a time if updates are available. Otherwise, it does an update check or
 // takes a long sleep until the loop runs again.
 void CrxUpdateService::ProcessPendingItems() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   CrxUpdateItem* ready_upgrade = FindReadyComponent();
   if (ready_upgrade) {
     UpdateComponent(ready_upgrade);
     return;
   }
 
   if (!CheckForUpdates())
     ScheduleNextRun(kStepDelayLong);
 }
@@ skipping 99 matching lines @@
     allow_background_download = workitem->component.allow_background_download;
     urls = &workitem->crx_urls;
     ChangeItemState(workitem, CrxUpdateItem::kDownloading);
   }
 
   // On demand component updates are always downloaded in foreground.
   const bool is_background_download = !workitem->on_demand &&
                                       allow_background_download &&
                                       config_->UseBackgroundDownloader();
 
-  crx_downloader_.reset(CrxDownloader::Create(is_background_download,
-                                              config_->RequestContext(),
-                                              blocking_task_runner_));
+  crx_downloader_.reset(
+      CrxDownloader::Create(is_background_download,
+                            config_->RequestContext(),
+                            blocking_task_runner_,
+                            config_->GetSingleThreadTaskRunner()));
   crx_downloader_->set_progress_callback(
       base::Bind(&CrxUpdateService::DownloadProgress,
                  base::Unretained(this),
                  crx_context->id));
   crx_downloader_->StartDownload(*urls,
                                  base::Bind(&CrxUpdateService::DownloadComplete,
                                             base::Unretained(this),
                                             base::Passed(&crx_context)));
 }
 
 void CrxUpdateService::UpdateCheckComplete(
     int error,
     const std::string& error_message,
     const UpdateResponse::Results& results) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   update_checker_.reset();
   if (!error)
     OnUpdateCheckSucceeded(results);
   else
     OnUpdateCheckFailed(error, error_message);
 }
 
 // Handles a valid Omaha update check response by matching the results with
 // the registered components which were checked for updates.
 // If updates are found, prepare the components for the actual version upgrade.
 // One of these components will be drafted for the upgrade next time
 // ProcessPendingItems is called.
 void CrxUpdateService::OnUpdateCheckSucceeded(
     const UpdateResponse::Results& results) {
   size_t num_updates_pending = 0;
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Update check succeeded.";
   std::vector<UpdateResponse::Result>::const_iterator it;
   for (it = results.list.begin(); it != results.list.end(); ++it) {
     CrxUpdateItem* crx = FindUpdateItemById(it->extension_id);
     if (!crx)
       continue;
 
     if (crx->status != CrxUpdateItem::kChecking) {
       NOTREACHED();
       continue;  // Not updating this component now.
@@ skipping 59 matching lines @@
   // considered up to date.
   ChangeItemStatus(CrxUpdateItem::kChecking, CrxUpdateItem::kUpToDate);
 
   // If there are updates pending we do a short wait, otherwise we take
   // a longer delay until we check the components again.
   ScheduleNextRun(num_updates_pending > 0 ? kStepDelayShort : kStepDelayLong);
 }
 
 void CrxUpdateService::OnUpdateCheckFailed(int error,
                                            const std::string& error_message) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(error);
   size_t count =
       ChangeItemStatus(CrxUpdateItem::kChecking, CrxUpdateItem::kNoUpdate);
   DCHECK_GT(count, 0ul);
   VLOG(1) << "Update check failed.";
   ScheduleNextRun(kStepDelayLong);
 }
 
 // Called when progress is being made downloading a CRX. The progress may
 // not monotonically increase due to how the CRX downloader switches between
 // different downloaders and fallback urls.
 void CrxUpdateService::DownloadProgress(
     const std::string& component_id,
     const CrxDownloader::Result& download_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   NotifyObservers(Observer::COMPONENT_UPDATE_DOWNLOADING, component_id);
 }
 
 // Called when the CRX package has been downloaded to a temporary location.
 // Here we fire the notifications and schedule the component-specific installer
 // to be called in the file thread.
 void CrxUpdateService::DownloadComplete(
     scoped_ptr<CRXContext> crx_context,
     const CrxDownloader::Result& download_result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   CrxUpdateItem* crx = FindUpdateItemById(crx_context->id);
   DCHECK(crx->status == CrxUpdateItem::kDownloadingDiff ||
          crx->status == CrxUpdateItem::kDownloading);
 
   AppendDownloadMetrics(crx_downloader_->download_metrics(),
                         &crx->download_metrics);
 
   crx_downloader_.reset();
 
@@ skipping 80 matching lines @@
   // Reset the unpacker last, otherwise we free our own arguments.
   unpacker_ = NULL;
 }
 
 // Installation has been completed. Adjust the component status and
 // schedule the next check. Schedule a short delay before trying the full
 // update when the differential update failed.
 void CrxUpdateService::DoneInstalling(const std::string& component_id,
                                       ComponentUnpacker::Error error,
                                       int extra_code) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
 
   ErrorCategory error_category = kErrorNone;
   switch (error) {
     case ComponentUnpacker::kNone:
       break;
     case ComponentUnpacker::kInstallerError:
       error_category = kInstallError;
       break;
     default:
       error_category = kUnpackError;
@@ skipping 27 matching lines @@
   }
 
   ping_manager_->OnUpdateComplete(item);
 
   // Move on to the next update, if there is one available.
   ScheduleNextRun(kStepDelayMedium);
 }
 
 void CrxUpdateService::NotifyObservers(Observer::Events event,
                                        const std::string& id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(Observer, observer_list_, OnEvent(event, id));
 }
 
 content::ResourceThrottle* CrxUpdateService::GetOnDemandResourceThrottle(
     net::URLRequest* request,
     const std::string& crx_id) {
   // We give the raw pointer to the caller, who will delete it at will
   // and we keep for ourselves a weak pointer to it so we can post tasks
   // from the UI thread without having to track lifetime directly.
   CUResourceThrottle* rt = new CUResourceThrottle(request);
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&CrxUpdateService::OnNewResourceThrottle,
                                      base::Unretained(this),
                                      rt->AsWeakPtr(),
                                      crx_id));
   return rt;
 }
 
 void CrxUpdateService::OnNewResourceThrottle(
     base::WeakPtr<CUResourceThrottle> rt,
     const std::string& crx_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(thread_checker_.CalledOnValidThread());
   // Check if we can on-demand update, else unblock the request anyway.
   CrxUpdateItem* item = FindUpdateItemById(crx_id);
   Status status = OnDemandUpdateWithCooldown(item);
   if (status == kOk || status == kInProgress) {
     item->throttles.push_back(rt);
     return;
   }
   UnblockResourceThrottle(rt);
 }
 
@@ skipping 110 matching lines @@
 }
 
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }
 
 }  // namespace component_updater