Added ActivityLog tests and associated bugfixes/extra logging.

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 <vector>
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 125 matching lines @@
 
 bool ActivityLogFactory::ServiceRedirectedInIncognito() const {
   return true;
 }
 
 // ActivityLog
 
 // Use GetInstance instead of directly creating an ActivityLog.
 ActivityLog::ActivityLog(Profile* profile) {
   // enable-extension-activity-logging and enable-extension-activity-ui
-  log_activity_to_stdout_ = CommandLine::ForCurrentProcess()->
-      HasSwitch(switches::kEnableExtensionActivityLogging);
-  log_activity_to_ui_ = CommandLine::ForCurrentProcess()->
-      HasSwitch(switches::kEnableExtensionActivityUI);
+  log_activity_to_stdout_ = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableExtensionActivityLogging);
+  log_activity_to_ui_ = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableExtensionActivityUI);
 
   // enable-extension-activity-log-testing
-  // Currently, this just controls whether arguments are collected. In the
-  // future, it may also control other optional activity log features.
-  log_arguments_ = CommandLine::ForCurrentProcess()->
-      HasSwitch(switches::kEnableExtensionActivityLogTesting);
-  if (!log_arguments_) {
+  // This controls whether arguments are collected.
+  testing_mode_ = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableExtensionActivityLogTesting);
+  if (!testing_mode_) {
     for (int i = 0; i < APIAction::kSizeAlwaysLog; i++) {
       arg_whitelist_api_.insert(std::string(APIAction::kAlwaysLog[i]));
     }
   }
 
   // If the database cannot be initialized for some reason, we keep
   // chugging along but nothing will get recorded. If the UI is
   // available, things will still get sent to the UI even if nothing
   // is being written to the database.
   db_ = new ActivityDatabase();
@@ skipping 70 matching lines @@
     LOG(ERROR) << "Unknown API call! " << api_call;
   }
 }
 
 // A wrapper around LogAPIActionInternal, but we know it's an API call.
 void ActivityLog::LogAPIAction(const Extension* extension,
                                const std::string& api_call,
                                ListValue* args,
                                const std::string& extra) {
   if (!IsLogEnabled()) return;
-  if (!log_arguments_ &&
+  if (!testing_mode_ &&
       arg_whitelist_api_.find(api_call) == arg_whitelist_api_.end())
     args->Clear();
   LogAPIActionInternal(extension,
                        api_call,
                        args,
                        extra,
                        APIAction::CALL);
 }
 
 // A wrapper around LogAPIActionInternal, but we know it's actually an event
 // being fired and triggering extension code. Having the two separate methods
 // (LogAPIAction vs LogEventAction) lets us hide how we actually choose to
 // handle them. Right now they're being handled almost the same.
 void ActivityLog::LogEventAction(const Extension* extension,
                                  const std::string& api_call,
                                  ListValue* args,
                                  const std::string& extra) {
   if (!IsLogEnabled()) return;
-  if (!log_arguments_ &&
+  if (!testing_mode_ &&
       arg_whitelist_api_.find(api_call) == arg_whitelist_api_.end())
     args->Clear();
   LogAPIActionInternal(extension,
                        api_call,
                        args,
                        extra,
                        APIAction::EVENT_CALLBACK);
 }
 
 void ActivityLog::LogBlockedAction(const Extension* extension,
                                    const std::string& blocked_call,
                                    ListValue* args,
                                    const char* reason,
                                    const std::string& extra) {
   if (!IsLogEnabled()) return;
-  if (!log_arguments_ &&
+  if (!testing_mode_ &&
       arg_whitelist_api_.find(blocked_call) == arg_whitelist_api_.end())
     args->Clear();
   scoped_refptr<BlockedAction> action = new BlockedAction(extension->id(),
                                                           base::Time::Now(),
                                                           blocked_call,
                                                           MakeArgList(args),
                                                           std::string(reason),
                                                           extra);
   ScheduleAndForget(&ActivityDatabase::RecordAction, action);
   // Display the action.
@@ skipping 139 matching lines @@
       return "content_script";
     case ActivityLog::ACTIVITY_EVENT_DISPATCH:
       return "event_dispatch";
     default:
       NOTREACHED();
       return "";
   }
 }
 
 }  // namespace extensions