[Extensions] Short-circuit activity logging if not enabled

extensions/browser/event_router.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 "extensions/browser/event_router.h"
 
 #include <stddef.h>
 
 #include <tuple>
 #include <utility>
@@ skipping 45 matching lines @@
 // A dictionary of event names to lists of filters that this extension has
 // registered from its lazy background page.
 const char kFilteredEvents[] = "filtered_events";
 
 // Sends a notification about an event to the API activity monitor and the
 // ExtensionHost for |extension_id| on the UI thread. Can be called from any
 // thread.
 void NotifyEventDispatched(void* browser_context_id,
                            const std::string& extension_id,
                            const std::string& event_name,
-                           std::unique_ptr<ListValue> args) {
-  // The ApiActivityMonitor can only be accessed from the UI thread.
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&NotifyEventDispatched, browser_context_id, extension_id,
-                   event_name, base::Passed(&args)));
-    return;
-  }
-
+                           const base::ListValue& args) {
   // Notify the ApiActivityMonitor about the event dispatch.
   BrowserContext* context = static_cast<BrowserContext*>(browser_context_id);
-  if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
-    return;
-  ApiActivityMonitor* monitor =
-      ExtensionsBrowserClient::Get()->GetApiActivityMonitor(context);
-  if (monitor)
-    monitor->OnApiEventDispatched(extension_id, event_name, std::move(args));
+  activity_monitor::OnApiEventDispatched(context, extension_id, event_name,
+                                         args);
 }
 
 // A global identifier used to distinguish extension events.
 base::StaticAtomicSequenceNumber g_extension_event_id;
 
 }  // namespace
 
 const char EventRouter::kRegisteredEvents[] = "events";
 
 struct EventRouter::ListenerProcess {
@@ skipping 13 matching lines @@
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* browser_context_id,
                                            const std::string& extension_id,
                                            int event_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
   NotifyEventDispatched(browser_context_id, extension_id, event_name,
-                        base::WrapUnique(event_args->DeepCopy()));
+                        *event_args);
 
   // TODO(chirantan): Make event dispatch a separate IPC so that it doesn't
   // piggyback off MessageInvoke, which is used for other things.
   ListValue args;
   args.Set(0, new base::StringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
   args.Set(3, new base::FundamentalValue(event_id));
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(
       MSG_ROUTING_CONTROL,
@@ skipping 778 matching lines @@
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions