Record event activity to the extension activity log.

chrome/browser/extensions/activity_log.cc

 // Copyright (c) 2011 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/activity_log.h"
 
 #include <set>
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
@@ skipping 143 matching lines @@
                                const ListValue* args,
                                const std::string& extra) {
   if (!IsLoggingEnabled()) return;
   std::string verb, manager;
   bool matches = RE2::FullMatch(name, "(.*?)\\.(.*)", &manager, &verb);
   if (matches) {
     std::string call_signature = MakeCallSignature(name, args);
     scoped_refptr<APIAction> action = new APIAction(
         extension->id(),
         base::Time::Now(),
+        APIAction::CALL,
         APIAction::StringAsActionType(verb),
         APIAction::StringAsTargetType(manager),
         call_signature,
         extra);
     ScheduleAndForget(&ActivityDatabase::RecordAction, action);
 
     // Display the action.
     ObserverMap::const_iterator iter = observers_.find(extension);
     if (iter != observers_.end()) {
       iter->second->Notify(&Observer::OnExtensionActivity,
                            extension,
                            ActivityLog::ACTIVITY_EXTENSION_API_CALL,
                            call_signature);
     }
+    if (log_activity_to_stdout_) {
+      LOG(INFO) << action->PrettyPrintForDebug();
+    }
+  } else {
+    LOG(ERROR) << "Unknown API call! " << name;
+  }
+}
+
+void ActivityLog::LogEventAction(const Extension* extension,
+                                 const std::string& name,
+                                 const ListValue* args,
+                                 const std::string& extra) {
+  std::string verb, manager;
+  bool matches = RE2::FullMatch(name, "(.*?)\\.(.*)", &manager, &verb);
+  if (matches) {
+    std::string call_signature = MakeCallSignature(name, args);
+    scoped_refptr<APIAction> action = new APIAction(
+        extension->id(),
+        base::Time::Now(),
+        APIAction::EVENT_CALLBACK,
+        APIAction::StringAsActionType(verb),
+        APIAction::StringAsTargetType(manager),
+        call_signature,
+        extra);
+    ScheduleAndForget(&ActivityDatabase::RecordAction, action);
+
+    // Display the action.
+    ObserverMap::const_iterator iter = observers_.find(extension);
+    if (iter != observers_.end()) {
+      iter->second->Notify(&Observer::OnExtensionActivity,
+                           extension,
+                           ActivityLog::ACTIVITY_EVENT_DISPATCH,
+                           call_signature);
+    }
     if (log_activity_to_stdout_)
       LOG(INFO) << action->PrettyPrintForDebug();
   } else {
     LOG(ERROR) << "Unknown API call! " << name;

[Eric Dingle, 2013/01/24 16:16:34]

Is this the correct error message for this function?

[mvrable, 2013/01/24 18:12:31]

Done.

   }
 }
 
 void ActivityLog::LogBlockedAction(const Extension* extension,
                                    const std::string& blocked_name,
                                    const ListValue* args,
                                    const char* reason,
                                    const std::string& extra) {
   if (!IsLoggingEnabled()) return;
   std::string blocked_call = MakeCallSignature(blocked_name, args);
@@ skipping 90 matching lines @@
 
 // static
 const char* ActivityLog::ActivityToString(Activity activity) {
   switch (activity) {
     case ActivityLog::ACTIVITY_EXTENSION_API_CALL:
       return "api_call";
     case ActivityLog::ACTIVITY_EXTENSION_API_BLOCK:
       return "api_block";
     case ActivityLog::ACTIVITY_CONTENT_SCRIPT:
       return "content_script";
+    case ActivityLog::ACTIVITY_EVENT_DISPATCH:
+      return "event_dispatch";
     default:
       NOTREACHED();
       return "";
   }
 }
 
 }  // namespace extensions