Moved DOMActionType information from extras into a real field (ActivityLog)

chrome/browser/extensions/activity_log/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 <set>
 #include <vector>
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 299 matching lines @@
     std::string blocked_str = MakeCallSignature(blocked_call, args);
     iter->second->Notify(&Observer::OnExtensionActivity,
                          extension,
                          ActivityLog::ACTIVITY_EXTENSION_API_BLOCK,
                          blocked_str);
   }
   if (log_activity_to_stdout_)
     LOG(INFO) << action->PrintForDebug();
 }
 
-void ActivityLog::LogDOMActionInternal(const Extension* extension,
-                                       const GURL& url,
-                                       const string16& url_title,
-                                       const std::string& api_call,
-                                       const ListValue* args,
-                                       const std::string& extra,
-                                       DOMAction::DOMActionType verb) {
+void ActivityLog::LogDOMAction(const Extension* extension,
+                               const GURL& url,
+                               const string16& url_title,
+                               const std::string& api_call,
+                               const ListValue* args,
+                               DomActionType::Type call_type,
+                               const std::string& extra) {
+  if (!IsLogEnabled()) return;
+  if (call_type == DomActionType::METHOD && api_call == "XMLHttpRequest.open")
+    call_type = DomActionType::XHR;
   scoped_refptr<DOMAction> action = new DOMAction(
       extension->id(),
       base::Time::Now(),
-      verb,
+      call_type,
       url,
       url_title,
       api_call,
       MakeArgList(args),
       extra);
   ScheduleAndForget(&ActivityDatabase::RecordAction, action);
 
   // Display the action.
   ObserverMap::const_iterator iter = observers_.find(extension);
   if (iter != observers_.end()) {
     // TODO(felt): This is a kludge, planning to update this when new
     // UI is in place.
-    if (verb == DOMAction::INSERTED) {
+    if (call_type == DomActionType::INSERTED) {
       iter->second->Notify(&Observer::OnExtensionActivity,
                            extension,
                            ActivityLog::ACTIVITY_CONTENT_SCRIPT,
                            action->PrintForDebug());
     } else {
       iter->second->Notify(&Observer::OnExtensionActivity,
                            extension,
                            ActivityLog::ACTIVITY_CONTENT_SCRIPT,
                            MakeCallSignature(api_call, args));
     }
   }
   if (log_activity_to_stdout_)
     LOG(INFO) << action->PrintForDebug();
 }
 
-void ActivityLog::LogDOMAction(const Extension* extension,
-                               const GURL& url,
-                               const string16& url_title,
-                               const std::string& api_call,
-                               const ListValue* args,
-                               const std::string& extra) {
-  if (!IsLogEnabled()) return;
-  DOMAction::DOMActionType action = DOMAction::MODIFIED;
-  if (extra == "Getter") {
-    action = DOMAction::GETTER;
-  } else if (extra == "Setter") {
-    action = DOMAction::SETTER;
-  } else if (api_call == "XMLHttpRequest.open") {
-    // Has to come before the Method check because XHR is also a Method.
-    action = DOMAction::XHR;
-  } else if (extra == "Method") {
-    action = DOMAction::METHOD;
-  }
-  LogDOMActionInternal(extension,
-                       url,
-                       url_title,
-                       api_call,
-                       args,
-                       extra,
-                       action);
-}
-
 void ActivityLog::LogWebRequestAction(const Extension* extension,
                                       const GURL& url,
                                       const std::string& api_call,
                                       scoped_ptr<DictionaryValue> details,
                                       const std::string& extra) {
   string16 null_title;
   if (!IsLogEnabled()) return;
 
   // Strip details of the web request modifications (for privacy reasons),
   // unless testing is enabled.
   if (!testing_mode_) {
     DictionaryValue::Iterator details_iterator(*details);
     while (!details_iterator.IsAtEnd()) {
       details->SetBoolean(details_iterator.key(), true);
       details_iterator.Advance();
     }
   }
   std::string details_string;
   JSONStringValueSerializer serializer(&details_string);
   serializer.SerializeAndOmitBinaryValues(*details);
 
   scoped_refptr<DOMAction> action = new DOMAction(
       extension->id(),
       base::Time::Now(),
-      DOMAction::WEBREQUEST,
+      DomActionType::WEBREQUEST,
       url,
       null_title,
       api_call,
       details_string,
       extra);
   ScheduleAndForget(&ActivityDatabase::RecordAction, action);
 
   // Display the action.
   ObserverMap::const_iterator iter = observers_.find(extension);
   if (iter != observers_.end()) {
@@ skipping 45 matching lines @@
     if (!it->second.empty()) {
       std::string ext_scripts_str;
       for (std::set<std::string>::const_iterator it2 = it->second.begin();
            it2 != it->second.end();
            ++it2) {
         ext_scripts_str += *it2;
         ext_scripts_str += " ";
       }
       scoped_ptr<ListValue> script_names(new ListValue());
       script_names->Set(0, new StringValue(ext_scripts_str));
-      LogDOMActionInternal(extension,
-                           on_url,
-                           web_contents->GetTitle(),
-                           std::string(),  // no api call here
-                           script_names.get(),
-                           std::string(),  // no extras either
-                           DOMAction::INSERTED);
+      LogDOMAction(extension,
+                   on_url,
+                   web_contents->GetTitle(),
+                   std::string(),  // no api call here
+                   script_names.get(),
+                   DomActionType::INSERTED,
+                   std::string());  // no extras either
     }
   }
 }
 
 void ActivityLog::KillActivityLogDatabase() {
   ScheduleAndForget(&ActivityDatabase::KillDatabase);
 }
 
 // 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