Save extension activity log to a file.

chrome/browser/extensions/extension_function_dispatcher.cc

 // Copyright (c) 2012 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/extension_function_dispatcher.h"
 
 #include <map>
 
+#include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/process_util.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/activity_log.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extension_function_registry.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
 #include "chrome/browser/extensions/extensions_quota_service.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/external_protocol/external_protocol_handler.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/common/extensions/api/extension_api.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/url_constants.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "webkit/glue/resource_type.h"
 
 using extensions::Extension;
 using extensions::ExtensionAPI;
 using content::RenderViewHost;
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
 const char kAccessDenied[] = "access denied";
 const char kQuotaExceeded[] = "quota exceeded";
 
 void LogSuccess(const Extension* extension,
-                const ExtensionHostMsg_Request_Params& params) {
-  extensions::ActivityLog* activity_log =
-      extensions::ActivityLog::GetInstance();
-  if (activity_log->HasObservers(extension)) {
-    std::string call_signature = params.name + "(";
-    ListValue::const_iterator it = params.arguments.begin();
-    for (; it != params.arguments.end(); ++it) {
-      std::string arg;
-      JSONStringValueSerializer serializer(&arg);
-      if (serializer.SerializeAndOmitBinaryValues(**it)) {
-        if (it != params.arguments.begin())
-          call_signature += ", ";
-        call_signature += arg;
-      }
-    }
-    call_signature += ")";
-
-    activity_log->Log(extension,
-                      extensions::ActivityLog::ACTIVITY_EXTENSION_API_CALL,
-                      call_signature);
+                const std::string& api_name,
+                scoped_ptr<ListValue> args,
+                Profile* profile) {
+  // The ActivityLog can only be accessed from the main (UI) thread.  If we're
+  // running on the wrong thread, re-dispatch from the main thread.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&LogSuccess,
+                                       extension,
+                                       api_name,
+                                       Passed(args.Pass()),
+                                       profile));
+  } else {
+    extensions::ActivityLog* activity_log =
+        extensions::ActivityLog::GetInstance(profile);
+    if (activity_log->HasObservers(extension))
+      activity_log->LogAPIAction(extension, api_name, args.get(), "");
   }
 }
 
 void LogFailure(const Extension* extension,
-                const std::string& func_name,
-                const char* reason) {
-  extensions::ActivityLog* activity_log =
-      extensions::ActivityLog::GetInstance();
-  if (activity_log->HasObservers(extension)) {
-    activity_log->Log(extension,
-                      extensions::ActivityLog::ACTIVITY_EXTENSION_API_BLOCK,
-                      func_name + ": " + reason);
+                const std::string& api_name,
+                scoped_ptr<ListValue> args,
+                const char* reason,
+                Profile* profile) {
+  // The ActivityLog can only be accessed from the main (UI) thread.  If we're
+  // running on the wrong thread, re-dispatch from the main thread.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&LogFailure,
+                                       extension,
+                                       api_name,
+                                       Passed(args.Pass()),
+                                       reason,
+                                       profile));
+  } else {
+    extensions::ActivityLog* activity_log =
+        extensions::ActivityLog::GetInstance(profile);
+    if (activity_log->HasObservers(extension))
+      activity_log->LogBlockedAction(extension,
+                                     api_name,
+                                     args.get(),
+                                     reason,
+                                     "");
   }
 }
 
+
 // Separate copy of ExtensionAPI used for IO thread extension functions. We need
 // this because ExtensionAPI has mutable data. It should be possible to remove
 // this once all the extension APIs are updated to the feature system.
 struct Static {
   Static()
       : api(extensions::ExtensionAPI::CreateWithDefaultConfiguration()) {
   }
   scoped_ptr<extensions::ExtensionAPI> api;
 };
 base::LazyInstance<Static> g_global_io_data = LAZY_INSTANCE_INITIALIZER;
@@ skipping 29 matching lines @@
 // static
 void ExtensionFunctionDispatcher::DispatchOnIOThread(
     ExtensionInfoMap* extension_info_map,
     void* profile,
     int render_process_id,
     base::WeakPtr<ChromeRenderMessageFilter> ipc_sender,
     int routing_id,
     const ExtensionHostMsg_Request_Params& params) {
   const Extension* extension =
       extension_info_map->extensions().GetByID(params.extension_id);
-
+  Profile* profile_cast = static_cast<Profile*>(profile);
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension, render_process_id,
                               extension_info_map->process_map(),
                               g_global_io_data.Get().api.get(),
                               profile,
                               ipc_sender, NULL, routing_id));
