Added ActivityLog tests and associated bugfixes/extra logging.

chrome/browser/renderer_host/chrome_render_message_filter.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/renderer_host/chrome_render_message_filter.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
@@ skipping 39 matching lines @@
 #include "chrome/browser/browser_about_handler.h"
 #endif
 
 using content::BrowserThread;
 using extensions::APIPermission;
 using WebKit::WebCache;
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
+enum ActivityLogCallType {
+  ACTIVITYAPI,
+  ACTIVITYEVENT
+};
+
 void AddAPIActionToExtensionActivityLog(
     Profile* profile,
+    const ActivityLogCallType call_type,
     const extensions::Extension* extension,
     const std::string& api_call,
     scoped_ptr<ListValue> args,
     const std::string& extra) {
   // The ActivityLog can only be accessed from the main (UI) thread.  If we're
   // running on the wrong thread, re-dispatch from the main thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&AddAPIActionToExtensionActivityLog,
                                        profile,
+                                       call_type,
                                        extension,
                                        api_call,
                                        base::Passed(&args),
                                        extra));
   } else {
     extensions::ActivityLog* activity_log =
         extensions::ActivityLog::GetInstance(profile);
-    if (activity_log && activity_log->IsLogEnabled())
-      activity_log->LogAPIAction(extension, api_call, args.get(), extra);
+    if (activity_log && activity_log->IsLogEnabled()) {
+      if (call_type == ACTIVITYAPI)
+        activity_log->LogAPIAction(extension, api_call, args.get(), extra);
+      else if (call_type == ACTIVITYEVENT)
+        activity_log->LogEventAction(extension, api_call, args.get(), extra);
+    }
   }
 }
 
 void AddDOMActionToExtensionActivityLog(
     Profile* profile,
     const extensions::Extension* extension,
     const GURL& url,
     const string16& url_title,
     const std::string& api_call,
     scoped_ptr<ListValue> args,
@@ skipping 83 matching lines @@
                         OnExtensionShouldSuspendAck)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_GenerateUniqueID,
                         OnExtensionGenerateUniqueID)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_SuspendAck, OnExtensionSuspendAck)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_ResumeRequests,
                         OnExtensionResumeRequests);
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddAPIActionToActivityLog,
                         OnAddAPIActionToExtensionActivityLog);
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddDOMActionToActivityLog,
                         OnAddDOMActionToExtensionActivityLog);
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddEventToActivityLog,
+                        OnAddEventToExtensionActivityLog);
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowDatabase, OnAllowDatabase)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowDOMStorage, OnAllowDOMStorage)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowFileSystem, OnAllowFileSystem)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowIndexedDB, OnAllowIndexedDB)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CanTriggerClipboardRead,
                         OnCanTriggerClipboardRead)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CanTriggerClipboardWrite,
                         OnCanTriggerClipboardWrite)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 389 matching lines @@
   *unique_id = next_unique_id++;
 }
 
 void ChromeRenderMessageFilter::OnExtensionResumeRequests(int route_id) {
   content::ResourceDispatcherHost::Get()->ResumeBlockedRequestsForRoute(
       render_process_id_, route_id);
 }
 
 void ChromeRenderMessageFilter::OnAddAPIActionToExtensionActivityLog(
     const std::string& extension_id,
-    const ExtensionHostMsg_APIAction_Params& params) {
+    const ExtensionHostMsg_APIActionOrEvent_Params& params) {
   const extensions::Extension* extension =
       extension_info_map_->extensions().GetByID(extension_id);
   scoped_ptr<ListValue> args(params.arguments.DeepCopy());
   // The activity is recorded as an API action in the extension
   // activity log.
-  AddAPIActionToExtensionActivityLog(profile_, extension,
+  AddAPIActionToExtensionActivityLog(profile_, ACTIVITYAPI, extension,
                                      params.api_call, args.Pass(),
                                      params.extra);
 }
 
 void ChromeRenderMessageFilter::OnAddDOMActionToExtensionActivityLog(
     const std::string& extension_id,
     const ExtensionHostMsg_DOMAction_Params& params) {
   const extensions::Extension* extension =
       extension_info_map_->extensions().GetByID(extension_id);
   scoped_ptr<ListValue> args(params.arguments.DeepCopy());
   // The activity is recorded as a DOM action on the extension
   // activity log.
   AddDOMActionToExtensionActivityLog(profile_, extension,
                                      params.url, params.url_title,
                                      params.api_call, args.Pass(),
                                      params.extra);
 }
 
+void ChromeRenderMessageFilter::OnAddEventToExtensionActivityLog(
+    const std::string& extension_id,
+    const ExtensionHostMsg_APIActionOrEvent_Params& params) {
+  const extensions::Extension* extension =
+      extension_info_map_->extensions().GetByID(extension_id);
+  scoped_ptr<ListValue> args(params.arguments.DeepCopy());
+  // The activity is recorded as an event in the extension
+  // activity log.
+  AddAPIActionToExtensionActivityLog(profile_, ACTIVITYEVENT, extension,
+                                     params.api_call, args.Pass(),
+                                     params.extra);
+}
+
 void ChromeRenderMessageFilter::OnAllowDatabase(int render_view_id,
                                                 const GURL& origin_url,
                                                 const GURL& top_origin_url,
                                                 const string16& name,
                                                 const string16& display_name,
                                                 bool* allowed) {
   *allowed = cookie_settings_->IsSettingCookieAllowed(origin_url,
                                                       top_origin_url);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
@@ skipping 74 matching lines @@
 
 void ChromeRenderMessageFilter::OnSetCookie(const IPC::Message& message,
                                             const GURL& url,
                                             const GURL& first_party_for_cookies,
                                             const std::string& cookie) {
 #if defined(ENABLE_AUTOMATION)
   AutomationResourceMessageFilter::SetCookiesForUrl(
       render_process_id_, message.routing_id(), url, cookie);
 #endif
 }