Remove Activity Log usage of Extension objects

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 "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 #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 {
 
-void LogSuccess(const Extension* extension,
+void LogSuccess(const std::string& extension_id,
                 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,
+                                       extension_id,
                                        api_name,
                                        base::Passed(&args),
                                        profile));
   } else {
     extensions::ActivityLog* activity_log =
         extensions::ActivityLog::GetInstance(profile);
-    activity_log->LogAPIAction(extension, api_name, args.get(), std::string());
+    activity_log->LogAPIAction(
+        extension_id, api_name, args.get(), std::string());
   }
 }
 
-void LogFailure(const Extension* extension,
+void LogFailure(const std::string& extension_id,
                 const std::string& api_name,
                 scoped_ptr<ListValue> args,
                 extensions::BlockedAction::Reason 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,
+                                       extension_id,
                                        api_name,
                                        base::Passed(&args),
                                        reason,
                                        profile));
   } else {
     extensions::ActivityLog* activity_log =
         extensions::ActivityLog::GetInstance(profile);
     activity_log->LogBlockedAction(
-        extension, api_name, args.get(), reason, std::string());
+        extension_id, api_name, args.get(), reason, std::string());
   }
 }
 
 
 // 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()) {
@@ skipping 151 matching lines @@
                  params.request_id));
 
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension, render_process_id,
                               extension_info_map->process_map(),
                               g_global_io_data.Get().api.get(),
                               profile, callback));
   scoped_ptr<ListValue> args(params.arguments.DeepCopy());
 
   if (!function) {
-    LogFailure(extension,
+    LogFailure(extension->id(),
                params.name,
                args.Pass(),
                extensions::BlockedAction::ACCESS_DENIED,
                profile_cast);
     return;
   }
 
   IOThreadExtensionFunction* function_io =
       function->AsIOThreadExtensionFunction();
   if (!function_io) {
     NOTREACHED();
     return;
   }
   function_io->set_ipc_sender(ipc_sender);
   function_io->set_extension_info_map(extension_info_map);
   function->set_include_incognito(
       extension_info_map->IsIncognitoEnabled(extension->id()));
 
   if (!CheckPermissions(function, extension, params, callback)) {
-    LogFailure(extension,
+    LogFailure(extension->id(),
                params.name,
                args.Pass(),
                extensions::BlockedAction::ACCESS_DENIED,
                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,
+    LogSuccess(extension->id(),
                params.name,
                args.Pass(),
                profile_cast);
     function->Run();
   } else {
-    LogFailure(extension,
+    LogFailure(extension->id(),
                params.name,
                args.Pass(),
                extensions::BlockedAction::QUOTA_EXCEEDED,
                profile_cast);
     function->OnQuotaExceeded(violation_error);
   }
 }
 
 ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(Profile* profile,
                                                          Delegate* delegate)
@@ skipping 44 matching lines @@
 
   scoped_refptr<ExtensionFunction> function(
       CreateExtensionFunction(params, extension,
                               render_view_host->GetProcess()->GetID(),
                               *(service->process_map()),
                               extensions::ExtensionAPI::GetSharedInstance(),
                               profile(), callback));
   scoped_ptr<ListValue> args(params.arguments.DeepCopy());
 
   if (!function) {
-    LogFailure(extension,
+    LogFailure(extension->id(),
                params.name,
                args.Pass(),
                extensions::BlockedAction::ACCESS_DENIED,
                profile());
     return;
   }
 
   UIThreadExtensionFunction* function_ui =
       function->AsUIThreadExtensionFunction();
   if (!function_ui) {
     NOTREACHED();
     return;
   }
   function_ui->SetRenderViewHost(render_view_host);
   function_ui->set_dispatcher(AsWeakPtr());
   function_ui->set_profile(profile_);
   function->set_include_incognito(service->CanCrossIncognito(extension));
 
   if (!CheckPermissions(function, extension, params, callback)) {
-    LogFailure(extension,
+    LogFailure(extension->id(),
                params.name,
                args.Pass(),
                extensions::BlockedAction::ACCESS_DENIED,
                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());
+    LogSuccess(extension->id(), params.name, args.Pass(), profile());
     function->Run();
   } else {
-    LogFailure(extension,
+    LogFailure(extension->id(),
                params.name,
                args.Pass(),
                extensions::BlockedAction::QUOTA_EXCEEDED,
                profile());
     function->OnQuotaExceeded(violation_error);
   }
 
   // Note: do not access |this| after this point. We may have been deleted
   // if function->Run() ended up closing the tab that owns us.
 
@@ skipping 109 matching lines @@
   return function;
 }
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback) {
   ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
                "Access to extension API denied.");
 }