Use ExtensionRegistry in EventRouter and ApiResourceManager

extensions/browser/event_router.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 "extensions/browser/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 150 matching lines @@
       FROM_HERE,
       base::Bind(&EventRouter::IncrementInFlightEventsOnUI,
                   browser_context_id,
                   extension_id));
 }
 
 EventRouter::EventRouter(BrowserContext* browser_context,
                          ExtensionPrefs* extension_prefs)
     : browser_context_(browser_context),
       extension_prefs_(extension_prefs),
+      extension_registry_observer_(this),
       listeners_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
                  content::Source<BrowserContext>(browser_context_));
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
-                 content::Source<BrowserContext>(browser_context_));
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
-                 content::Source<BrowserContext>(browser_context_));
+  extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 }
 
 EventRouter::~EventRouter() {}
 
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
       event_name, extension_id, process, scoped_ptr<DictionaryValue>())));
 }
@@ skipping 492 matching lines @@
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
         LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
             browser_context_)->lazy_background_task_queue();
         queue->AddPendingTask(browser_context_, extension->id(),
                               base::Bind(&DoNothing));
       }
       break;
     }
-    case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
-      // Add all registered lazy listeners to our cache.
-      const Extension* extension =
-          content::Details<const Extension>(details).ptr();
-      std::set<std::string> registered_events =
-          GetRegisteredEvents(extension->id());
-      listeners_.LoadUnfilteredLazyListeners(extension->id(),
-                                             registered_events);
-      const DictionaryValue* filtered_events =
-          GetFilteredEvents(extension->id());
-      if (filtered_events)
-        listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
-      break;
-    }
-    case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
-      // Remove all registered lazy listeners from our cache.
-      UnloadedExtensionInfo* unloaded =
-          content::Details<UnloadedExtensionInfo>(details).ptr();
-      listeners_.RemoveLazyListenersForExtension(unloaded->extension->id());
-      break;
-    }
     default:
       NOTREACHED();
       return;

[Devlin, 2014/06/25 19:59:54]

nit: Can you take out this return while you're here? :)

[limasdf, 2014/07/20 06:35:50]

Done.

   }
 }
 
+void EventRouter::OnExtensionLoaded(content::BrowserContext* browser_context,
+                                    const Extension* extension) {
+  std::set<std::string> registered_events =
+      GetRegisteredEvents(extension->id());
+  listeners_.LoadUnfilteredLazyListeners(extension->id(), registered_events);
+  const DictionaryValue* filtered_events = GetFilteredEvents(extension->id());
+  if (filtered_events)
+    listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
+}
+
+void EventRouter::OnExtensionUnloaded(content::BrowserContext* browser_context,
+                                      const Extension* extension,
+                                      UnloadedExtensionInfo::Reason reason) {
+  listeners_.RemoveLazyListenersForExtension(extension->id());
+}
+
 Event::Event(const std::string& event_name,
              scoped_ptr<base::ListValue> event_args)
     : event_name(event_name),
       event_args(event_args.Pass()),
       restrict_to_browser_context(NULL),
       user_gesture(EventRouter::USER_GESTURE_UNKNOWN),
       can_load_ephemeral_apps(false) {
   DCHECK(this->event_args.get());
 }
 
@@ skipping 38 matching lines @@
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       browser_context(browser_context) {}
 
 }  // namespace extensions