Use ExtensionRegistryObserver instead of deprecated extension notification from c/b/extension

chrome/browser/extensions/api/storage/managed_value_store_cache.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/extensions/api/storage/managed_value_store_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
-#include "chrome/browser/chrome_notification_types.h"
+#include "base/scoped_observer.h"
 #include "chrome/browser/extensions/api/storage/policy_value_store.h"
 #include "chrome/browser/policy/profile_policy_connector.h"
 #include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/policy/schema_registry_service.h"
 #include "chrome/browser/policy/schema_registry_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/storage/storage_schema_manifest_handler.h"
 #include "components/policy/core/common/policy_namespace.h"
 #include "components/policy/core/common/schema.h"
 #include "components/policy/core/common/schema_map.h"
 #include "components/policy/core/common/schema_registry.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
-#include "content/public/browser/notification_source.h"
 #include "extensions/browser/api/storage/settings_storage_factory.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/value_store/value_store_change.h"
 #include "extensions/common/api/storage.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/one_shot_event.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace extensions {
+class ExtensionRegistry;
 
 namespace storage = core_api::storage;
 
 namespace {
 
 const char kLoadSchemasBackgroundTaskTokenName[] =
     "load_managed_storage_schemas_token";
 
 // The Legacy Browser Support was the first user of the policy-for-extensions
 // API, and relied on behavior that will be phased out. If this extension is
 // present then its policies will be loaded in a special way.
 // TODO(joaodasilva): remove this for M35. http://crbug.com/325349
 const char kLegacyBrowserSupportExtensionId[] =
     "heildphpnddilhkemkielfhnkaagiabh";
 
 }  // namespace
 
 // This helper observes initialization of all the installed extensions and
 // subsequent loads and unloads, and keeps the SchemaRegistry of the Profile
 // in sync with the current list of extensions. This allows the PolicyService
 // to fetch cloud policy for those extensions, and allows its providers to
 // selectively load only extension policy that has users.
 class ManagedValueStoreCache::ExtensionTracker
-    : public content::NotificationObserver {
+    : public ExtensionRegistryObserver {
  public:
   explicit ExtensionTracker(Profile* profile);
   virtual ~ExtensionTracker() {}
 
-  // NotificationObserver implementation:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
+ private:
+  // ExtensionRegistryObserver implementation.
+  virtual void OnExtensionWillBeInstalled(
+      content::BrowserContext* browser_context,
+      const Extension* extension,
+      bool is_update,
+      bool from_ephemeral,
+      const std::string& old_name) OVERRIDE;
+  virtual void OnExtensionUninstalled(content::BrowserContext* browser_context,
+                                      const Extension* extension) OVERRIDE;
 
- private:
   // Handler for the signal from ExtensionSystem::ready().
   void OnExtensionsReady();
 
   // Starts a schema load for all extensions that use managed storage.
   void LoadSchemas(scoped_ptr<ExtensionSet> added);
 
   bool UsesManagedStorage(const Extension* extension) const;
 
   // Loads the schemas of the |extensions| and passes a ComponentMap to
   // Register().
   static void LoadSchemasOnBlockingPool(scoped_ptr<ExtensionSet> extensions,
                                         base::WeakPtr<ExtensionTracker> self);
   void Register(const policy::ComponentMap* components);
 
   Profile* profile_;
-  content::NotificationRegistrar registrar_;
+  ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
+      extension_registry_observer_;
   policy::SchemaRegistry* schema_registry_;
   base::WeakPtrFactory<ExtensionTracker> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionTracker);
 };
 
 ManagedValueStoreCache::ExtensionTracker::ExtensionTracker(Profile* profile)
     : profile_(profile),
+      extension_registry_observer_(this),
       schema_registry_(
           policy::SchemaRegistryServiceFactory::GetForContext(profile)),
       weak_factory_(this) {
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED,
-                 content::Source<Profile>(profile_));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
-                 content::Source<Profile>(profile_));
-
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
   // Load schemas when the extension system is ready. It might be ready now.
   ExtensionSystem::Get(profile_)->ready().Post(
       FROM_HERE,
       base::Bind(&ExtensionTracker::OnExtensionsReady,
                  weak_factory_.GetWeakPtr()));
 }
 
-void ManagedValueStoreCache::ExtensionTracker::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
+void ManagedValueStoreCache::ExtensionTracker::OnExtensionWillBeInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update,
+    bool from_ephemeral,
+    const std::string& old_name) {
   // Some extensions are installed on the first run before the ExtensionSystem
   // becomes ready. Wait until all of them are ready before registering the
   // schemas of managed extensions, so that the policy loaders are reloaded at
   // most once.
   if (!ExtensionSystem::Get(profile_)->ready().is_signaled())
     return;
+  scoped_ptr<ExtensionSet> added(new ExtensionSet);
+  added->Insert(extension);
+  LoadSchemas(added.Pass());
+}
 
-  switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_INSTALLED_DEPRECATED: {
-      scoped_ptr<ExtensionSet> added(new ExtensionSet);
-      added->Insert(
-          content::Details<InstalledExtensionInfo>(details)->extension);
-      LoadSchemas(added.Pass());
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED: {
-      const Extension* removed =
-          content::Details<const Extension>(details).ptr();
-      if (removed && UsesManagedStorage(removed)) {
-        schema_registry_->UnregisterComponent(policy::PolicyNamespace(
-            policy::POLICY_DOMAIN_EXTENSIONS, removed->id()));
-      }
-      break;
-    }
-    default:
-      NOTREACHED();
-      return;
+void ManagedValueStoreCache::ExtensionTracker::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  if (!ExtensionSystem::Get(profile_)->ready().is_signaled())
+    return;
+  if (extension && UsesManagedStorage(extension)) {
+    schema_registry_->UnregisterComponent(policy::PolicyNamespace(
+        policy::POLICY_DOMAIN_EXTENSIONS, extension->id()));
   }
 }
 
 void ManagedValueStoreCache::ExtensionTracker::OnExtensionsReady() {
   // Load schemas for all installed extensions.
   LoadSchemas(
       ExtensionRegistry::Get(profile_)->GenerateInstalledExtensionsSet());
 }
 
 void ManagedValueStoreCache::ExtensionTracker::LoadSchemas(
@@ skipping 206 matching lines @@
 
   return store;
 }
 
 bool ManagedValueStoreCache::HasStore(const std::string& extension_id) const {
   // TODO(joaodasilva): move this check to a ValueStore method.
   return base::DirectoryExists(base_path_.AppendASCII(extension_id));
 }
 
 }  // namespace extensions