Revert 203950 "Remove Activity Log usage of Extension objects"

trunk/src/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 139 matching lines @@
 
 void ActivityLog::SetArgumentLoggingForTesting(bool log_arguments) {
   testing_mode_ = log_arguments;
 }
 
 // static
 ActivityLog* ActivityLog::GetInstance(Profile* profile) {
   return ActivityLogFactory::GetForProfile(profile);
 }
 
-void ActivityLog::AddObserver(ActivityLog::Observer* observer) {
+void ActivityLog::AddObserver(const Extension* extension,
+                              ActivityLog::Observer* observer) {
   if (!IsLogEnabled()) return;
-  // TODO(felt) Re-implement Observer notification HERE for the API.
+  if (observers_.count(extension) == 0)
+    observers_[extension] = new ObserverListThreadSafe<Observer>;
+  observers_[extension]->AddObserver(observer);
 }
 
-void ActivityLog::RemoveObserver(ActivityLog::Observer* observer) {
-  // TODO(felt) Re-implement Observer notification HERE for the API.
+void ActivityLog::RemoveObserver(const Extension* extension,
+                                 ActivityLog::Observer* observer) {
+  if (observers_.count(extension) == 1)
+    observers_[extension]->RemoveObserver(observer);
 }
 
-void ActivityLog::LogAPIActionInternal(const std::string& extension_id,
+void ActivityLog::LogAPIActionInternal(const Extension* extension,
                                        const std::string& api_call,
                                        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_);
     }
     scoped_refptr<APIAction> action = new APIAction(
-        extension_id,
+        extension->id(),
         base::Time::Now(),
         type,
         api_call,
         MakeArgList(args),
         extra);
     ScheduleAndForget(&ActivityDatabase::RecordAction, action);
-    // TODO(felt) Re-implement Observer notification HERE for the API.
+
+    // Display the action.
+    ObserverMap::const_iterator iter = observers_.find(extension);
+    if (iter != observers_.end()) {
+      if (type == APIAction::CALL) {
+        iter->second->Notify(&Observer::OnExtensionActivity,
+                             extension,
+                             ActivityLog::ACTIVITY_EXTENSION_API_CALL,
+                             MakeCallSignature(api_call, args));
+      } else if (type == APIAction::EVENT_CALLBACK) {
+        iter->second->Notify(&Observer::OnExtensionActivity,
+                             extension,
+                             ActivityLog::ACTIVITY_EVENT_DISPATCH,
+                             MakeCallSignature(api_call, args));
+      }
+    }
     if (log_activity_to_stdout_)
       LOG(INFO) << action->PrintForDebug();
   } 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,
+void ActivityLog::LogAPIAction(const Extension* extension,
                                const std::string& api_call,
                                ListValue* args,
                                const std::string& extra) {
   if (!IsLogEnabled()) return;
   if (!testing_mode_ &&
       arg_whitelist_api_.find(api_call) == arg_whitelist_api_.end())
     args->Clear();
-  LogAPIActionInternal(extension_id,
+  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 std::string& extension_id,
+void ActivityLog::LogEventAction(const Extension* extension,
                                  const std::string& api_call,
                                  ListValue* args,
                                  const std::string& extra) {
   if (!IsLogEnabled()) return;
   if (!testing_mode_ &&
       arg_whitelist_api_.find(api_call) == arg_whitelist_api_.end())
     args->Clear();
-  LogAPIActionInternal(extension_id,
+  LogAPIActionInternal(extension,
                        api_call,
                        args,
                        extra,
                        APIAction::EVENT_CALLBACK);
 }
 
-void ActivityLog::LogBlockedAction(const std::string& extension_id,
+void ActivityLog::LogBlockedAction(const Extension* extension,
                                    const std::string& blocked_call,
                                    ListValue* args,
                                    BlockedAction::Reason reason,
                                    const std::string& extra) {
   if (!IsLogEnabled()) return;
   if (!testing_mode_ &&
       arg_whitelist_api_.find(blocked_call) == arg_whitelist_api_.end())
     args->Clear();
-  scoped_refptr<BlockedAction> action = new BlockedAction(extension_id,
+  scoped_refptr<BlockedAction> action = new BlockedAction(extension->id(),
                                                           base::Time::Now(),
                                                           blocked_call,
                                                           MakeArgList(args),
                                                           reason,
                                                           extra);
   ScheduleAndForget(&ActivityDatabase::RecordAction, action);
-  // TODO(felt) Re-implement Observer notification HERE for the API.
+  // Display the action.
+  ObserverMap::const_iterator iter = observers_.find(extension);
+  if (iter != observers_.end()) {
+    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::LogDOMAction(const std::string& extension_id,
+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,
+      extension->id(),
       base::Time::Now(),
       call_type,
       url,
       url_title,
       api_call,
       MakeArgList(args),
       extra);
   ScheduleAndForget(&ActivityDatabase::RecordAction, action);
-  // TODO(felt) Re-implement Observer notification HERE for the API.
+
+  // 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 (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::LogWebRequestAction(const std::string& extension_id,
+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,
+      extension->id(),
       base::Time::Now(),
       DomActionType::WEBREQUEST,
       url,
       null_title,
       api_call,
       details_string,
       extra);
   ScheduleAndForget(&ActivityDatabase::RecordAction, action);
-  // TODO(felt) Re-implement Observer notification HERE for the API.
+
+  // Display the action.
+  ObserverMap::const_iterator iter = observers_.find(extension);
+  if (iter != observers_.end()) {
+    iter->second->Notify(&Observer::OnExtensionActivity,
+                         extension,
+                         ActivityLog::ACTIVITY_CONTENT_SCRIPT,
+                         action->PrintForDebug());
+  }
   if (log_activity_to_stdout_)
     LOG(INFO) << action->PrintForDebug();
 }
 
 void ActivityLog::GetActions(
     const std::string& extension_id,
     const int day,
     const base::Callback
         <void(scoped_ptr<std::vector<scoped_refptr<Action> > >)>& callback) {
   BrowserThread::PostTaskAndReplyWithResult(
@@ skipping 30 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));
-      LogDOMAction(extension->id(),
+      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::DatabaseErrorCallback(int error, sql::Statement* stmt) {
   if (sql::IsErrorCatastrophic(error))
     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