Change NotifyAppList*() functions into observers on a ProfileKeyedService.

chrome/browser/ui/app_list/apps_model_builder.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/ui/app_list/apps_model_builder.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/extension_app_item.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/gfx/image/image_skia.h"
 
 using extensions::Extension;
+using extensions::ExtensionInstallingDetails;
 
 namespace {
 
 bool AppPrecedes(const ExtensionAppItem* app1, const ExtensionAppItem* app2) {
   const syncer::StringOrdinal& page1 = app1->GetPageOrdinal();
   const syncer::StringOrdinal& page2 = app2->GetPageOrdinal();
   if (page1.LessThan(page2))
     return true;
 
   if (page1.Equals(page2))
@@ skipping 14 matching lines @@
   extensions::ExtensionPrefs* extension_prefs =
       extensions::ExtensionSystem::Get(profile_)->extension_service()->
           extension_prefs();
 
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
       content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
       content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED,
       content::Source<ExtensionSorting>(extension_prefs->extension_sorting()));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_BEGIN,
+      content::Source<Profile>(profile_));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_PROGRESS,
+      content::Source<Profile>(profile_));
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_FAIL,
+      content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_APP_INSTALLED_TO_APPLIST,
       content::Source<Profile>(profile_));
 
   pref_change_registrar_.Init(extension_prefs->pref_service());
   pref_change_registrar_.Add(extensions::ExtensionPrefs::kExtensionsPref,
                              base::Bind(&AppsModelBuilder::ResortApps,
                                         base::Unretained(this)));
 
   model_->AddObserver(this);
 }
 
 AppsModelBuilder::~AppsModelBuilder() {
   model_->RemoveObserver(this);
 }
 
 void AppsModelBuilder::Build() {
   DCHECK(model_ && model_->item_count() == 0);
 
   PopulateApps();
   HighlightApp();
 }
 
-void AppsModelBuilder::OnBeginExtensionInstall(
-    const std::string& extension_id,
-    const std::string& extension_name,
-    const gfx::ImageSkia& installing_icon) {
-  InsertApp(new ExtensionAppItem(profile_,
-                                 extension_id,
-                                 controller_,
-                                 extension_name,
-                                 installing_icon));
-  highlight_app_id_ = extension_id;
-  HighlightApp();
-}
-
-void AppsModelBuilder::OnDownloadProgress(const std::string& extension_id,
-                                          int percent_downloaded) {
-  int i = FindApp(extension_id);
-  if (i == -1)
-    return;
-  GetAppAt(i)->SetPercentDownloaded(percent_downloaded);
-}
-
-void AppsModelBuilder::OnInstallFailure(const std::string& extension_id) {
-  int i = FindApp(extension_id);
-  if (i == -1)
-    return;
-  model_->DeleteAt(i);
-}
-
 void AppsModelBuilder::AddApps(const ExtensionSet* extensions, Apps* apps) {
   for (ExtensionSet::const_iterator app = extensions->begin();
        app != extensions->end(); ++app) {
     if ((*app)->ShouldDisplayInAppLauncher())
       apps->push_back(new ExtensionAppItem(profile_,
                                            (*app)->id(),
                                            controller_,
                                            "",
                                            gfx::ImageSkia()));
   }
@@ skipping 129 matching lines @@
       if (unload_info->reason == extension_misc::UNLOAD_REASON_UNINSTALL)
         model_->DeleteAt(index);
       else
         GetAppAt(index)->UpdateIcon();
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED: {
       ResortApps();
       break;
     }
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_BEGIN: {
+      ExtensionInstallingDetails* d =
+          content::Details<ExtensionInstallingDetails>(details).ptr();
+
+      InsertApp(new ExtensionAppItem(profile_,
+                                    d->extension_id,
+                                    controller_,
+                                    d->extension_name,
+                                    d->icon));
+      highlight_app_id_ = d->extension_id;
+      HighlightApp();
+    }
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_PROGRESS: {
+      std::pair<std::string, int>* complete_details =
+          content::Details<std::pair<std::string, int> >(details).ptr();
+      std::string& extension_id = complete_details->first;
+      int percent_downloaded = complete_details->second;
+      int i = FindApp(extension_id);
+      if (i == -1)
+        return;
+      GetAppAt(i)->SetPercentDownloaded(percent_downloaded);
+    }
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_FAIL: {
+      const std::string& extension_id =
+          *content::Details<std::string>(details).ptr();
+      int i = FindApp(extension_id);
+      if (i == -1)
+        return;
+      model_->DeleteAt(i);
+    }
     case chrome::NOTIFICATION_APP_INSTALLED_TO_APPLIST: {
       highlight_app_id_ = *content::Details<const std::string>(details).ptr();
       HighlightApp();
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void AppsModelBuilder::ListItemsAdded(size_t start, size_t count) {
 }
 
 void AppsModelBuilder::ListItemsRemoved(size_t start, size_t count) {
 }
 
 void AppsModelBuilder::ListItemMoved(size_t index, size_t target_index) {
   if (ignore_changes_)
     return;
 
   ExtensionAppItem* prev = target_index > 0 ? GetAppAt(target_index - 1) : NULL;
   ExtensionAppItem* next = target_index + 1 < model_->item_count() ?
       GetAppAt(target_index + 1) : NULL;
   GetAppAt(target_index)->Move(prev, next);
 }
 
 void AppsModelBuilder::ListItemsChanged(size_t start, size_t count) {
   NOTREACHED();
 }