+  scoped_ptr<ListValue> args(params.arguments.DeepCopy());
+
   if (!function) {
-    LogFailure(extension, params.name, kAccessDenied);
+    LogFailure(extension,
+               params.name,
+               args.Pass(),
+               kAccessDenied,
+               profile_cast);
     return;
   }
 
   IOThreadExtensionFunction* function_io =
       function->AsIOThreadExtensionFunction();
   if (!function_io) {
     NOTREACHED();
     return;
   }
   function_io->set_ipc_sender(ipc_sender, routing_id);
   function_io->set_extension_info_map(extension_info_map);
   function->set_include_incognito(
       extension_info_map->IsIncognitoEnabled(extension->id()));
 
   if (!CheckPermissions(function, extension, params, ipc_sender, routing_id)) {
-    LogFailure(extension, params.name, kAccessDenied);
+    LogFailure(extension,
+               params.name,
+               args.Pass(),
+               kAccessDenied,
+               profile_cast);
     return;
   }
 
   ExtensionsQuotaService* quota = extension_info_map->GetQuotaService();
   std::string violation_error = quota->Assess(extension->id(),
                                               function,
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
+    LogSuccess(extension,
+               params.name,
+               args.Pass(),
+               profile_cast);
     function->Run();
-    LogSuccess(extension, params);
   } else {
+    LogFailure(extension,
+               params.name,
+               args.Pass(),
+               kQuotaExceeded,
+               profile_cast);
     function->OnQuotaExceeded(violation_error);
-    LogFailure(extension, params.name, kQuotaExceeded);
   }
 }
 
 ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(Profile* profile,
                                                          Delegate* delegate)
   : profile_(profile),
     delegate_(delegate) {
 }
 
 ExtensionFunctionDispatcher::~ExtensionFunctionDispatcher() {
@@ skipping 16 matching lines @@
         WebSecurityOrigin::createFromString(params.source_origin),
         params.source_url));
 
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension,
                               render_view_host->GetProcess()->GetID(),
                               *(service->process_map()),
                               extensions::ExtensionAPI::GetSharedInstance(),
                               profile(), render_view_host, render_view_host,
                               render_view_host->GetRoutingID()));
+  scoped_ptr<ListValue> args(params.arguments.DeepCopy());
+
   if (!function) {
-    LogFailure(extension, params.name, kAccessDenied);
+    LogFailure(extension,
+               params.name,
+               args.Pass(),
+               kAccessDenied,
+               profile());
     return;
   }
 
   UIThreadExtensionFunction* function_ui =
       function->AsUIThreadExtensionFunction();
   if (!function_ui) {
     NOTREACHED();
     return;
   }
   function_ui->set_dispatcher(AsWeakPtr());
   function_ui->set_profile(profile_);
   function->set_include_incognito(service->CanCrossIncognito(extension));
 
   if (!CheckPermissions(function, extension, params, render_view_host,
                         render_view_host->GetRoutingID())) {
-    LogFailure(extension, params.name, kAccessDenied);
+    LogFailure(extension,
+               params.name,
+               args.Pass(),
+               kAccessDenied,
+               profile());
     return;
   }
 
   ExtensionsQuotaService* quota = service->quota_service();
   std::string violation_error = quota->Assess(extension->id(),
                                               function,
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
     // See crbug.com/39178.
     ExternalProtocolHandler::PermitLaunchUrl();
-
+    LogSuccess(extension, params.name, args.Pass(), profile());
     function->Run();
-    LogSuccess(extension, params);
   } else {
+    LogFailure(extension,
+               params.name,
+               args.Pass(),
+               kQuotaExceeded,
+               profile());
     function->OnQuotaExceeded(violation_error);
-    LogFailure(extension, params.name, kQuotaExceeded);
   }
 
   // Note: do not access |this| after this point. We may have been deleted
   // if function->Run() ended up closing the tab that owns us.
 
   // Check if extension was uninstalled by management.uninstall.
   if (!service->extensions()->GetByID(params.extension_id))
     return;
 
   // We only adjust the keepalive count for UIThreadExtensionFunction for
@@ skipping 71 matching lines @@
 }
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     IPC::Sender* ipc_sender, int routing_id, int request_id) {
   ListValue empty_list;
   ipc_sender->Send(new ExtensionMsg_Response(
       routing_id, request_id, false, empty_list,
       "Access to extension API denied."));
 }