Add ApiActivityMonitor to decouple ActivityLog from low-level extensions code

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"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
+#include "extensions/browser/api_activity_monitor.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_map.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace extensions {
 
 namespace {
 
 void DoNothing(ExtensionHost* host) {}
 
 // A dictionary of event names to lists of filters that this extension has
 // registered from its lazy background page.
 const char kFilteredEvents[] = "filtered_events";
 
+// Sends a notification about an event to the API activity monitor on the
+// UI thread. Can be called from any thread.
+void NotifyApiEventDispatched(void* browser_context_id,
+                              const std::string& extension_id,
+                              const std::string& event_name,
+                              scoped_ptr<ListValue> args) {
+  // The ApiActivityMonitor can only be accessed from the UI thread.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&NotifyApiEventDispatched,
+                   browser_context_id,
+                   extension_id,
+                   event_name,
+                   base::Passed(&args)));
+    return;
+  }
+
+  // Notify the ApiActivityMonitor about the event dispatch.
+  BrowserContext* context = static_cast<BrowserContext*>(browser_context_id);
+  if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
+    return;
+  ApiActivityMonitor* monitor =
+      ExtensionsBrowserClient::Get()->GetApiActivityMonitor(context);
+  if (monitor)
+    monitor->OnApiEventDispatched(extension_id, event_name, args.Pass());
+}
+
 }  // namespace
 
 const char EventRouter::kRegisteredEvents[] = "events";
 
 struct EventRouter::ListenerProcess {
   content::RenderProcessHost* process;
   std::string extension_id;
 
   ListenerProcess(content::RenderProcessHost* process,
                   const std::string& extension_id)
       : process(process), extension_id(extension_id) {}
 
   bool operator<(const ListenerProcess& that) const {
     if (process < that.process)
       return true;
     if (process == that.process && extension_id < that.extension_id)
       return true;
     return false;
   }
 };
 
 // static
-void EventRouter::NotifyExtensionDispatchObserverOnUIThread(
-    void* browser_context_id,
-    scoped_ptr<EventDispatchInfo> details) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&NotifyExtensionDispatchObserverOnUIThread,
-                   browser_context_id, base::Passed(&details)));
-  } else {
-    BrowserContext* context =
-        reinterpret_cast<BrowserContext*>(browser_context_id);
-    if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
-      return;
-    ExtensionSystem* extension_system = ExtensionSystem::Get(context);
-    EventRouter* event_router = extension_system->event_router();
-    if (!event_router)
-      return;
-    if (event_router->event_dispatch_observer_) {
-      event_router->event_dispatch_observer_->OnWillDispatchEvent(
-          details.Pass());
-    }
-  }
-}
-
-// static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* browser_context_id,
                                            const std::string& extension_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
-  NotifyExtensionDispatchObserverOnUIThread(
-      browser_context_id,
-      make_scoped_ptr(new EventDispatchInfo(
-          extension_id,
-          event_name,
-          make_scoped_ptr(event_args->DeepCopy()))));
+  NotifyApiEventDispatched(browser_context_id,
+                           extension_id,
+                           event_name,
+                           make_scoped_ptr(event_args->DeepCopy()));
 
   ListValue args;
   args.Set(0, new base::StringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(
       MSG_ROUTING_CONTROL,
       extension_id,
       kEventBindings,
       "dispatchEvent",
@@ skipping 34 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),
-      listeners_(this),
-      event_dispatch_observer_(NULL) {
+      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,
                  content::Source<BrowserContext>(browser_context_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<BrowserContext>(browser_context_));
@@ skipping 27 matching lines @@
   std::vector<ObserverMap::iterator> iters_to_remove;
   for (ObserverMap::iterator iter = observers_.begin();
        iter != observers_.end(); ++iter) {
     if (iter->second == observer)
       iters_to_remove.push_back(iter);
   }
   for (size_t i = 0; i < iters_to_remove.size(); ++i)
     observers_.erase(iters_to_remove[i]);
 }
 
-void EventRouter::SetEventDispatchObserver(EventDispatchObserver* observer) {
-  CHECK(!event_dispatch_observer_);
-  event_dispatch_observer_ = observer;
-}
-
 void EventRouter::OnListenerAdded(const EventListener* listener) {
   const EventListenerInfo details(
       listener->event_name,
       listener->extension_id,
       listener->process ? listener->process->GetBrowserContext() : NULL);
   std::string base_event_name = GetBaseEventName(listener->event_name);
   ObserverMap::iterator observer = observers_.find(base_event_name);
   if (observer != observers_.end())
     observer->second->OnListenerAdded(details);
 }
@@ skipping 539 matching lines @@
   return copy;
 }
 
 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) {}
 
-EventDispatchInfo::EventDispatchInfo(const std::string& extension_id,
-                                     const std::string& event_name,
-                                     scoped_ptr<ListValue> event_args)
-    : extension_id(extension_id),
-      event_name(event_name),
-      event_args(event_args.Pass()) {}
-
-EventDispatchInfo::~EventDispatchInfo() {}
-
 }  // namespace extensions