Extension activity log database refactoring (step 3)

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/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/extensions/activity_log/activity_log.h"
-#include "chrome/browser/extensions/activity_log/api_actions.h"
-#include "chrome/browser/extensions/activity_log/blocked_actions.h"
 #include "chrome/browser/extensions/activity_log/stream_noargs_ui_policy.h"
 #include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_system_factory.h"
 #include "chrome/browser/extensions/install_tracker_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/common/chrome_constants.h"
@@ skipping 221 matching lines @@
 }
 
 void ActivityLog::AddObserver(ActivityLog::Observer* observer) {
   observers_->AddObserver(observer);
 }
 
 void ActivityLog::RemoveObserver(ActivityLog::Observer* observer) {
   observers_->RemoveObserver(observer);
 }
 
+void ActivityLog::LogAction(scoped_refptr<Action> action) {
+  if (IsLogEnabled() &&
+      !ActivityLogAPI::IsExtensionWhitelisted(action->extension_id())) {
+    if (policy_)
+      policy_->ProcessAction(action);
+    observers_->Notify(&Observer::OnExtensionActivity, action);
+    if (testing_mode_)
+      LOG(INFO) << action->PrintForDebug();
+  }
+}
+
 void ActivityLog::LogAPIActionInternal(const std::string& extension_id,
                                        const std::string& api_call,
                                        base::ListValue* args,
                                        const std::string& extra,
                                        const APIAction::Type type) {
   std::string verb, manager;
   bool matches = RE2::FullMatch(api_call, "(.*?)\\.(.*)", &manager, &verb);
   if (matches) {
     if (!args->empty() && manager == "tabs") {
       APIAction::LookupTabId(api_call, args, profile_);
     }
 
-    if (policy_) {
-      scoped_ptr<base::DictionaryValue> details(new DictionaryValue());
-      std::string key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_EXTRA);
-      details->SetString(key, extra);
-      DCHECK((type == APIAction::CALL || type == APIAction::EVENT_CALLBACK) &&
-          "Unexpected APIAction call type.");
-      policy_->ProcessAction(
-          type == APIAction::CALL ? ActivityLogPolicy::ACTION_API :
-              ActivityLogPolicy::ACTION_EVENT,
-          extension_id,
-          api_call,
-          GURL(),
-          args,
-          details.get());
-    }
+    DCHECK((type == APIAction::CALL || type == APIAction::EVENT_CALLBACK) &&
+           "Unexpected APIAction call type.");
 
-    // TODO(felt) Logging should be done more efficiently, so that it
-    // doesn't require construction of the action object.
-    scoped_refptr<APIAction> action = new APIAction(
-        extension_id,
-        base::Time::Now(),
-        type,
-        api_call,
-        MakeArgList(args),
-        *args,
-        extra);
+    scoped_refptr<Action> action;
+    action = new Action(extension_id,
+                        base::Time::Now(),
+                        type == APIAction::CALL ? Action::ACTION_API_CALL
+                                                : Action::ACTION_API_EVENT);
+    action->set_api_name(api_call);
+    action->set_args(make_scoped_ptr(args->DeepCopy()));
+    // TODO(mvrable): Factor common key strings out as constants.
+    if (!extra.empty())
+      action->mutable_other()->SetString("extra", extra);
 
-    observers_->Notify(&Observer::OnExtensionActivity, action);
-    if (testing_mode_) LOG(INFO) << action->PrintForDebug();
+    LogAction(action);
   } else {
     LOG(ERROR) << "Unknown API call! " << api_call;
   }
 }
 
 // A wrapper around LogAPIActionInternal, but we know it's an API call.
 void ActivityLog::LogAPIAction(const std::string& extension_id,
                                const std::string& api_call,
                                base::ListValue* args,
                                const std::string& extra) {
@@ skipping 24 matching lines @@
 }
 
 void ActivityLog::LogBlockedAction(const std::string& extension_id,
                                    const std::string& blocked_call,
                                    base::ListValue* args,
                                    BlockedAction::Reason reason,
                                    const std::string& extra) {
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
 
-  if (policy_) {
-    scoped_ptr<base::DictionaryValue> details(new DictionaryValue());
-    std::string key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_REASON);
-    details->SetInteger(key, static_cast<int>(reason));
-    key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_EXTRA);
-    details->SetString(key, extra);
-    policy_->ProcessAction(
-        ActivityLogPolicy::ACTION_BLOCKED,
-        extension_id,
-        blocked_call,
-        GURL(),
-        args,
-        details.get());
-  }
+  scoped_refptr<Action> action;
+  action =
+      new Action(extension_id, base::Time::Now(), Action::ACTION_API_BLOCKED);
+  action->set_api_name(blocked_call);
+  action->set_args(make_scoped_ptr(args->DeepCopy()));
+  // TODO(mvrable): Factor common key strings out as constants.
+  action->mutable_other()->SetInteger("reason", static_cast<int>(reason));
+  if (!extra.empty())
+    action->mutable_other()->SetString("extra", extra);
 
