Added UMA stats for extensions events on addListener.

chrome/browser/extensions/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 "chrome/browser/extensions/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/activity_log.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/extensions/system_info_event_router.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/extension_api.h"
+#include "chrome/common/extensions/api/generated_api.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/view_type.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 
 using base::Value;
 using content::BrowserThread;
 
 namespace extensions {
@@ skipping 136 matching lines @@
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_));
 
+  extensions::api::GeneratedEventHistogramMap::
+    AddAll(histogram_values_);
+
   // NULL in unit_tests.
   if (extension_prefs) {
     // Check if registered events are up-to-date. We need to do this before
     // reading the registered events, because it deletes them if they're out of
     // date.
     dispatch_chrome_updated_event_ =
         !extension_prefs->CheckRegisteredEventsUpToDate();
   }
 }
 
 EventRouter::~EventRouter() {}
 
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
       event_name, extension_id, process, scoped_ptr<DictionaryValue>())));
+  RecordEventListenerAdded(event_name);

[koz (OOO until 15th September), 2013/03/13 01:00:27]

This might be trickier than it seems. Extensions / apps with lazy listeners will
repeatedly call AddEventListener() because they will be loaded and unloaded many
times. When a non-persistent extension is loaded it will add both a lazy
listener and a regular listener.

One way to solve this might be to distinguish between persistent and
non-persistent extensions and track listener adds for the former and lazy
listener adds for the later.

But even that has the problem that whenever the browser starts persistent
extensions will call AddEventListener() again and we will track it again. This
might not be too bad as we might reason that on average all persistent
extensions are going to be restarted roughly the same number of times, so that
can be factored out, but it's still quite dodgy...

We should clarify what we intend to find out from these statistics. If we want
to measure API usage there might be another way (eg: grep over the webstore)...

 }
 
 void EventRouter::RemoveEventListener(const std::string& event_name,
                                       content::RenderProcessHost* process,
                                       const std::string& extension_id) {
   EventListener listener(event_name, extension_id, process,
                          scoped_ptr<DictionaryValue>());
   listeners_.RemoveListener(&listener);
 }
 
@@ skipping 89 matching lines @@
   if (did_exist) {
     ExtensionPrefs* prefs = extensions::ExtensionSystem::Get(profile_)->
         extension_service()->extension_prefs();
     std::set<std::string> events = prefs->GetRegisteredEvents(extension_id);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     prefs->SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::AddFilteredEventListener(const std::string& event_name,

[koz (OOO until 15th September), 2013/03/13 01:00:27]

You'll need to record filtered event listeners being added here, too.

                                            content::RenderProcessHost* process,
                                            const std::string& extension_id,
                                            const base::DictionaryValue& filter,
                                            bool add_lazy_listener) {
   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
       event_name, extension_id, process,
       scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 
   if (add_lazy_listener) {
     bool added = listeners_.AddListener(scoped_ptr<EventListener>(
@@ skipping 259 matching lines @@
   if (!host)
     return;
 
   if (listeners_.HasProcessListener(host->render_process_host(),
                                     host->extension()->id())) {
     DispatchEventToProcess(host->extension()->id(),
                            host->render_process_host(), event);
   }
 }
 
+void EventRouter::RecordEventListenerAdded(const std::string& event_name) {
+  UMA_HISTOGRAM_ENUMERATION("Extensions.AddEventListener",
+      histogram_values_[event_name], extensions::events::ENUM_BOUNDARY);
+}
+
 void EventRouter::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
       content::RenderProcessHost* renderer =
           content::Source<content::RenderProcessHost>(source).ptr();
       // Remove all event listeners associated with this renderer.
       listeners_.RemoveListenersForProcess(renderer);
@@ skipping 115 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions