First cut at the component observer.

chrome/browser/component_updater/component_updater_service.cc

 // Copyright (c) 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>
 
@@ skipping 201 matching lines @@
       extra_code1(0),
       diff_error_category(0),
       diff_error_code(0),
       diff_extra_code1(0) {
 }
 
 CrxUpdateItem::~CrxUpdateItem() {
 }
 
 CrxComponent::CrxComponent()
-    : installer(NULL) {
+    : installer(NULL),
+      observer(NULL) {
 }
 
 CrxComponent::~CrxComponent() {
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // 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
@@ skipping 100 matching lines @@
 
   void DoneInstalling(const std::string& component_id,
                       ComponentUnpacker::Error error,
                       int extended_error);
 
   size_t ChangeItemStatus(CrxUpdateItem::Status from,
                           CrxUpdateItem::Status to);
 
   CrxUpdateItem* FindUpdateItemById(const std::string& id);
 
+  void NotifyComponentObservers(ComponentObserver::Events event,
+                                int extra) const;
+
   scoped_ptr<ComponentUpdateService::Configurator> config_;
 
   scoped_ptr<ComponentPatcher> component_patcher_;
 
   scoped_ptr<net::URLFetcher> url_fetcher_;
 
   scoped_ptr<component_updater::PingManager> ping_manager_;
 
   // A collection of every work item.
   typedef std::vector<CrxUpdateItem*> UpdateItems;
@@ skipping 32 matching lines @@
  }
 
 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.
   running_ = true;
   if (work_items_.empty())
     return kOk;
 
+  NotifyComponentObservers(ComponentObserver::COMPONENT_UPDATER_STARTED, 0);
+
   content::NotificationService::current()->Notify(
     chrome::NOTIFICATION_COMPONENT_UPDATER_STARTED,
     content::Source<ComponentUpdateService>(this),
     content::NotificationService::NoDetails());
 
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(config_->InitialDelay()),
                this, &CrxUpdateService::ProcessPendingItems);
   return kOk;
 }
 
@@ skipping 19 matching lines @@
   // 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.
   int64 delay = (step_delay || requested_work_items_.size() > 0)
       ? config_->StepDelay() : config_->NextCheckDelay();
 
   if (!step_delay) {
+    NotifyComponentObservers(ComponentObserver::COMPONENT_UPDATER_SLEEPING, 0);
+
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATER_SLEEPING,
         content::Source<ComponentUpdateService>(this),
         content::NotificationService::NoDetails());
     // Zero is only used for unit tests.
     if (0 == delay)
       return;
   }
 
   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(delay),
@@ skipping 328 matching lines @@
     }
     // All test passed. Queue an upgrade for this component and fire the
     // notifications.
     crx->crx_url = it->crx_url;
     crx->diff_crx_url = it->diff_crx_url;
     crx->status = CrxUpdateItem::kCanUpdate;
     crx->next_version = Version(it->version);
     crx->next_fp = it->package_fingerprint;
     ++update_pending;
 
+    if (crx->component.observer) {
+      crx->component.observer->OnEvent(
+          ComponentObserver::COMPONENT_UPDATE_FOUND, 0);
+    }
+
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_FOUND,
         content::Source<std::string>(&crx->id),
         content::NotificationService::NoDetails());
   }
 
   // All the components that are not mentioned in the manifest we
   // consider them up to date.
   ChangeItemStatus(CrxUpdateItem::kChecking, CrxUpdateItem::kUpToDate);
 
@@ skipping 56 matching lines @@
       count = ChangeItemStatus(CrxUpdateItem::kDownloadingDiff,
                                CrxUpdateItem::kUpdatingDiff);
     } else {
       count = ChangeItemStatus(CrxUpdateItem::kDownloading,
                                CrxUpdateItem::kUpdating);
     }
     DCHECK_EQ(count, 1ul);
 
     url_fetcher_.reset();
 
+    if (crx->component.observer) {
+      crx->component.observer->OnEvent(
+          ComponentObserver::COMPONENT_UPDATE_READY, 0);
+    }
+
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COMPONENT_UPDATE_READY,
         content::Source<std::string>(&context->id),
         content::NotificationService::NoDetails());
 
     // Why unretained? See comment at top of file.
     BrowserThread::PostDelayedTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&CrxUpdateService::Install,
@@ skipping 73 matching lines @@
     item->error_category = error_category;
     item->error_code = error;
     item->extra_code1 = extra_code;
   }
 
   ping_manager_->OnUpdateComplete(item);
 
   ScheduleNextRun(false);
 }
 
+void CrxUpdateService::NotifyComponentObservers(
+    ComponentObserver::Events event, int extra) const {
+  for (UpdateItems::const_iterator it = work_items_.begin();
+       it != work_items_.end(); ++it) {
+    ComponentObserver* observer = (*it)->component.observer;
+    if (observer)
+      observer->OnEvent(event, 0);
+  }
+}
+
 // The component update factory. Using the component updater as a singleton
 // is the job of the browser process.
 ComponentUpdateService* ComponentUpdateServiceFactory(
     ComponentUpdateService::Configurator* config) {
   DCHECK(config);
   return new CrxUpdateService(config);
 }