Remove NOTIFICATION_EXTENSION_ENABLED.

extensions/browser/event_router.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 #define EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/scoped_observer.h"
 #include "base/values.h"
 #include "components/keyed_service/core/keyed_service.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "extensions/browser/event_listener_map.h"
+#include "extensions/browser/events/lazy_event_dispatch_util.h"
 #include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/event_filtering_info.h"
 #include "ipc/ipc_sender.h"
 #include "url/gurl.h"
 
 class GURL;
 
 namespace content {
 class BrowserContext;
 class RenderProcessHost;
 }
 
 namespace extensions {
 class Extension;
 class ExtensionHost;
 class ExtensionPrefs;
 class ExtensionRegistry;
 
 struct Event;
 struct EventListenerInfo;
 
 class EventRouter : public KeyedService,
-                    public content::NotificationObserver,
                     public ExtensionRegistryObserver,
                     public EventListenerMap::Delegate,
                     public content::RenderProcessHostObserver {
  public:
   // These constants convey the state of our knowledge of whether we're in
   // a user-caused gesture as part of DispatchEvent.
   enum UserGestureState {
     USER_GESTURE_UNKNOWN = 0,
     USER_GESTURE_ENABLED = 1,
     USER_GESTURE_NOT_ENABLED = 2,
@@ skipping 134 matching lines @@
 
   // Reports UMA for an event dispatched to |extension| with histogram value
   // |histogram_value|. Must be called on the UI thread.
   //
   // |did_enqueue| should be true if the event was queued waiting for a process
   // to start, like an event page.
   void ReportEvent(events::HistogramValue histogram_value,
                    const Extension* extension,
                    bool did_enqueue);
 
+  LazyEventDispatchUtil* lazy_event_dispatch_util() {
+    return &lazy_event_dispatch_util_;
+  }
+
  private:
   friend class EventRouterFilterTest;
   friend class EventRouterTest;
 
   // An identifier for an event dispatch that is used to prevent double dispatch
   // due to race conditions between the direct and lazy dispatch paths.
   typedef std::pair<const content::BrowserContext*, std::string>
       EventDispatchIdentifier;
 
   // TODO(gdk): Document this.
   static void DispatchExtensionMessage(
       IPC::Sender* ipc_sender,
       void* browser_context_id,
       const std::string& extension_id,
       int event_id,
       const std::string& event_name,
       base::ListValue* event_args,
       UserGestureState user_gesture,
       const extensions::EventFilteringInfo& info);
 
   // Returns or sets the list of events for which the given extension has
   // registered.
   std::set<std::string> GetRegisteredEvents(
       const std::string& extension_id) const;
   void SetRegisteredEvents(const std::string& extension_id,
                            const std::set<std::string>& events);
 
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
   // ExtensionRegistryObserver implementation.
   void OnExtensionLoaded(content::BrowserContext* browser_context,
                          const Extension* extension) override;
   void OnExtensionUnloaded(content::BrowserContext* browser_context,
                            const Extension* extension,
                            UnloadedExtensionReason reason) override;
 
   // Shared by all event dispatch methods. If |restrict_to_extension_id| is
   // empty, the event is broadcast.  An event that just came off the pending
   // list may not be delayed again.
@@ skipping 77 matching lines @@
                            base::TerminationStatus status,
                            int exit_code) override;
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;
 
   content::BrowserContext* browser_context_;
 
   // The ExtensionPrefs associated with |browser_context_|. May be NULL in
   // tests.
   ExtensionPrefs* extension_prefs_;
 
-  content::NotificationRegistrar registrar_;
-
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   EventListenerMap listeners_;
 
   // Map from base event name to observer.
   typedef base::hash_map<std::string, Observer*> ObserverMap;
   ObserverMap observers_;
 
   std::set<content::RenderProcessHost*> observed_process_set_;
 
+  LazyEventDispatchUtil lazy_event_dispatch_util_;
+
   DISALLOW_COPY_AND_ASSIGN(EventRouter);
 };
 
 struct Event {
   // This callback should return true if the event should be dispatched to the
   // given context and extension, and false otherwise.
   typedef base::Callback<bool(content::BrowserContext*,
                               const Extension*,
                               Event*,
                               const base::DictionaryValue*)>
@@ skipping 69 matching lines @@
   const std::string event_name;
 
   const std::string extension_id;
   const GURL listener_url;
   content::BrowserContext* browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_