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/test/histogram_tester.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.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 "extensions/common/value_builder.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_ptr<base::DictionaryValue> CreateBackgroundManifest(bool persistent) {
+  scoped_ptr<base::DictionaryValue> manifest =
+    make_scoped_ptr(new base::DictionaryValue());
+  manifest->SetString("background.page", "background.html");
+  manifest->SetBoolean("background.persistent", persistent);
+  return manifest;

[imcheng, 2016/01/20 18:28:21]

It should compile if you changed this to:

std::move(manifest);

[mark a. foltz, 2016/01/20 21:58:07]

Thanks!  That was the fix.  It isn't clear to me yet when move-ing is done
implicitly and the error message if you don't is pretty obscure :)

+}
+
 }  // 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);
+  // TODO: Create component extensions w/ and w/out lazy background page
+  // Use ExtensionBuilder.
+  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 */);
+
+  ExtensionBuilder component_builder;
+  scoped_refptr<Extension> component = component_builder.
+    SetLocation(Manifest::Location::COMPONENT).Build();
+  router.ReportEvent(events::HistogramValue::FOR_TEST,
+                     component.get(),
+                     false  /** did_enqueue */);
+  ExpectHistogramCounts(2, 1, 0, 0, 0, 0);
+
+  ExtensionBuilder persistent_builder;
+  scoped_ptr<base::DictionaryValue> persistent_manifest =
+    CreateBackgroundManifest(true);
+
+  scoped_refptr<Extension> persistent = persistent_builder.
+    SetManifest(persistent_manifest).Build();
+  router.ReportEvent(events::HistogramValue::FOR_TEST,
+                     persistent.get(),
+                     false  /** did_enqueue */);
+  ExpectHistogramCounts(3, 1, 1, 0, 0, 0);
+
+  // ExtensionBuilder event_builder;
+  // scoped_refptr<Extension> event = event_builder.
+  //   SetManifest(CreateBackgroundManifest(false)).Build();
+  // router.ReportEvent(events::HistogramValue::FOR_TEST,
+  //                    event.get(),
+  //                    false  /** did_enqueue */);
+  // router.ReportEvent(events::HistogramValue::FOR_TEST,
+  //                    event.get(),
+  //                    true  /** did_enqueue */);
+  // ExpectHistogramCounts(4, 1, 1, 1, 0, 1);
+
+  // ExtensionBuilder component_event_builder;
+  // scoped_refptr<Extension> component_event = component_event_builder.
+  //   SetLocation(Manifest::Location::COMPONENT).
+  //   SetManifest(CreateBackgroundManifest(false)).Build();
+  // 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(5, 2, 1, 2, 1, 2);
+}
+
 }  // namespace extensions