[Extensions] Short-circuit activity logging if not enabled

extensions/browser/extension_function_dispatcher.cc

 // Copyright 2014 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 "extensions/browser/extension_function_dispatcher.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 36 matching lines @@
 using content::BrowserThread;
 using content::RenderViewHost;
 
 namespace extensions {
 namespace {
 
 // Notifies the ApiActivityMonitor that an extension API function has been
 // called. May be called from any thread.
 void NotifyApiFunctionCalled(const std::string& extension_id,
                              const std::string& api_name,
-                             std::unique_ptr<base::ListValue> args,
+                             const base::ListValue& args,
                              content::BrowserContext* browser_context) {
-  // The ApiActivityMonitor 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(&NotifyApiFunctionCalled,
-                                       extension_id,
-                                       api_name,
-                                       base::Passed(&args),
-                                       browser_context));
-    return;
-  }
-  // The BrowserContext may become invalid after the task above is posted.
-  if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
-    return;
-
-  ApiActivityMonitor* monitor =
-      ExtensionsBrowserClient::Get()->GetApiActivityMonitor(browser_context);
-  if (monitor)
-    monitor->OnApiFunctionCalled(extension_id, api_name, std::move(args));
+  activity_monitor::OnApiFunctionCalled(browser_context, extension_id, api_name,
+                                        args);
 }
 
 // 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(ExtensionAPI::CreateWithDefaultConfiguration()) {}
   std::unique_ptr<ExtensionAPI> api;
 };
 base::LazyInstance<Static> g_global_io_data = LAZY_INSTANCE_INITIALIZER;
@@ skipping 288 matching lines @@
     function->RunWithValidation()->Execute();
     return;
   }
 
   QuotaService* quota = extension_info_map->GetQuotaService();
   std::string violation_error = quota->Assess(extension->id(),
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
-    std::unique_ptr<base::ListValue> args(params.arguments.DeepCopy());
-    NotifyApiFunctionCalled(extension->id(), params.name, std::move(args),
+    NotifyApiFunctionCalled(extension->id(), params.name, params.arguments,
                             static_cast<content::BrowserContext*>(profile_id));
     UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
                                 function->histogram_value());
     tracked_objects::ScopedProfile scoped_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(function->name()),
         tracked_objects::ScopedProfile::ENABLED);
     base::ElapsedTimer timer;
     function->RunWithValidation()->Execute();
     // TODO(devlin): Once we have a baseline metric for how long functions take,
     // we can create a handful of buckets and record the function name so that
@@ skipping 119 matching lines @@
   ProcessManager* process_manager = ProcessManager::Get(browser_context_);
 
   ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context_);
   QuotaService* quota = extension_system->quota_service();
   std::string violation_error = quota->Assess(extension->id(),
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
 
   if (violation_error.empty()) {
-    std::unique_ptr<base::ListValue> args(params.arguments.DeepCopy());
-
     // See crbug.com/39178.
     ExtensionsBrowserClient::Get()->PermitExternalProtocolHandler();
-    NotifyApiFunctionCalled(extension->id(), params.name, std::move(args),
+    NotifyApiFunctionCalled(extension->id(), params.name, params.arguments,
                             browser_context_);
     UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
                                 function->histogram_value());
     tracked_objects::ScopedProfile scoped_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(function->name()),
         tracked_objects::ScopedProfile::ENABLED);
     base::ElapsedTimer timer;
     function->RunWithValidation()->Execute();
     // TODO(devlin): Once we have a baseline metric for how long functions take,
     // we can create a handful of buckets and record the function name so that
@@ skipping 112 matching lines @@
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback,
     functions::HistogramValue histogram_value) {
   base::ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
                "Access to extension API denied.", histogram_value);
 }
 
 }  // namespace extensions