Add extension event histogram values for messaging, webRequest, and webview.

extensions/browser/event_router.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 #define EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/scoped_observer.h"
 #include "base/values.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "extensions/browser/event_listener_map.h"
 #include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/event_filtering_info.h"
 #include "ipc/ipc_sender.h"
+#include "url/gurl.h"
 
 class GURL;
 class PrefService;
 
 namespace content {
 class BrowserContext;
 class RenderProcessHost;
 }
 
 namespace extensions {
@@ skipping 39 matching lines @@
 
   // Gets the EventRouter for |browser_context|.
   static EventRouter* Get(content::BrowserContext* browser_context);
 
   // Converts event names like "foo.onBar/123" into "foo.onBar". Event names
   // without a "/" are returned unchanged.
   static std::string GetBaseEventName(const std::string& full_event_name);
 
   // Sends an event via ipc_sender to the given extension. Can be called on any
   // thread.
-  static void DispatchEvent(IPC::Sender* ipc_sender,
-                            void* browser_context_id,
-                            const std::string& extension_id,
-                            const std::string& event_name,
-                            scoped_ptr<base::ListValue> event_args,
-                            UserGestureState user_gesture,
-                            const EventFilteringInfo& info);
+  //
+  // It is very rare to call this function directly. Instead use the instance
+  // methods BroadcastEvent or DispatchEventToExtension.
+  static void DispatchEventToSender(IPC::Sender* ipc_sender,
+                                    void* browser_context_id,
+                                    const GURL& url,

[Devlin, 2015/08/07 21:25:47]

We can kill the urls, now, right?

[not at google - send to devlin, 2015/08/10 20:48:33]

Good point.

+                                    const std::string& extension_id,
+                                    events::HistogramValue histogram_value,
+                                    const std::string& event_name,
+                                    scoped_ptr<base::ListValue> event_args,
+                                    UserGestureState user_gesture,
+                                    const EventFilteringInfo& info);
 
   // An EventRouter is shared between |browser_context| and its associated
   // incognito context. |extension_prefs| may be NULL in tests.
   EventRouter(content::BrowserContext* browser_context,
               ExtensionPrefs* extension_prefs);
   ~EventRouter() override;
 
   // Add or remove an extension as an event listener for |event_name|.
   //
   // Note that multiple extensions can share a process due to process
@@ skipping 73 matching lines @@
   // listener for it. NOTE: This should be used rarely, for dispatching events
   // to extensions that haven't had a chance to add their own listeners yet, eg:
   // newly installed extensions.
   void DispatchEventWithLazyListener(const std::string& extension_id,
                                      scoped_ptr<Event> event);
 
   // Record the Event Ack from the renderer. (One less event in-flight.)
   void OnEventAck(content::BrowserContext* context,
                   const std::string& extension_id);
 
+  // Reports UMA for an event dispatched to |extension| with histogram value
+  // |histogram_value|. Must be called on the UI thread.
+  //
+  // |did_enqueue| should be true if the event was queued waiting for a process
+  // to start, like an event page.
+  void ReportEvent(events::HistogramValue histogram_value,
+                   const Extension* extension,
+                   bool did_enqueue);
+
  private:
   friend class EventRouterTest;
 
   // The extension and process that contains the event listener for a given
   // event.
   struct ListenerProcess;
 
   // A map between an event name and a set of extensions that are listening
   // to that event.
   typedef std::map<std::string, std::set<ListenerProcess> > ListenerMap;
@@ skipping 24 matching lines @@
                            const Extension* extension,
                            UnloadedExtensionInfo::Reason reason) override;
 
   // Returns true if the given listener map contains a event listeners for
   // the given event. If |extension_id| is non-empty, we also check that that
   // extension is one of the listeners.
   bool HasEventListenerImpl(const ListenerMap& listeners,
                             const std::string& extension_id,
                             const std::string& event_name);
 
-  // Shared by DispatchEvent*. If |restrict_to_extension_id| is empty, the
-  // event is broadcast.
-  // An event that just came off the pending list may not be delayed again.
+  // Shared by all event dispatch methods. If |restrict_to_extension_id| is
+  // empty, the event is broadcast.  An event that just came off the pending
+  // list may not be delayed again.
   void DispatchEventImpl(const std::string& restrict_to_extension_id,
                          const linked_ptr<Event>& event);
 
   // Ensures that all lazy background pages that are interested in the given
   // event are loaded, and queues the event if the page is not ready yet.
   // Inserts an EventDispatchIdentifier into |already_dispatched| for each lazy
   // event dispatch that is queued.
   void DispatchLazyEvent(const std::string& extension_id,
                          const linked_ptr<Event>& event,
                          std::set<EventDispatchIdentifier>* already_dispatched,
                          const base::DictionaryValue* listener_filter);
 
   // Dispatches the event to the specified extension or URL running in
   // |process|.
   void DispatchEventToProcess(const std::string& extension_id,
                               const GURL& listener_url,
                               content::RenderProcessHost* process,
                               const linked_ptr<Event>& event,
-                              const base::DictionaryValue* listener_filter);
+                              const base::DictionaryValue* listener_filter,
+                              bool did_enqueue);
 
   // Returns false when the event is scoped to a context and the listening
   // extension does not have access to events from that context. Also fills
   // |event_args| with the proper arguments to send, which may differ if
   // the event crosses the incognito boundary.
   bool CanDispatchEventToBrowserContext(content::BrowserContext* context,
                                         const Extension* extension,
                                         const linked_ptr<Event>& event);
 
   // Possibly loads given extension's background page in preparation to
@@ skipping 21 matching lines @@
       const std::string& extension_id);
 
   // Track the dispatched events that have not yet sent an ACK from the
   // renderer.
   void IncrementInFlightEvents(content::BrowserContext* context,
                                const Extension* extension,
                                int event_id,
                                const std::string& event_name);
 
   // static
-  static void IncrementInFlightEventsOnUI(void* browser_context_id,
-                                          const std::string& extension_id,
-                                          int event_id,
-                                          const std::string& event_name);
+  static void DoDispatchEventToSenderBookkeepingOnUI(
+      void* browser_context_id,
+      const std::string& extension_id,
+      const GURL& url,
+      int event_id,
+      events::HistogramValue histogram_value,
+      const std::string& event_name);
 
   void DispatchPendingEvent(const linked_ptr<Event>& event,
                             ExtensionHost* host);
 
   // Implementation of EventListenerMap::Delegate.
   void OnListenerAdded(const EventListener* listener) override;
   void OnListenerRemoved(const EventListener* listener) override;
 
   // RenderProcessHostObserver implementation.
   void RenderProcessExited(content::RenderProcessHost* host,
@@ skipping 102 matching lines @@
   const std::string event_name;
 
   const std::string extension_id;
   const GURL listener_url;
   content::BrowserContext* browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_