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,
+      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,
-                 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,
+    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;
-
-  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: {
-      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;
+  scoped_ptr<ExtensionSet> added(new ExtensionSet);
+  added->Insert(extension);
+  LoadSchemas(added.Pass());
+}
+void ManagedValueStoreCache::ExtensionTracker::OnExtensionUninstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {

[Devlin, 2014/05/28 16:58:34]

I don't _think_ this can ever happen, but the if statement on line 130 used to
break in both notifications, whereas now the OnExtensionUninstalled still
executes.  Could you either make sure that an extension can never be uninstalled
if the system isn't ready (you wouldn't think it could/should happen, but you
never know), or add the check here, too?

[limasdf, 2014/05/28 17:38:43]

Done.
The reason why I removed is the comment says 'extesnions are installed'.
But obviously code doesn't cover only extension installed event. :)

+  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