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,
+                                    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 with histogram value |histogram_value|.
+  // Must be called on the UI thread.
+  //
+  // The target of the event - extension background page, view, webui, etc -
+  // can be determined by the |process_id| and |url| tuple. If the URL is

[Devlin, 2015/08/05 21:34:09]

What process id?

[not at google - send to devlin, 2015/08/07 20:55:03]

Fixed.

+  // unknown, which may be the case for hand-written events (like messaging),
+  // it may be blank.
+  //
+  // |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 GURL& url,
+                   bool did_enqueue);
+
  private:
   friend class EventRouterTest;
 
+  enum ExtensionPageType {
+    EXTENSION_PAGE_NONE,
+    EXTENSION_PAGE_VIEW,
+    EXTENSION_PAGE_PERSISTENT_BACKGROUND,
+    EXTENSION_PAGE_DORMANT_EVENT,
+    EXTENSION_PAGE_AWAKE_EVENT,
+  };
+
   // 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;
 
   // An identifier for an event dispatch that is used to prevent double dispatch
   // due to race conditions between the direct and lazy dispatch paths.
   typedef std::pair<const content::BrowserContext*, std::string>
       EventDispatchIdentifier;
 
   // TODO(gdk): Document this.
   static void DispatchExtensionMessage(
       IPC::Sender* ipc_sender,
       void* browser_context_id,
       const std::string& extension_id,
       int event_id,
       const std::string& event_name,
       base::ListValue* event_args,
       UserGestureState user_gesture,
       const extensions::EventFilteringInfo& info);
 
+  ExtensionPageType GetExtensionPageType(const Extension* extension,
+                                         const GURL& url,
+                                         bool did_enqueue);
+
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
   // ExtensionRegistryObserver implementation.
   void OnExtensionLoaded(content::BrowserContext* browser_context,
                          const Extension* extension) override;
   void OnExtensionUnloaded(content::BrowserContext* browser_context,
                            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_