Use ExtensionRegistryObserver instead of deprecated extension notification from c/b/e/api.

chrome/browser/extensions/api/push_messaging/push_messaging_api.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/push_messaging/push_messaging_api.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/extensions/api/push_messaging.h"
 #include "components/invalidation/invalidation_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/identity_provider.h"
 
 using content::BrowserThread;
 
 const char kChannelIdSeparator[] = "/";
@@ skipping 27 matching lines @@
   glue::Message message;
   message.subchannel_id = subchannel;
   message.payload = payload;
 
   DVLOG(2) << "PushMessagingEventRouter::OnMessage"
            << " payload = '" << payload
            << "' subchannel = '" << subchannel
            << "' extension = '" << extension_id << "'";
 
   scoped_ptr<base::ListValue> args(glue::OnMessage::Create(message));
-  scoped_ptr<extensions::Event> event(
-      new extensions::Event(glue::OnMessage::kEventName, args.Pass()));
+  scoped_ptr<Event> event(new Event(glue::OnMessage::kEventName, args.Pass()));
   event->restrict_to_browser_context = profile_;
   EventRouter::Get(profile_)->DispatchEventToExtension(
       extension_id, event.Pass());
 }
 
 // GetChannelId class functions
 
 PushMessagingGetChannelIdFunction::PushMessagingGetChannelIdFunction()
     : OAuth2TokenService::Consumer("push_messaging"),
       interactive_(false) {}
@@ skipping 190 matching lines @@
       return;
     }
     default:
       // Return error to caller.
       ReportResult(std::string(), error_text);
       return;
   }
 }
 
 PushMessagingAPI::PushMessagingAPI(content::BrowserContext* context)
-    : profile_(Profile::FromBrowserContext(context)) {
+    : extension_registry_observer_(this),
+      profile_(Profile::FromBrowserContext(context)) {
+  extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_->GetOriginalProfile()));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
-                 content::Source<Profile>(profile_->GetOriginalProfile()));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
-                 content::Source<Profile>(profile_->GetOriginalProfile()));
 }
 
 PushMessagingAPI::~PushMessagingAPI() {
 }
 
 // static
 PushMessagingAPI* PushMessagingAPI::Get(content::BrowserContext* context) {
   return BrowserContextKeyedAPIFactory<PushMessagingAPI>::Get(context);
 }
 
 void PushMessagingAPI::Shutdown() {
   event_router_.reset();
   handler_.reset();
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<PushMessagingAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<PushMessagingAPI>*
 PushMessagingAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
+void PushMessagingAPI::OnExtensionLoaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension) {
+  invalidation::InvalidationService* invalidation_service =
+      invalidation::InvalidationServiceFactory::GetForProfile(profile_);
+  if (!invalidation_service)
+    return;
+
+  if (!event_router_)
+    event_router_.reset(new PushMessagingEventRouter(profile_));
+  if (!handler_) {
+    handler_.reset(new PushMessagingInvalidationHandler(invalidation_service,
+                                                        event_router_.get()));
+  }

[not at google - send to devlin, 2014/05/12 17:53:27]

can you pull this initialization code into a function? like

bool InitEventRouterAndHandler() {
  ...
  if (!invalidation_service)
    return false;

  ...
  return true;
}

[limasdf, 2014/05/12 23:20:16]

Done.

+  if (extension->HasAPIPermission(APIPermission::kPushMessaging)) {
+    handler_->RegisterExtension(extension->id());
+  }
+}
+
+void PushMessagingAPI::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    UnloadedExtensionInfo::Reason reason) {
+  invalidation::InvalidationService* invalidation_service =
+      invalidation::InvalidationServiceFactory::GetForProfile(profile_);
+  if (!invalidation_service)
+    return;
+
+  if (!event_router_)
+    event_router_.reset(new PushMessagingEventRouter(profile_));
+  if (!handler_) {
+    handler_.reset(new PushMessagingInvalidationHandler(invalidation_service,
+                                                        event_router_.get()));
+  }
+  if (extension->HasAPIPermission(APIPermission::kPushMessaging)) {
+    handler_->UnregisterExtension(extension->id());
+  }
+}
+
 void PushMessagingAPI::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
+  DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_INSTALLED);
+
   invalidation::InvalidationService* invalidation_service =
       invalidation::InvalidationServiceFactory::GetForProfile(profile_);
   if (!invalidation_service)
     return;
 
   if (!event_router_)
     event_router_.reset(new PushMessagingEventRouter(profile_));
   if (!handler_) {
     handler_.reset(new PushMessagingInvalidationHandler(
         invalidation_service, event_router_.get()));
   }
-  switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_INSTALLED: {
-      const Extension* extension =
-          content::Details<const InstalledExtensionInfo>(details)->extension;
-      if (extension->HasAPIPermission(APIPermission::kPushMessaging)) {
-        handler_->SuppressInitialInvalidationsForExtension(extension->id());
-      }
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
-      const Extension* extension = content::Details<Extension>(details).ptr();
-      if (extension->HasAPIPermission(APIPermission::kPushMessaging)) {
-        handler_->RegisterExtension(extension->id());
-      }
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
-      const Extension* extension =
-          content::Details<UnloadedExtensionInfo>(details)->extension;
-      if (extension->HasAPIPermission(APIPermission::kPushMessaging)) {
-        handler_->UnregisterExtension(extension->id());
-      }
-      break;
-    }
-    default:
-      NOTREACHED();
+
+  const Extension* extension =
+      content::Details<const InstalledExtensionInfo>(details)->extension;
+  if (extension->HasAPIPermission(APIPermission::kPushMessaging)) {
+    handler_->SuppressInitialInvalidationsForExtension(extension->id());
   }
 }
 
 void PushMessagingAPI::SetMapperForTest(
     scoped_ptr<PushMessagingInvalidationMapper> mapper) {
   handler_ = mapper.Pass();
 }
 
 template <>
 void
 BrowserContextKeyedAPIFactory<PushMessagingAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(invalidation::InvalidationServiceFactory::GetInstance());
 }
 
 }  // namespace extensions