Add support for uninstalling components and use it in SupervisedUserWhitelistInstaller.

components/component_updater/component_updater_service.cc

 // Copyright 2014 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/component_updater_service.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 82 matching lines @@
  public:
   explicit CrxUpdateService(Configurator* config);
   ~CrxUpdateService() override;
 
   // Overrides for ComponentUpdateService.
   void AddObserver(Observer* observer) override;
   void RemoveObserver(Observer* observer) override;
   Status Start() override;
   Status Stop() override;
   Status RegisterComponent(const CrxComponent& component) override;
+  Status UnregisterComponent(const std::string& crx_id) override;
   std::vector<std::string> GetComponentIDs() const override;
   OnDemandUpdater& GetOnDemandUpdater() override;
   void MaybeThrottle(const std::string& crx_id,
                      const base::Closure& callback) override;
   scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() override;
 
   // Context for a crx download url request.
   struct CRXContext {
     scoped_refptr<ComponentInstaller> installer;
     std::vector<uint8_t> pk_hash;
@@ skipping 34 matching lines @@
                         const CrxDownloader::Result& download_result);
 
   void DownloadComplete(scoped_ptr<CRXContext> crx_context,
                         const CrxDownloader::Result& download_result);
 
   Status OnDemandUpdateInternal(CrxUpdateItem* item);
   Status OnDemandUpdateWithCooldown(CrxUpdateItem* item);
 
   void ProcessPendingItems();
 
+  // Uninstall and remove all unregistered work items.
+  void UninstallUnregisteredItems();
+
   // Find a component that is ready to update.
   CrxUpdateItem* FindReadyComponent() const;
 
   // Prepares the components for an update check and initiates the request.
   // Returns true if an update check request has been made. Returns false if
   // no update check was needed or an error occured.
   bool CheckForUpdates();
 
   void UpdateComponent(CrxUpdateItem* workitem);
 
@@ skipping 258 matching lines @@
     const CrxComponent& component) {
   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;
+    uit->unregistered = false;
     return kReplaced;
   }
 
   uit = new CrxUpdateItem;
   uit->id.swap(id);
   uit->component = component;
 
   work_items_.push_back(uit);
 
   // If this is the first component registered we call Start to
   // schedule the first timer. Otherwise, reset the timer to trigger another
   // pass over the work items, if the component updater is sleeping, fact
   // indicated by a running timer. If the timer is not running, it means that
   // the service is busy updating something, and in that case, this component
   // will be picked up at the next pass.
   if (running_) {
     if (work_items_.size() == 1) {
       Start();
     } else if (timer_.IsRunning()) {
         timer_.Start(FROM_HERE,
                      base::TimeDelta::FromSeconds(config_->InitialDelay()),
                      this,
                      &CrxUpdateService::ProcessPendingItems);
     }
   }
 
   return kOk;
 }
 
+ComponentUpdateService::Status CrxUpdateService::UnregisterComponent(
+    const std::string& crx_id) {
+  auto it = std::find_if(work_items_.begin(), work_items_.end(),
+                         CrxUpdateItem::FindById(crx_id));
+  if (it == work_items_.end())
+    return kError;
+
+  (*it)->unregistered = true;
+
+  ScheduleNextRun(kStepDelayShort);
+  return kOk;
+}
+
 std::vector<std::string> CrxUpdateService::GetComponentIDs() const {
   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;
@@ skipping 11 matching lines @@
   Status status = OnDemandUpdateWithCooldown(item);
   if (status == kOk || status == kInProgress) {
     item->ready_callbacks.push_back(callback);
     return;
   }
   callback.Run();
 }
 
 scoped_refptr<base::SequencedTaskRunner>
 CrxUpdateService::GetSequencedTaskRunner() {
-  return config_->GetSequencedTaskRunner();
+  return blocking_task_runner_;

[Bernhard Bauer, 2015/02/08 23:20:40]

I had to make this change because of failing tests.
config_->GetSequencedTaskRunner() returns a different task runner every time it
is called (because it gets a new sequence token), which meant that the default
component installer was running on a different thread than what it expected.

 }
 
 bool CrxUpdateService::GetComponentDetails(const std::string& component_id,
                                            CrxUpdateItem* item) const {
   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;
 }
@@ skipping 11 matching lines @@
 // takes a long sleep until the loop runs again.
 void CrxUpdateService::ProcessPendingItems() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CrxUpdateItem* ready_upgrade = FindReadyComponent();
   if (ready_upgrade) {
     UpdateComponent(ready_upgrade);
     return;
   }
 
+  UninstallUnregisteredItems();
+
   if (!CheckForUpdates())
     ScheduleNextRun(kStepDelayLong);
 }
 
+void CrxUpdateService::UninstallUnregisteredItems() {
+  std::vector<CrxUpdateItem*> new_work_items;
+  for (CrxUpdateItem* item : work_items_) {
+    scoped_ptr<CrxUpdateItem> owned_item(item);
+    if (owned_item->unregistered) {
+      const bool success = owned_item->component.installer->Uninstall();
+      DCHECK(success);
+    } else {
+      new_work_items.push_back(owned_item.release());
+    }
+  }
+  new_work_items.swap(work_items_);
+}
+
 CrxUpdateItem* CrxUpdateService::FindReadyComponent() const {
   class Helper {
    public:
     static bool IsReadyOnDemand(CrxUpdateItem* item) {
       return item->on_demand && IsReady(item);
     }
     static bool IsReady(CrxUpdateItem* item) {
       return item->status == CrxUpdateItem::kCanUpdate;
     }
   };
@@ skipping 233 matching lines @@
 
 // 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(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();
 
   if (download_result.error) {
     if (crx->status == CrxUpdateItem::kDownloadingDiff) {
@@ skipping 94 matching lines @@
       error_category = kInstallError;
       break;
     default:
       error_category = kUnpackError;
       break;
   }
 
   const bool is_success = error == ComponentUnpacker::kNone;
 
   CrxUpdateItem* item = FindUpdateItemById(component_id);
+
   if (item->status == CrxUpdateItem::kUpdatingDiff && !is_success) {
     item->diff_error_category = error_category;
     item->diff_error_code = error;
     item->diff_extra_code1 = extra_code;
     item->diff_update_failed = true;
     size_t count = ChangeItemStatus(CrxUpdateItem::kUpdatingDiff,
                                     CrxUpdateItem::kCanUpdate);
     DCHECK_EQ(count, 1ul);
     ScheduleNextRun(kStepDelayShort);
     return;
@@ skipping 94 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