Extract chrome.runtime API code from extensions::EventRouter

chrome/browser/extensions/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 CHROME_BROWSER_EXTENSIONS_EVENT_ROUTER_H_
 #define CHROME_BROWSER_EXTENSIONS_EVENT_ROUTER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/event_listener_map.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/common/event_filtering_info.h"
 #include "ipc/ipc_sender.h"
 
 class GURL;
 class PrefService;
-class Profile;
 
 namespace content {
 class BrowserContext;
 class RenderProcessHost;
 }
 
 namespace extensions {
 class ActivityLog;
 class Extension;
 class ExtensionHost;
@@ skipping 23 matching lines @@
    public:
     // Called when a listener is added.
     virtual void OnListenerAdded(const EventListenerInfo& details) {}
     // Called when a listener is removed.
     virtual void OnListenerRemoved(const EventListenerInfo& details) {}
   };
 
   // Sends an event via ipc_sender to the given extension. Can be called on any
   // thread.
   static void DispatchEvent(IPC::Sender* ipc_sender,
-                            void* profile_id,
+                            void* browser_context_id,
                             const std::string& extension_id,
                             const std::string& event_name,
                             scoped_ptr<base::ListValue> event_args,
                             UserGestureState user_gesture,
                             const EventFilteringInfo& info);
 
   // An EventRouter is shared between |browser_context| and its associated
   // incognito context. |extension_prefs| may be NULL in tests.
   EventRouter(content::BrowserContext* browser_context,
               ExtensionPrefs* extension_prefs);
@@ skipping 85 matching lines @@
   // to that event.
   typedef std::map<std::string, std::set<ListenerProcess> > ListenerMap;
 
   // 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;
 
   // Records an event notification in the extension activity log.  Can be
   // called from any thread.
-  static void LogExtensionEventMessage(void* profile_id,
+  static void LogExtensionEventMessage(void* browser_context_id,
                                        const std::string& extension_id,
                                        const std::string& event_name,
                                        scoped_ptr<base::ListValue> event_args);
 
   // TODO(gdk): Document this.
   static void DispatchExtensionMessage(
       IPC::Sender* ipc_sender,
-      void* profile_id,
+      void* browser_context_id,
       const std::string& extension_id,
       const std::string& event_name,
       base::ListValue* event_args,
       UserGestureState user_gesture,
       const extensions::EventFilteringInfo& info);
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
@@ skipping 54 matching lines @@
   const base::DictionaryValue* GetFilteredEvents(
       const std::string& extension_id);
 
   // Track of the number of dispatched events that have not yet sent an
   // ACK from the renderer.
   void IncrementInFlightEvents(content::BrowserContext* context,
                                const Extension* extension);
 
   // static
   static void IncrementInFlightEventsOnUI(
-      void* profile_id,
+      void* browser_context_id,
       const std::string& extension_id);
 
   void DispatchPendingEvent(const linked_ptr<Event>& event,
                             ExtensionHost* host);
 
   // Implementation of EventListenerMap::Delegate.
   virtual void OnListenerAdded(const EventListener* listener) OVERRIDE;
   virtual void OnListenerRemoved(const EventListener* listener) OVERRIDE;
 
   content::BrowserContext* browser_context_;
 
-  // The ExtensionPrefs associated with |profile_|. May be NULL in tests.
+  // The ExtensionPrefs associated with |browser_context_|. May be NULL in
+  // tests.
   ExtensionPrefs* extension_prefs_;
 
   content::NotificationRegistrar registrar_;
 
   EventListenerMap listeners_;
 
   typedef base::hash_map<std::string, Observer*> ObserverMap;
   ObserverMap observers_;
 
-  // True if we should dispatch the chrome.runtime.onInstalled event with
-  // reason "chrome_update" upon loading each extension.
-  // TODO(jamescook): Move this to RuntimeEventRouter.
-  bool dispatch_chrome_updated_event_;
-
   DISALLOW_COPY_AND_ASSIGN(EventRouter);
 };
 
 struct Event {
   typedef base::Callback<void(content::BrowserContext*,
                               const Extension*,
                               base::ListValue*)> WillDispatchCallback;
 
   // The event to dispatch.
   std::string event_name;
@@ skipping 48 matching lines @@
   EventListenerInfo(const std::string& event_name,
                     const std::string& extension_id);
 
   const std::string event_name;
   const std::string extension_id;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EVENT_ROUTER_H_