-  scoped_refptr<BlockedAction> action = new BlockedAction(extension_id,
-                                                          base::Time::Now(),
-                                                          blocked_call,
-                                                          MakeArgList(args),
-                                                          reason,
-                                                          extra);
-  observers_->Notify(&Observer::OnExtensionActivity, action);
-  if (testing_mode_) LOG(INFO) << action->PrintForDebug();
+  LogAction(action);
 }
 
 void ActivityLog::LogDOMAction(const std::string& extension_id,
                                const GURL& url,
                                const string16& url_title,
                                const std::string& api_call,
                                const base::ListValue* args,
                                DomActionType::Type call_type,
                                const std::string& extra) {
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
-  if (call_type == DomActionType::METHOD && api_call == "XMLHttpRequest.open")
+
+  Action::ActionType action_type = Action::ACTION_DOM_ACCESS;
+  if (call_type == DomActionType::INSERTED) {
+    action_type = Action::ACTION_CONTENT_SCRIPT;
+  } else if (call_type == DomActionType::METHOD &&
+             api_call == "XMLHttpRequest.open") {
     call_type = DomActionType::XHR;
-
-  if (policy_) {
-    scoped_ptr<base::DictionaryValue> details(new DictionaryValue());
-    std::string key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_DOM_ACTION);
-    details->SetInteger(key, static_cast<int>(call_type));
-    key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_URL_TITLE);
-    details->SetString(key, url_title);
-    key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_EXTRA);
-    details->SetString(key, extra);
-    policy_->ProcessAction(
-        ActivityLogPolicy::ACTION_DOM,
-        extension_id,
-        api_call,
-        url,
-        args,
-        details.get());
+    action_type = Action::ACTION_DOM_XHR;
   }
 
+  scoped_refptr<Action> action;
+  action = new Action(extension_id, base::Time::Now(), action_type);
+  action->set_api_name(api_call);
+  if (args)
+    action->set_args(make_scoped_ptr(args->DeepCopy()));
+  action->set_page_url(url);
+  // TODO(mvrable): Factor common key strings out as constants.
+  action->set_page_title(base::UTF16ToUTF8(url_title));
+  action->mutable_other()->SetInteger("dom_verb", static_cast<int>(call_type));
+  if (!extra.empty())
+    action->mutable_other()->SetString("extra", extra);
 
-  // TODO(felt) Logging should be done more efficiently, so that it
-  // doesn't require construction of the action object.
-  scoped_refptr<DOMAction> action = new DOMAction(
-      extension_id,
-      base::Time::Now(),
-      call_type,
-      url,
-      url_title,
-      api_call,
-      MakeArgList(args),
-      extra);
-  observers_->Notify(&Observer::OnExtensionActivity, action);
-  if (testing_mode_) LOG(INFO) << action->PrintForDebug();
+  LogAction(action);
 }
 
 void ActivityLog::LogWebRequestAction(const std::string& extension_id,
                                       const GURL& url,
                                       const std::string& api_call,
                                       scoped_ptr<DictionaryValue> details,
                                       const std::string& extra) {
-  string16 null_title;
   if (!IsLogEnabled() ||
       ActivityLogAPI::IsExtensionWhitelisted(extension_id)) return;
 
-  std::string details_string;
-  if (policy_) {
-    scoped_ptr<base::DictionaryValue> details(new DictionaryValue());
-    std::string key = policy_->GetKey(
-        ActivityLogPolicy::PARAM_KEY_DETAILS_STRING);
-    details->SetString(key, details_string);
-    key = policy_->GetKey(ActivityLogPolicy::PARAM_KEY_EXTRA);
-    details->SetString(key, extra);
-    policy_->ProcessAction(
-        ActivityLogPolicy::ACTION_WEB_REQUEST,
-        extension_id,
-        api_call,
-        url,
-        NULL,
-        details.get());
-  }
+  scoped_refptr<Action> action;
+  action =
+      new Action(extension_id, base::Time::Now(), Action::ACTION_WEB_REQUEST);
+  action->set_api_name(api_call);
+  action->set_page_url(url);
+  // TODO(mvrable): Factor common key strings out as constants.
+  action->mutable_other()->Set("web_request", details.release());
+  if (!extra.empty())
+    action->mutable_other()->SetString("extra", extra);
 
-  JSONStringValueSerializer serializer(&details_string);
-  serializer.SerializeAndOmitBinaryValues(*details);
-
-  // TODO(felt) Logging should be done more efficiently, so that it
-  // doesn't require construction of the action object.
-  scoped_refptr<DOMAction> action = new DOMAction(
-      extension_id,
-      base::Time::Now(),
-      DomActionType::WEBREQUEST,
-      url,
-      null_title,
-      api_call,
-      details_string,
-      extra);
-  observers_->Notify(&Observer::OnExtensionActivity, action);
-  if (testing_mode_) LOG(INFO) << action->PrintForDebug();
+  LogAction(action);
 }
 
 void ActivityLog::GetActions(
     const std::string& extension_id,
     const int day,
     const base::Callback
         <void(scoped_ptr<std::vector<scoped_refptr<Action> > >)>& callback) {
   if (policy_) {
     policy_->ReadData(extension_id, day, callback);
   }
@@ skipping 43 matching lines @@
                    web_contents->GetTitle(),
                    std::string(),  // no api call here
                    script_names.get(),
                    DomActionType::INSERTED,
                    extra);
     }
   }
 }
 
 }  // namespace extensions