Remove InstallTracker's extension load, unload observer

chrome/browser/ui/app_list/extension_app_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/extension_app_model_builder.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_ui_util.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
 #include "chrome/browser/ui/app_list/extension_app_item.h"
 #include "chrome/common/chrome_switches.h"
-#include "content/public/browser/notification_service.h"
 #include "extensions/browser/extension_prefs.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "ui/gfx/image/image_skia.h"
 
 using extensions::Extension;
 
 ExtensionAppModelBuilder::ExtensionAppModelBuilder(
     AppListControllerDelegate* controller)
     : service_(NULL),
       profile_(NULL),
       controller_(controller),
       model_(NULL),
       highlighted_app_pending_(false),
-      tracker_(NULL) {
+      tracker_(NULL),
+      extension_registry_observer_(this) {
 }
 
 ExtensionAppModelBuilder::~ExtensionAppModelBuilder() {
   OnShutdown();
   if (!service_)
     model_->top_level_item_list()->RemoveObserver(this);
 }
 
 void ExtensionAppModelBuilder::InitializeWithService(
     app_list::AppListSyncableService* service) {
@@ skipping 65 matching lines @@
   if (!item)
     return;
   item->SetPercentDownloaded(percent_downloaded);
 }
 
 void ExtensionAppModelBuilder::OnInstallFailure(
     const std::string& extension_id) {
   model_->DeleteItem(extension_id);
 }
 
-void ExtensionAppModelBuilder::OnExtensionLoaded(const Extension* extension) {
+void ExtensionAppModelBuilder::OnExtensionLoaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension) {
   if (!extensions::ui_util::ShouldDisplayInAppLauncher(extension, profile_))
     return;
 
   DVLOG(2) << service_ << ": OnExtensionLoaded: "
            << extension->id().substr(0, 8);
   ExtensionAppItem* existing_item = GetExtensionAppItem(extension->id());
   if (existing_item) {
     existing_item->Reload();
     if (service_)
       service_->UpdateItem(existing_item);
     return;
   }
 
   InsertApp(CreateAppItem(extension->id(),
                           "",
                           gfx::ImageSkia(),
                           extension->is_platform_app()));
   UpdateHighlight();
 }
 
-void ExtensionAppModelBuilder::OnExtensionUnloaded(const Extension* extension) {
+void ExtensionAppModelBuilder::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension,
+    extensions::UnloadedExtensionInfo::Reason reason) {
   ExtensionAppItem* item = GetExtensionAppItem(extension->id());
   if (!item)
     return;
   item->UpdateIcon();
 }
 
 void ExtensionAppModelBuilder::OnExtensionUninstalled(
-    const Extension* extension) {
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension) {
   if (service_) {
     DVLOG(2) << service_ << ": OnExtensionUninstalled: "
              << extension->id().substr(0, 8);
     service_->RemoveItem(extension->id());
     return;
   }
   model_->DeleteItem(extension->id());
 }
 
 void ExtensionAppModelBuilder::OnDisabledExtensionUpdated(
     const Extension* extension) {
   if (!extensions::ui_util::ShouldDisplayInAppLauncher(extension, profile_))
     return;
 
   ExtensionAppItem* existing_item = GetExtensionAppItem(extension->id());
   if (existing_item)
     existing_item->Reload();
 }
 
 void ExtensionAppModelBuilder::OnAppInstalledToAppList(
     const std::string& extension_id) {
   SetHighlightedApp(extension_id);
 }
 
 void ExtensionAppModelBuilder::OnShutdown() {

[not at google - send to devlin, 2014/05/30 23:22:17]

again strictly speaking you should be listening to the Registry's OnShutdown and
doing the same for that.

i'm wondering whether OnShutdown should actually take an ExtensionRegistry
instance, not a BrowserContext, to avoid any method overloading issues.

[limasdf, 2014/06/02 11:49:04]

Done. To avoid method overloading issue, I have renamed
ExtensionRegistryObserver::OnShutdown to OnExtensionShutdown.

[not at google - send to devlin, 2014/06/02 19:45:53]

OnExtensionShutdown isn't really right. It's not attached to a specific
extension. Overloading based on passing in an ExtensionREgistry will work just
fine.

   if (tracker_) {
     tracker_->RemoveObserver(this);
     tracker_ = NULL;
   }
 }
 
 scoped_ptr<ExtensionAppItem> ExtensionAppModelBuilder::CreateAppItem(
     const std::string& extension_id,
     const std::string& extension_name,
     const gfx::ImageSkia& installing_icon,
@@ skipping 11 matching lines @@
 void ExtensionAppModelBuilder::BuildModel() {
   DCHECK(!tracker_);
   tracker_ = controller_->GetInstallTrackerFor(profile_);
 
   PopulateApps();
   UpdateHighlight();
 
   // Start observing after model is built.
   if (tracker_)
     tracker_->AddObserver(this);
+
+  extension_registry_observer_.Add(
+      extensions::ExtensionRegistry::Get(profile_));
 }
 
 void ExtensionAppModelBuilder::PopulateApps() {
   extensions::ExtensionSet extensions;
   controller_->GetApps(profile_, &extensions);
 
   for (extensions::ExtensionSet::const_iterator app = extensions.begin();
        app != extensions.end(); ++app) {
     if (!extensions::ui_util::ShouldDisplayInAppLauncher(*app, profile_))
       continue;
@@ skipping 71 matching lines @@
     app_list::AppListItem* item = item_list->item_at(idx + 1);
     if (item->GetItemType() == ExtensionAppItem::kItemType) {
       next = static_cast<ExtensionAppItem*>(item);
       break;
     }
   }
   // item->Move will call set_position, overriding the item's position.
   if (prev || next)
     static_cast<ExtensionAppItem*>(item)->Move(prev, next);
 }