Add NOTIFICATION_EXTENSION_REMOVED for Extensions removed from ExtensionService.

chrome/browser/extensions/extension_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/strings/string16.h"
 #include "chrome/browser/extensions/app_sync_bundle.h"
 #include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/extension_function_histogram_value.h"
 #include "chrome/browser/extensions/extension_icon_manager.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_sync_bundle.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
@@ skipping 100 matching lines @@
   virtual base::SequencedTaskRunner* GetFileTaskRunner() = 0;
 };
 
 // Manages installed and running Chromium extensions.
 class ExtensionService
     : public ExtensionServiceInterface,
       public extensions::ExternalProviderInterface::VisitorInterface,
       public content::NotificationObserver,
       public extensions::Blacklist::Observer {
  public:
+  class DisabledExtensionObserver {
+   public:
+    // Called when an extension is removed from the disabled extensions list.
+    // |was_enabled| is true if it was enabled, false if it was blacklisted
+    // or uninstalled.
+    virtual void OnDisabledExtensionRemoved(

[Matt Perry, 2013/08/01 00:37:33]

This seems oddly specific. I think it should be split into 2 notifications:
- EXTENSION_ENABLED (or _LOADED would work, too)
- EXTENSION_DELETED
(or Observer methods if you prefer that. But then I would add the methods to
InstallObserver
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...
)

[Yoyo Zhou, 2013/08/01 00:46:40]

To be clear, there are paths which result in an Extension being destroyed
without it being enabled or uninstalled (I think upgrade might be one of them).
We're actually interested in knowing whenever it's not disabled anymore. For
that we could bring back the EXTENSION_UNLOADED_DISABLED notification, but in
general I thought we were moving away from notifications.

So would you prefer this to be two methods, OnDisabledExtensionEnabled and
OnDisabledExtensionDeleted?

InstallObserver doesn't really look like a good fit. Too many pure virtual
methods we don't care about.

+        const extensions::Extension* extension,
+        bool was_enabled) = 0;
+  };
+
   // If auto-updates are turned on, default to running every 5 hours.
   static const int kDefaultUpdateFrequencySeconds = 60 * 60 * 5;
 
   // The name of the directory inside the profile where per-app local settings
   // are stored.
   static const char kLocalAppSettingsDirectoryName[];
 
   // The name of the directory inside the profile where per-extension local
   // settings are stored.
   static const char kLocalExtensionSettingsDirectoryName[];
@@ skipping 530 matching lines @@
     browser_terminating_ = value;
   }
 
   // By default ExtensionService will wait with installing an updated extension
   // until the extension is idle. Tests might not like this behavior, so you can
   // disable it with this method.
   void set_install_updates_when_idle_for_test(bool value) {
     install_updates_when_idle_ = value;
   }
 
+  // Adds/Removes disabled extension observers.
+  void AddDisabledExtensionObserver(DisabledExtensionObserver* observer);
+  void RemoveDisabledExtensionObserver(DisabledExtensionObserver* observer);
+
   // Adds/Removes update observers.
   void AddUpdateObserver(extensions::UpdateObserver* observer);
   void RemoveUpdateObserver(extensions::UpdateObserver* observer);
 
   // |flare| provides a StartSyncFlare to the SyncableService. See
   // sync_start_util for more.
   void SetSyncStartFlare(const syncer::SyncableService::StartSyncFlare& flare);
 
  private:
   // Contains Extension data that can change during the life of the process,
@@ skipping 244 matching lines @@
 
   scoped_ptr<ExtensionErrorUI> extension_error_ui_;
   // Sequenced task runner for extension related file operations.
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
 #if defined(ENABLE_EXTENSIONS)
   scoped_ptr<extensions::ExtensionActionStorageManager>
       extension_action_storage_manager_;
 #endif
 
+  ObserverList<DisabledExtensionObserver, true> disabled_extension_observers_;
   ObserverList<extensions::UpdateObserver, true> update_observers_;
 
   // Run()ning tells sync to try and start soon, because syncable changes
   // have started happening. It will cause sync to call us back
   // asynchronously via MergeDataAndStartSyncing as soon as possible.
   syncer::SyncableService::StartSyncFlare flare_;
 
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsWithUnlimtedStorage);
   FRIEND_TEST_ALL_PREFIXES(ExtensionServiceTest,
                            InstallAppsAndCheckStorageProtection);
   DISALLOW_COPY_AND_ASSIGN(ExtensionService);
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_SERVICE_H_