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

chrome/browser/extensions/api/alarms/alarm_manager.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/alarms/alarm_manager.h"
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/clock.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/state_store.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/alarms.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 
 namespace extensions {
 
 namespace alarms = api::alarms;
 
 namespace {
 
 // A list of alarms that this extension has set.
 const char kRegisteredAlarms[] = "alarms";
@@ skipping 57 matching lines @@
   }
   return list.Pass();
 }
 
 
 }  // namespace
 
 // AlarmManager
 
 AlarmManager::AlarmManager(content::BrowserContext* context)
-    : profile_(Profile::FromBrowserContext(context)),
+    : browser_context_(context),
       clock_(new base::DefaultClock()),
-      delegate_(new DefaultAlarmDelegate(context)) {
+      delegate_(new DefaultAlarmDelegate(context)),
+      extension_registry_observer_(this) {
+  extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
   registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
-                 content::Source<Profile>(profile_));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
-                 content::Source<Profile>(profile_));
+                 chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
+                 content::Source<content::BrowserContext>(browser_context_));
 
-  StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
+  StateStore* storage = ExtensionSystem::Get(browser_context_)->state_store();
   if (storage)
     storage->RegisterKey(kRegisteredAlarms);
 }
 
 AlarmManager::~AlarmManager() {
 }
 
 void AlarmManager::AddAlarm(const std::string& extension_id,
                             const Alarm& alarm,
                             const AddAlarmCallback& callback) {
@@ skipping 99 matching lines @@
 static base::LazyInstance<BrowserContextKeyedAPIFactory<AlarmManager> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<AlarmManager>*
 AlarmManager::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 // static
-AlarmManager* AlarmManager::Get(Profile* profile) {
-  return BrowserContextKeyedAPIFactory<AlarmManager>::Get(profile);
+AlarmManager* AlarmManager::Get(content::BrowserContext* browser_context) {
+  return BrowserContextKeyedAPIFactory<AlarmManager>::Get(browser_context);
 }
 
 void AlarmManager::RemoveAlarmIterator(const AlarmIterator& iter) {
   AlarmList& list = iter.first->second;
   list.erase(iter.second);
   if (list.empty())
     alarms_.erase(iter.first);
 
   // Cancel the timer if there are no more alarms.
   // We don't need to reschedule the poll otherwise, because in
@@ skipping 42 matching lines @@
     RemoveAlarmIterator(old_alarm);
 
   alarms_[extension_id].push_back(alarm);
   base::Time alarm_time =
       base::Time::FromJsTime(alarm.js_alarm->scheduled_time);
   if (next_poll_time_.is_null() || alarm_time < next_poll_time_)
     SetNextPollTime(alarm_time);
 }
 
 void AlarmManager::WriteToStorage(const std::string& extension_id) {
-  StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
+  StateStore* storage = ExtensionSystem::Get(browser_context_)->state_store();
   if (!storage)
     return;
 
   scoped_ptr<base::Value> alarms;
   AlarmMap::iterator list = alarms_.find(extension_id);
   if (list != alarms_.end())
     alarms.reset(AlarmsToValue(list->second).release());
   else
     alarms.reset(AlarmsToValue(std::vector<Alarm>()).release());
   storage->SetExtensionValue(extension_id, kRegisteredAlarms, alarms.Pass());
@@ skipping 99 matching lines @@
 void AlarmManager::RunWhenReady(
     const std::string& extension_id, const ReadyAction& action) {
   ReadyMap::iterator it = ready_actions_.find(extension_id);
 
   if (it == ready_actions_.end())
     action.Run(extension_id);
   else
     it->second.push(action);
 }
 
+void AlarmManager::OnExtensionLoaded(content::BrowserContext* browser_context,
+                                     const Extension* extension) {
+  StateStore* storage = ExtensionSystem::Get(browser_context_)->state_store();
+  if (storage) {
+    ready_actions_.insert(ReadyMap::value_type(extension->id(), ReadyQueue()));
+    storage->GetExtensionValue(
+        extension->id(),
+        kRegisteredAlarms,
+        base::Bind(
+            &AlarmManager::ReadFromStorage, AsWeakPtr(), extension->id()));
+  }
+}
+
 void AlarmManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
-  switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
-      const Extension* extension =
-          content::Details<const Extension>(details).ptr();
-      StateStore* storage = ExtensionSystem::Get(profile_)->state_store();
-      if (storage) {
-        ready_actions_.insert(
-            ReadyMap::value_type(extension->id(), ReadyQueue()));
-        storage->GetExtensionValue(extension->id(), kRegisteredAlarms,
-            base::Bind(&AlarmManager::ReadFromStorage,
-                       AsWeakPtr(), extension->id()));
-      }
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
-      const Extension* extension =
-          content::Details<const Extension>(details).ptr();
-      RemoveAllAlarms(
-          extension->id(), base::Bind(RemoveAllOnUninstallCallback));
-      break;
-    }
-    default:
-      NOTREACHED();
-      break;
-  }
+  DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_UNINSTALLED);
+  const Extension* extension = content::Details<const Extension>(details).ptr();
+  RemoveAllAlarms(extension->id(), base::Bind(RemoveAllOnUninstallCallback));
 }
 
 // AlarmManager::Alarm
 
 Alarm::Alarm()
     : js_alarm(new api::alarms::Alarm()) {
 }
 
 Alarm::Alarm(const std::string& name,
              const api::alarms::AlarmCreateInfo& create_info,
@@ skipping 27 matching lines @@
   if (create_info.period_in_minutes.get()) {
     js_alarm->period_in_minutes.reset(
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions