Adds UMA for counting component event page wakeups.

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 742 matching lines @@
 
 void EventRouter::ReportEvent(events::HistogramValue histogram_value,
                               const Extension* extension,
                               bool did_enqueue) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Record every event fired.
   UMA_HISTOGRAM_ENUMERATION("Extensions.Events.Dispatch", histogram_value,
                             events::ENUM_BOUNDARY);
 
+  bool is_component = Manifest::IsComponentLocation(extension->location());
+
   // Record events for component extensions. These should be kept to a minimum,
   // especially if they wake its event page. Component extensions should use
   // declarative APIs as much as possible.
-  if (Manifest::IsComponentLocation(extension->location())) {
+  if (is_component) {
     UMA_HISTOGRAM_ENUMERATION("Extensions.Events.DispatchToComponent",
                               histogram_value, events::ENUM_BOUNDARY);
   }
 
   // Record events for background pages, if any. The most important statistic
   // is DispatchWithSuspendedEventPage. Events reported there woke an event
   // page. Implementing either filtered or declarative versions of these events
   // should be prioritised.
   //
   // Note: all we know is that the extension *has* a persistent or event page,
   // not that the event is being dispatched *to* such a page. However, this is
   // academic, since extensions with any background page have that background
   // page running (or in the case of suspended event pages, must be started)
   // regardless of where the event is being dispatched. Events are dispatched
   // to a *process* not a *frame*.
   if (BackgroundInfo::HasPersistentBackgroundPage(extension)) {
     UMA_HISTOGRAM_ENUMERATION(
         "Extensions.Events.DispatchWithPersistentBackgroundPage",
         histogram_value, events::ENUM_BOUNDARY);
   } else if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
     if (did_enqueue) {
       UMA_HISTOGRAM_ENUMERATION(
           "Extensions.Events.DispatchWithSuspendedEventPage", histogram_value,
           events::ENUM_BOUNDARY);
+      if (is_component) {
+        UMA_HISTOGRAM_ENUMERATION(
+            "Extensions.Events.DispatchToComponentWithSuspendedEventPage",
+            histogram_value,
+            events::ENUM_BOUNDARY);
+      }
     } else {
       UMA_HISTOGRAM_ENUMERATION(
           "Extensions.Events.DispatchWithRunningEventPage", histogram_value,
           events::ENUM_BOUNDARY);
     }
   }
 }
 
 void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
                                        ExtensionHost* host) {
@@ skipping 103 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