Adds UMA for counting component event page wakeups.

extensions/browser/event_router_unittest.cc

 // Copyright 2013 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 <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/test/histogram_tester.h"
 #include "base/values.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/event_listener_map.h"
 #include "extensions/browser/extensions_test.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace {
 
 // A simple mock to keep track of listener additions and removals.
 class MockEventRouterObserver : public EventRouter::Observer {
  public:
   MockEventRouterObserver()
@@ skipping 47 matching lines @@
 
 scoped_ptr<EventListener> CreateEventListenerForURL(
     const GURL& listener_url,
     const std::string& event_name,
     content::RenderProcessHost* process,
     base::DictionaryValue* filter) {
   return EventListener::ForURL(
       event_name, listener_url, process, make_scoped_ptr(filter));
 }
 
+scoped_refptr<Extension> CreateExtension(bool component, bool persistent) {
+  scoped_ptr<base::DictionaryValue> manifest =
+      make_scoped_ptr(new base::DictionaryValue());
+  manifest->SetString("name", "foo");
+  manifest->SetString("version", "1.0.0");
+  manifest->SetInteger("manifest_version", 2);
+  manifest->SetString("background.page", "background.html");
+  manifest->SetBoolean("background.persistent", persistent);
+
+  ExtensionBuilder builder;
+  builder.SetManifest(std::move(manifest));
+  if (component)
+    builder.SetLocation(Manifest::Location::COMPONENT);
+
+  return builder.Build();
+}
+
 }  // namespace
 
 class EventRouterTest : public ExtensionsTest {
  public:
   EventRouterTest()
       : notification_service_(content::NotificationService::Create()) {}
 
  protected:
   // Tests adding and removing observers from EventRouter.
   void RunEventRouterObserverTest(const EventListenerConstructor& constructor);
 
+  // Tests that the correct counts are recorded for the Extensions.Events
+  // histograms.
+  void ExpectHistogramCounts(int dispatch_count,
+                             int component_count,
+                             int persistent_count,
+                             int suspended_count,
+                             int component_suspended_count,
+                             int running_count) {
+    if (dispatch_count) {
+      histogram_tester_.ExpectBucketCount("Extensions.Events.Dispatch",
+                                          events::HistogramValue::FOR_TEST,
+                                          dispatch_count);
+    }
+    if (component_count) {
+      histogram_tester_.ExpectBucketCount(
+          "Extensions.Events.DispatchToComponent",
+          events::HistogramValue::FOR_TEST, component_count);
+    }
+    if (persistent_count) {
+      histogram_tester_.ExpectBucketCount(
+          "Extensions.Events.DispatchWithPersistentBackgroundPage",
+          events::HistogramValue::FOR_TEST, persistent_count);
+    }
+    if (suspended_count) {
+      histogram_tester_.ExpectBucketCount(
+          "Extensions.Events.DispatchWithSuspendedEventPage",
+          events::HistogramValue::FOR_TEST, suspended_count);
+    }
+    if (component_suspended_count) {
+      histogram_tester_.ExpectBucketCount(
+          "Extensions.Events.DispatchToComponentWithSuspendedEventPage",
+          events::HistogramValue::FOR_TEST, component_suspended_count);
+    }
+    if (running_count) {
+      histogram_tester_.ExpectBucketCount(
+          "Extensions.Events.DispatchWithRunningEventPage",
+          events::HistogramValue::FOR_TEST, running_count);
+    }
+  }
+
  private:
   scoped_ptr<content::NotificationService> notification_service_;
+  content::TestBrowserThreadBundle thread_bundle_;
+  base::HistogramTester histogram_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRouterTest);
 };
 
 TEST_F(EventRouterTest, GetBaseEventName) {
   // Normal event names are passed through unchanged.
   EXPECT_EQ("foo.onBar", EventRouter::GetBaseEventName("foo.onBar"));
 
   // Sub-events are converted to the part before the slash.
   EXPECT_EQ("foo.onBar", EventRouter::GetBaseEventName("foo.onBar/123"));
@@ skipping 57 matching lines @@
 TEST_F(EventRouterTest, EventRouterObserverForExtensions) {
   RunEventRouterObserverTest(
       base::Bind(&CreateEventListenerForExtension, "extension_id"));
 }
 
 TEST_F(EventRouterTest, EventRouterObserverForURLs) {
   RunEventRouterObserverTest(
       base::Bind(&CreateEventListenerForURL, GURL("http://google.com/path")));
 }
 
+TEST_F(EventRouterTest, TestReportEvent) {
+  EventRouter router(browser_context(), NULL);
+  scoped_refptr<Extension> normal = test_util::CreateEmptyExtension("id1");
+  router.ReportEvent(events::HistogramValue::FOR_TEST, normal.get(),
+                     false /** did_enqueue */);
+  ExpectHistogramCounts(1 /** Dispatch */, 0 /** DispatchToComponent */,
+                        0 /** DispatchWithPersistentBackgroundPage */,
+                        0 /** DispatchWithSuspendedEventPage */,
+                        0 /** DispatchToComponentWithSuspendedEventPage */,
+                        0 /** DispatchWithRunningEventPage */);
+
+  scoped_refptr<Extension> component = CreateExtension(true, true);
+  router.ReportEvent(events::HistogramValue::FOR_TEST, component.get(),
+                     false /** did_enqueue */);
+  ExpectHistogramCounts(2, 1, 1, 0, 0, 0);
+
+  scoped_refptr<Extension> persistent = CreateExtension(false, true);
+  router.ReportEvent(events::HistogramValue::FOR_TEST, persistent.get(),
+                     false /** did_enqueue */);
+  ExpectHistogramCounts(3, 1, 2, 0, 0, 0);
+
+  scoped_refptr<Extension> event = CreateExtension(false, false);
+  router.ReportEvent(events::HistogramValue::FOR_TEST, event.get(),
+                     false /** did_enqueue */);
+  router.ReportEvent(events::HistogramValue::FOR_TEST, event.get(),
+                     true /** did_enqueue */);
+  ExpectHistogramCounts(5, 1, 2, 1, 0, 1);

[benwells, 2016/01/20 23:23:36]

Nit: Seems like having ExpectHistogramCounts(4, 1, 2, 0, 0, 1) (or whatever it
should be) between the two ReportEvents would make the difference between
enqueue being true and false explicitly tested. Same goes for the next block.

+
+  scoped_refptr<Extension> component_event = CreateExtension(true, false);
+  router.ReportEvent(events::HistogramValue::FOR_TEST, component_event.get(),
+                     false /** did_enqueue */);
+  router.ReportEvent(events::HistogramValue::FOR_TEST, component_event.get(),
+                     true /** did_enqueue */);
+  ExpectHistogramCounts(7, 3, 2, 2, 1, 2);
+}
+
 }  // namespace extensions