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 43 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();

[Sorin Jianu, 2015/02/07 02:20:35]

Thank you for moving the call so that the uninstall happens after the update of
the component. The idea here is that when we give out an update to a component,
we also expect to hear back from the the component update service, so we know if
the update succeeded or failed. Therefore, the update must be processed before
the uninstall in the case where the call to unregistered a component arrived
while the component was in the loop of being checked for updates.

[Bernhard Bauer, 2015/02/08 13:52:57]

Makes sense. Thanks for the explanation!

+
   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