[Extensions] Short-circuit activity logging if not enabled

extensions/browser/api_activity_monitor.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_API_ACTIVITY_MONITOR_H_
 #define EXTENSIONS_BROWSER_API_ACTIVITY_MONITOR_H_
 
 #include <memory>
 #include <string>
 
+class GURL;
 
 namespace base {
+class DictionaryValue;
 class ListValue;
 }
 
+namespace content {
+class BrowserContext;
+}
+
 namespace extensions {
+namespace activity_monitor {
 
-// ApiActivityMonitor is used to monitor extension API event dispatch and API
-// function calls. An embedder can use this interface to log low-level extension
-// activity.
-class ApiActivityMonitor {
- public:
-  // Called when an API event is dispatched to an extension.
-  virtual void OnApiEventDispatched(
-      const std::string& extension_id,
-      const std::string& event_name,
-      std::unique_ptr<base::ListValue> event_args) = 0;
+using Monitor = void (*)(content::BrowserContext* browser_context,
+                         const std::string& extension_id,
+                         const std::string& activity_name,
+                         const base::ListValue& event_args);
+using WebRequestMonitor =
+    void (*)(content::BrowserContext* browser_context,
+             const std::string& extension_id,
+             const GURL& url,
+             bool is_incognito,
+             const std::string& api_call,
+             std::unique_ptr<base::DictionaryValue> details);
 
-  // Called when an extension calls an API function.
-  virtual void OnApiFunctionCalled(const std::string& extension_id,
-                                   const std::string& api_name,
-                                   std::unique_ptr<base::ListValue> args) = 0;
+// Get or set the current global monitor for API events and functions. Note that
+// these handlers *must* be allowed to be called on any thread!
+Monitor GetApiEventMonitor();
+Monitor GetApiFunctionMonitor();
+WebRequestMonitor GetWebRequestMonitor();
+void SetApiEventMonitor(Monitor event_monitor);
+void SetApiFunctionMonitor(Monitor function_monitor);
+void SetWebRequestMonitor(WebRequestMonitor web_request_monitor);
 
- protected:
-  virtual ~ApiActivityMonitor() {}
-};
+// Called when an API event is dispatched to an extension. May be called on any
+// thread.
+void OnApiEventDispatched(content::BrowserContext* browser_context,
+                          const std::string& extension_id,
+                          const std::string& event_name,
+                          const base::ListValue& event_args);
 
+// Called when an extension calls an API function. May be called on any thread.
+void OnApiFunctionCalled(content::BrowserContext* browser_context,
+                         const std::string& extension_id,
+                         const std::string& api_name,
+                         const base::ListValue& args);
+
+// Called when an extension uses the web request API.

[asargent_no_longer_on_chrome, 2016/06/20 22:13:11]

Looks like this can be called from IO thread - worth mentioning in the comment?

Also, it seems that browser_context we call this with comes from the void* we
use in io_thread_extension_message_filter.h - I guess we use void* instead of
BrowserContext* as a reminder that you're not on the UI thread and the pointer
might not be valid. Is that worth mentioning in the comment for this method?

[Devlin, 2016/06/21 17:07:51]

Added more comments.

+void OnWebRequestApiUsed(content::BrowserContext* browser_context,
+                         const std::string& extension_id,
+                         const GURL& url,
+                         bool is_incognito,
+                         const std::string& api_call,
+                         std::unique_ptr<base::DictionaryValue> details);
+
+}  // namespace activity_monitor
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_ACTIVITY_MONITOR_H_