Record event activity to the extension activity log.

chrome/browser/extensions/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 "chrome/browser/extensions/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/activity_log.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/extensions/process_map.h"
@@ skipping 53 matching lines @@
   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::LogExtensionEventMessage(Profile* profile,
+                                           const std::string& extension_id,
+                                           const std::string& event_name,
+                                           scoped_ptr<ListValue> event_args) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&LogExtensionEventMessage,
+                                       profile,
+                                       extension_id,
+                                       event_name,
+                                       Passed(event_args.Pass())));
+  } else {
+    // An ExtensionService might not be running during unit tests, or an
+    // extension might have been unloaded by the time we get to logging it.  In
+    // those cases log a warning.
+    ExtensionService* extension_service =
+        ExtensionSystem::Get(profile)->extension_service();
+    if (!extension_service) {
+      LOG(WARNING) << "ExtensionService does not seem to be available "
+                   << "(this may be normal for unit tests)";
+    } else {
+      const Extension* extension =
+          extension_service->extensions()->GetByID(extension_id);
+      if (!extension) {
+        LOG(WARNING) << "Extension " << extension_id << " not found!";
+      } else {
+        extensions::ActivityLog::GetInstance(profile)->LogEventAction(
+            extension, event_name, event_args.get(), "");
+      }
+    }
+  }
+}
+
+// static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
+                                           Profile* profile,
                                            const std::string& extension_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            const GURL& event_url,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
+  LogExtensionEventMessage(profile, extension_id, event_name,
+                           scoped_ptr<ListValue>(event_args->DeepCopy()));

[Matt Perry, 2013/01/25 21:24:17]

Can we only do this copying if activity logging is enabled?

[mvrable, 2013/01/28 16:27:36]

Done, if the updated code looks good to you.

+
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(MSG_ROUTING_CONTROL,
       extension_id, kDispatchEvent, args, event_url,
       user_gesture == USER_GESTURE_ENABLED));
 
   // DispatchExtensionMessage does _not_ take ownership of event_args, so we
   // must ensure that the destruction of args does not attempt to free it.
   Value* removed_event_args = NULL;
   args.Remove(1, &removed_event_args);
 }
 
 // static
 void EventRouter::DispatchEvent(IPC::Sender* ipc_sender,
+                                Profile* profile,
                                 const std::string& extension_id,
                                 const std::string& event_name,
                                 scoped_ptr<ListValue> event_args,
                                 const GURL& event_url,
                                 UserGestureState user_gesture,
                                 const EventFilteringInfo& info) {
-  DispatchExtensionMessage(ipc_sender, extension_id, event_name,
+  DispatchExtensionMessage(ipc_sender, profile, extension_id, event_name,
                            event_args.get(), event_url, user_gesture, info);
 }
 
 EventRouter::EventRouter(Profile* profile, ExtensionPrefs* extension_prefs)
     : profile_(profile),
       listeners_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      activity_log_(ActivityLog::GetInstance(profile)),
       dispatch_chrome_updated_event_(false) {
   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_EXTENSIONS_READY,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
@@ skipping 48 matching lines @@
 
 void EventRouter::OnListenerAdded(const EventListener* listener) {
   const std::string& event_name = listener->event_name;
   const EventListenerInfo details(event_name, listener->extension_id);
   ObserverMap::iterator observer = observers_.find(event_name);
   if (observer != observers_.end())
     observer->second->OnListenerAdded(details);
 
   if (SystemInfoEventRouter::IsSystemInfoEvent(event_name))
     SystemInfoEventRouter::GetInstance()->AddEventListener(event_name);
+
+  const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
+      extension_service()->GetExtensionById(listener->extension_id,
+                                            ExtensionService::INCLUDE_ENABLED);
+  if (extension) {
+    scoped_ptr<ListValue> args(new ListValue());
+    if (listener->filter)
+      args->Append(listener->filter->DeepCopy());
+    activity_log_->LogAPIAction(extension,
+                                event_name + ".addListener",
+                                args.get(),
+                                "");
+  }
 }
 
 void EventRouter::OnListenerRemoved(const EventListener* listener) {
   const std::string& event_name = listener->event_name;
   const EventListenerInfo details(event_name, listener->extension_id);
   ObserverMap::iterator observer = observers_.find(event_name);
   if (observer != observers_.end())
     observer->second->OnListenerRemoved(details);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&NotifyEventListenerRemovedOnIOThread,
                  profile_, listener->extension_id, event_name));
 
   if (SystemInfoEventRouter::IsSystemInfoEvent(event_name))
     SystemInfoEventRouter::GetInstance()->RemoveEventListener(event_name);
+
+  const Extension* extension = extensions::ExtensionSystem::Get(profile_)->
+      extension_service()->GetExtensionById(listener->extension_id,
+                                            ExtensionService::INCLUDE_ENABLED);
+  if (extension) {
+    scoped_ptr<ListValue> args(new ListValue());
+    activity_log_->LogAPIAction(extension,
+                                event_name + ".removeListener",
+                                args.get(),
+                                "");
+  }
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   scoped_ptr<EventListener> listener(new EventListener(
       event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
   bool is_new = listeners_.AddListener(listener.Pass());
 
   if (is_new) {
     ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
@@ skipping 200 matching lines @@
   }
 
   if (!CanDispatchEventToProfile(listener_profile, extension, event))
     return;
 
   if (!event->will_dispatch_callback.is_null()) {
     event->will_dispatch_callback.Run(listener_profile, extension,
                                       event->event_args.get());
   }
 
-  DispatchExtensionMessage(process, extension_id,
+  DispatchExtensionMessage(process, listener_profile, extension_id,
                            event->event_name, event->event_args.get(),
                            event->event_url, event->user_gesture,
                            event->filter_info);
   IncrementInFlightEvents(listener_profile, extension);
 }
 
 bool EventRouter::CanDispatchEventToProfile(Profile* profile,
                                             const Extension* extension,
                                             const linked_ptr<Event>& event) {
   // Is this event from a different profile than the renderer (ie, an
@@ skipping 208 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions