Add ApiActivityMonitor to decouple ActivityLog from low-level extensions code

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 <map>
 #include <set>
 #include <string>
@@ skipping 50 matching lines @@
   // the base name of the event (e.g. adding an event listener for event name
   // "foo.onBar/123" will trigger observers registered for "foo.onBar").
   class Observer {
    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) {}
   };
 
-  // The EventDispatchObserver is notified on the UI thread whenever
-  // an event is dispatched. There can be only one EventDispatchObserver.
-  class EventDispatchObserver {
-   public:
-    virtual void OnWillDispatchEvent(scoped_ptr<EventDispatchInfo> details) = 0;
-  };
-
   // Converts event names like "foo.onBar/123" into "foo.onBar". Event names
   // without a "/" are returned unchanged.
   static std::string GetBaseEventName(const std::string& full_event_name);
 
   // Sends an event via ipc_sender to the given extension. Can be called on any
   // thread.
   static void DispatchEvent(IPC::Sender* ipc_sender,
                             void* browser_context_id,
                             const std::string& extension_id,
                             const std::string& event_name,
@@ skipping 22 matching lines @@
 
   // Registers an observer to be notified when an event listener for
   // |event_name| is added or removed. There can currently be only one observer
   // for each distinct |event_name|.
   void RegisterObserver(Observer* observer,
                         const std::string& event_name);
 
   // Unregisters an observer from all events.
   void UnregisterObserver(Observer* observer);
 
-  // Sets the observer to be notified whenever an event is dispatched to an
-  // extension.
-  void SetEventDispatchObserver(EventDispatchObserver* observer);
-
   // Add or remove the extension as having a lazy background page that listens
   // to the event. The difference from the above methods is that these will be
   // remembered even after the process goes away. We use this list to decide
   // which extension pages to load when dispatching an event.
   void AddLazyEventListener(const std::string& event_name,
                             const std::string& extension_id);
   void RemoveLazyEventListener(const std::string& event_name,
                                const std::string& extension_id);
 
   // If |add_lazy_listener| is true also add the lazy version of this listener.
@@ skipping 51 matching lines @@
 
   // A map between an event name and a set of extensions that are listening
   // 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;
 
-  // Sends a notification about an event to the event dispatch observer on the
-  // UI thread. Can be called from any thread.
-  static void NotifyExtensionDispatchObserverOnUIThread(
-      void* browser_context_id,
-      scoped_ptr<EventDispatchInfo> details);
-
   // TODO(gdk): Document this.
   static void DispatchExtensionMessage(
       IPC::Sender* ipc_sender,
       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);
 
@@ skipping 82 matching lines @@
   ExtensionPrefs* extension_prefs_;
 
   content::NotificationRegistrar registrar_;
 
   EventListenerMap listeners_;
 
   // Map from base event name to observer.
   typedef base::hash_map<std::string, Observer*> ObserverMap;
   ObserverMap observers_;
 
-  EventDispatchObserver* event_dispatch_observer_;
-
   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 55 matching lines @@
                     const std::string& extension_id,
                     content::BrowserContext* browser_context);
   // The event name including any sub-event, e.g. "runtime.onStartup" or
   // "webRequest.onCompleted/123".
   const std::string event_name;
 
   const std::string extension_id;
   content::BrowserContext* browser_context;
 };
 
-struct EventDispatchInfo {
-  EventDispatchInfo(const std::string& extension_id,
-                    const std::string& event_name,
-                    scoped_ptr<base::ListValue> event_args);
-  ~EventDispatchInfo();
-
-  const std::string extension_id;
-  const std::string event_name;
-  scoped_ptr<base::ListValue> event_args;
-};
-
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_