Final batch adding real histogram values for extension events.

BUG=503402
R=rdevlin.cronin@chromium.org, asvitkine@chromium.org

Review URL: https://codereview.chromium.org/1236493004

Cr-Commit-Position: refs/heads/master@{#339905}

46 files changed, 537 insertions, 404 deletions

diff --git a/chrome/browser/extensions/api/automation_internal/automation_util.cc b/chrome/browser/extensions/api/automation_internal/automation_util.cc
index cbd2f9b..a16654b 100644
--- a/chrome/browser/extensions/api/automation_internal/automation_util.cc
+++ b/chrome/browser/extensions/api/automation_internal/automation_util.cc
@@ -116,11 +116,12 @@ void PopulateNodeData(const ui::AXNodeData& node_data,
 }
 
 void DispatchEventInternal(content::BrowserContext* context,
+                           events::HistogramValue histogram_value,
                            const std::string& event_name,
                            scoped_ptr<base::ListValue> args) {
   if (context && EventRouter::Get(context)) {
     scoped_ptr<Event> event(
-        new Event(events::UNKNOWN, event_name, args.Pass()));
+        new Event(histogram_value, event_name, args.Pass()));
     event->restrict_to_browser_context = context;
     EventRouter::Get(context)->BroadcastEvent(event.Pass());
   }
@@ -188,7 +189,7 @@ void DispatchAccessibilityEventsToAutomation(
     // collection of tree updates over (to the extension); see
     // |AccessibilityHostMsg_EventParams| and |AccessibilityHostMsg_Events|.
     DispatchEventInternal(
-        browser_context,
+        browser_context, events::AUTOMATION_INTERNAL_ON_ACCESSIBILITY_EVENT,
         api::automation_internal::OnAccessibilityEvent::kEventName,
         api::automation_internal::OnAccessibilityEvent::Create(
             ax_event_params));
@@ -203,6 +204,7 @@ void DispatchTreeDestroyedEventToAutomation(
       process_id, routing_id);
   DispatchEventInternal(
       browser_context,
+      events::AUTOMATION_INTERNAL_ON_ACCESSIBILITY_TREE_DESTROYED,
       api::automation_internal::OnAccessibilityTreeDestroyed::kEventName,
       api::automation_internal::OnAccessibilityTreeDestroyed::Create(tree_id));
   AXTreeIDRegistry::GetInstance()->RemoveAXTreeID(tree_id);
diff --git a/chrome/browser/extensions/api/font_settings/font_settings_api.cc b/chrome/browser/extensions/api/font_settings/font_settings_api.cc
index bd9b1ec..4f0d7c9 100644
--- a/chrome/browser/extensions/api/font_settings/font_settings_api.cc
+++ b/chrome/browser/extensions/api/font_settings/font_settings_api.cc
@@ -102,14 +102,15 @@ FontSettingsEventRouter::FontSettingsEventRouter(
   registrar_.Init(profile_->GetPrefs());
 
   AddPrefToObserve(prefs::kWebKitDefaultFixedFontSize,
+                   events::FONT_SETTINGS_ON_DEFAULT_FIXED_FONT_SIZE_CHANGED,
                    fonts::OnDefaultFixedFontSizeChanged::kEventName,
                    kPixelSizeKey);
   AddPrefToObserve(prefs::kWebKitDefaultFontSize,
-                   fonts::OnDefaultFontSizeChanged::kEventName,
-                   kPixelSizeKey);
+                   events::FONT_SETTINGS_ON_DEFAULT_FONT_SIZE_CHANGED,
+                   fonts::OnDefaultFontSizeChanged::kEventName, kPixelSizeKey);
   AddPrefToObserve(prefs::kWebKitMinimumFontSize,
-                   fonts::OnMinimumFontSizeChanged::kEventName,
-                   kPixelSizeKey);
+                   events::FONT_SETTINGS_ON_MINIMUM_FONT_SIZE_CHANGED,
+                   fonts::OnMinimumFontSizeChanged::kEventName, kPixelSizeKey);
 
   PrefChangeRegistrar::NamedChangeCallback callback =
       base::Bind(&FontSettingsEventRouter::OnFontFamilyMapPrefChanged,
@@ -133,13 +134,15 @@ FontSettingsEventRouter::FontSettingsEventRouter(
 
 FontSettingsEventRouter::~FontSettingsEventRouter() {}
 
-void FontSettingsEventRouter::AddPrefToObserve(const char* pref_name,
-                                               const char* event_name,
-                                               const char* key) {
-  registrar_.Add(pref_name,
-                 base::Bind(&FontSettingsEventRouter::OnFontPrefChanged,
-                            base::Unretained(this),
-                            event_name, key));
+void FontSettingsEventRouter::AddPrefToObserve(
+    const char* pref_name,
+    events::HistogramValue histogram_value,
+    const char* event_name,
+    const char* key) {
+  registrar_.Add(
+      pref_name,
+      base::Bind(&FontSettingsEventRouter::OnFontPrefChanged,
+                 base::Unretained(this), histogram_value, event_name, key));
 }
 
 void FontSettingsEventRouter::OnFontFamilyMapPrefChanged(
@@ -178,15 +181,13 @@ void FontSettingsEventRouter::OnFontNamePrefChanged(
   dict->SetString(kScriptKey, script);
 
   extensions::preference_helpers::DispatchEventToExtensions(
-      profile_,
-      fonts::OnFontChanged::kEventName,
-      &args,
-      APIPermission::kFontSettings,
-      false,
-      pref_name);
+      profile_, events::FONT_SETTINGS_ON_FONT_CHANGED,
+      fonts::OnFontChanged::kEventName, &args, APIPermission::kFontSettings,
+      false, pref_name);
 }
 
 void FontSettingsEventRouter::OnFontPrefChanged(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     const std::string& key,
     const std::string& pref_name) {
@@ -200,12 +201,8 @@ void FontSettingsEventRouter::OnFontPrefChanged(
   dict->Set(key, pref->GetValue()->DeepCopy());
 
   extensions::preference_helpers::DispatchEventToExtensions(
-      profile_,
-      event_name,
-      &args,
-      APIPermission::kFontSettings,
-      false,
-      pref_name);
+      profile_, histogram_value, event_name, &args,
+      APIPermission::kFontSettings, false, pref_name);
 }
 
 FontSettingsAPI::FontSettingsAPI(content::BrowserContext* context)
diff --git a/chrome/browser/extensions/api/font_settings/font_settings_api.h b/chrome/browser/extensions/api/font_settings/font_settings_api.h
index 8d506fe..77f3f38 100644
--- a/chrome/browser/extensions/api/font_settings/font_settings_api.h
+++ b/chrome/browser/extensions/api/font_settings/font_settings_api.h
@@ -16,6 +16,7 @@
 #include "chrome/browser/extensions/chrome_extension_function.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 
 class Profile;
 
@@ -40,6 +41,7 @@ class FontSettingsEventRouter {
   // event |event_name| to extensions. A JavaScript object is passed to the
   // extension event function with the new value of the pref in property |key|.
   void AddPrefToObserve(const char* pref_name,
+                        events::HistogramValue histogram_value,
                         const char* event_name,
                         const char* key);
 
@@ -58,7 +60,8 @@ class FontSettingsEventRouter {
   // value of the setting is the value of browser pref |pref_name|. This value
   // is passed in the JavaScript object argument to the extension event function
   // under the key |key|.
-  void OnFontPrefChanged(const std::string& event_name,
+  void OnFontPrefChanged(events::HistogramValue histogram_value,
+                         const std::string& event_name,
                          const std::string& key,
                          const std::string& pref_name);
 
diff --git a/chrome/browser/extensions/api/input_ime/input_ime_api.cc b/chrome/browser/extensions/api/input_ime/input_ime_api.cc
index cded280..9cfa878 100644
--- a/chrome/browser/extensions/api/input_ime/input_ime_api.cc
+++ b/chrome/browser/extensions/api/input_ime/input_ime_api.cc
@@ -112,7 +112,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
         component_id,
         input_ime::ParseScreenType(GetCurrentScreenType())));
 
-    DispatchEventToExtension(input_ime::OnActivate::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_ACTIVATE,
+                             input_ime::OnActivate::kEventName, args.Pass());
   }
 
   void OnDeactivated(const std::string& component_id) override {
@@ -123,7 +124,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
     scoped_ptr<base::ListValue> args(
         input_ime::OnDeactivated::Create(component_id));
 
-    DispatchEventToExtension(input_ime::OnDeactivated::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_DEACTIVATED,
+                             input_ime::OnDeactivated::kEventName, args.Pass());
   }
 
   void OnFocus(
@@ -140,7 +142,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
 
     scoped_ptr<base::ListValue> args(input_ime::OnFocus::Create(context_value));
 
-    DispatchEventToExtension(input_ime::OnFocus::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_FOCUS,
+                             input_ime::OnFocus::kEventName, args.Pass());
   }
 
   void OnBlur(int context_id) override {
@@ -149,7 +152,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
 
     scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
-    DispatchEventToExtension(input_ime::OnBlur::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_BLUR,
+                             input_ime::OnBlur::kEventName, args.Pass());
   }
 
   void OnInputContextUpdate(
@@ -165,8 +169,9 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
     scoped_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
-    DispatchEventToExtension(input_ime::OnInputContextUpdate::kEventName,
-                             args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_IME_ON_INPUT_CONTEXT_UPDATE,
+        input_ime::OnInputContextUpdate::kEventName, args.Pass());
   }
 
   bool IsInterestedInKeyEvent() const override {
@@ -206,7 +211,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
     scoped_ptr<base::ListValue> args(
         input_ime::OnKeyEvent::Create(component_id, key_data_value));
 
-    DispatchEventToExtension(input_ime::OnKeyEvent::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_KEY_EVENT,
+                             input_ime::OnKeyEvent::kEventName, args.Pass());
   }
 
   void OnCandidateClicked(
@@ -237,7 +243,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
     scoped_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
         component_id, candidate_id, button_enum));
 
-    DispatchEventToExtension(input_ime::OnCandidateClicked::kEventName,
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_CANDIDATE_CLICKED,
+                             input_ime::OnCandidateClicked::kEventName,
                              args.Pass());
   }
 
@@ -250,8 +257,9 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
     scoped_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
-    DispatchEventToExtension(input_ime::OnMenuItemActivated::kEventName,
-                             args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_IME_ON_MENU_ITEM_ACTIVATED,
+        input_ime::OnMenuItemActivated::kEventName, args.Pass());
   }
 
   void OnSurroundingTextChanged(const std::string& component_id,
@@ -269,8 +277,9 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
     scoped_ptr<base::ListValue> args(
         input_ime::OnSurroundingTextChanged::Create(component_id, info));
 
-    DispatchEventToExtension(input_ime::OnSurroundingTextChanged::kEventName,
-                             args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_IME_ON_SURROUNDING_TEXT_CHANGED,
+        input_ime::OnSurroundingTextChanged::kEventName, args.Pass());
   }
 
   void OnCompositionBoundsChanged(
@@ -301,7 +310,9 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
       args->Append(first_value->DeepCopy());
     args->Append(bounds_list);
 
-    DispatchEventToExtension(kOnCompositionBoundsChangedEventName, args.Pass());
+    DispatchEventToExtension(
+        extensions::events::INPUT_METHOD_PRIVATE_ON_COMPOSITION_BOUNDS_CHANGED,
+        kOnCompositionBoundsChangedEventName, args.Pass());
   }
 
   void OnReset(const std::string& component_id) override {
@@ -310,12 +321,15 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
 
     scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(component_id));
 
-    DispatchEventToExtension(input_ime::OnReset::kEventName, args.Pass());
+    DispatchEventToExtension(extensions::events::INPUT_IME_ON_RESET,
+                             input_ime::OnReset::kEventName, args.Pass());
   }
 
  private:
-  void DispatchEventToExtension(const std::string& event_name,
-                                scoped_ptr<base::ListValue> args) {
+  void DispatchEventToExtension(
+      extensions::events::HistogramValue histogram_value,
+      const std::string& event_name,
+      scoped_ptr<base::ListValue> args) {
     if (event_name != input_ime::OnActivate::kEventName) {
       // For suspended IME extension (e.g. XKB extension), don't awake it by IME
       // events except onActivate. The IME extension should be awake by other
@@ -339,8 +353,8 @@ class ImeObserver : public InputMethodEngineInterface::Observer {
       }
     }
 
-    scoped_ptr<extensions::Event> event(new extensions::Event(
-        extensions::events::UNKNOWN, event_name, args.Pass()));
+    scoped_ptr<extensions::Event> event(
+        new extensions::Event(histogram_value, event_name, args.Pass()));
     event->restrict_to_browser_context = profile_;
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, event.Pass());
diff --git a/chrome/browser/extensions/api/location/location_manager.cc b/chrome/browser/extensions/api/location/location_manager.cc
index a5cd40f..e3015a7 100644
--- a/chrome/browser/extensions/api/location/location_manager.cc
+++ b/chrome/browser/extensions/api/location/location_manager.cc
@@ -313,6 +313,7 @@ void LocationManager::SendLocationUpdate(
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
+  events::HistogramValue histogram_value = events::UNKNOWN;
   std::string event_name;
 
   if (position.Validate() &&
@@ -324,15 +325,17 @@ void LocationManager::SendLocationUpdate(
     location.timestamp = position.timestamp.ToJsTime();
 
     args->Append(location.ToValue().release());
+    histogram_value = events::LOCATION_ON_LOCATION_UPDATE;
     event_name = location::OnLocationUpdate::kEventName;
   } else {
     // Set data for onLocationError event.
     // TODO(vadimt): Set name.
     args->AppendString(position.error_message);
+    histogram_value = events::LOCATION_ON_LOCATION_ERROR;
     event_name = location::OnLocationError::kEventName;
   }
 
-  scoped_ptr<Event> event(new Event(events::UNKNOWN, event_name, args.Pass()));
+  scoped_ptr<Event> event(new Event(histogram_value, event_name, args.Pass()));
 
   EventRouter::Get(browser_context_)
       ->DispatchEventToExtension(extension_id, event.Pass());
diff --git a/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc b/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc
index 9daa4d9..6c48ca2 100644
--- a/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc
+++ b/chrome/browser/extensions/api/media_galleries/media_galleries_api.cc
@@ -347,7 +347,7 @@ void MediaGalleriesEventRouter::OnScanStarted(const std::string& extension_id) {
   MediaGalleries::ScanProgressDetails details;
   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_START;
   DispatchEventToExtension(
-      extension_id,
+      extension_id, events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
       MediaGalleries::OnScanProgress::kEventName,
       MediaGalleries::OnScanProgress::Create(details).Pass());
 }
@@ -357,7 +357,7 @@ void MediaGalleriesEventRouter::OnScanCancelled(
   MediaGalleries::ScanProgressDetails details;
   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_CANCEL;
   DispatchEventToExtension(
-      extension_id,
+      extension_id, events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
       MediaGalleries::OnScanProgress::kEventName,
       MediaGalleries::OnScanProgress::Create(details).Pass());
 }
@@ -373,7 +373,7 @@ void MediaGalleriesEventRouter::OnScanFinished(
   details.image_count.reset(new int(file_counts.image_count));
   details.video_count.reset(new int(file_counts.video_count));
   DispatchEventToExtension(
-      extension_id,
+      extension_id, events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
       MediaGalleries::OnScanProgress::kEventName,
       MediaGalleries::OnScanProgress::Create(details).Pass());
 }
@@ -383,13 +383,14 @@ void MediaGalleriesEventRouter::OnScanError(
   MediaGalleries::ScanProgressDetails details;
   details.type = MediaGalleries::SCAN_PROGRESS_TYPE_ERROR;
   DispatchEventToExtension(
-      extension_id,
+      extension_id, events::MEDIA_GALLERIES_ON_SCAN_PROGRESS,
       MediaGalleries::OnScanProgress::kEventName,
       MediaGalleries::OnScanProgress::Create(details).Pass());
 }
 
 void MediaGalleriesEventRouter::DispatchEventToExtension(
     const std::string& extension_id,
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ -402,8 +403,8 @@ void MediaGalleriesEventRouter::DispatchEventToExtension(
   if (!router->ExtensionHasEventListener(extension_id, event_name))
     return;
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      extensions::events::UNKNOWN, event_name, event_args.Pass()));
+  scoped_ptr<extensions::Event> event(
+      new extensions::Event(histogram_value, event_name, event_args.Pass()));
   router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
@@ -413,7 +414,7 @@ void MediaGalleriesEventRouter::OnGalleryChanged(
   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_CONTENTS_CHANGED;
   details.gallery_id = base::Uint64ToString(gallery_id);
   DispatchEventToExtension(
-      extension_id,
+      extension_id, events::MEDIA_GALLERIES_ON_GALLERY_CHANGED,
       MediaGalleries::OnGalleryChanged::kEventName,
       MediaGalleries::OnGalleryChanged::Create(details).Pass());
 }
@@ -424,7 +425,7 @@ void MediaGalleriesEventRouter::OnGalleryWatchDropped(
   details.type = MediaGalleries::GALLERY_CHANGE_TYPE_WATCH_DROPPED;
   details.gallery_id = gallery_id;
   DispatchEventToExtension(
-      extension_id,
+      extension_id, events::MEDIA_GALLERIES_ON_GALLERY_CHANGED,
       MediaGalleries::OnGalleryChanged::kEventName,
       MediaGalleries::OnGalleryChanged::Create(details).Pass());
 }
diff --git a/chrome/browser/extensions/api/media_galleries/media_galleries_api.h b/chrome/browser/extensions/api/media_galleries/media_galleries_api.h
index 95ab476..f1c142b 100644
--- a/chrome/browser/extensions/api/media_galleries/media_galleries_api.h
+++ b/chrome/browser/extensions/api/media_galleries/media_galleries_api.h
@@ -23,6 +23,7 @@
 #include "components/storage_monitor/media_storage_util.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 
 namespace MediaGalleries = extensions::api::media_galleries;
 
@@ -73,6 +74,7 @@ class MediaGalleriesEventRouter : public BrowserContextKeyedAPI,
   friend class BrowserContextKeyedAPIFactory<MediaGalleriesEventRouter>;
 
   void DispatchEventToExtension(const std::string& extension_id,
+                                events::HistogramValue histogram_value,
                                 const std::string& event_name,
                                 scoped_ptr<base::ListValue> event_args);
 
diff --git a/chrome/browser/extensions/api/notifications/notifications_api.cc b/chrome/browser/extensions/api/notifications/notifications_api.cc
index 0cbde41..6ca149d 100644
--- a/chrome/browser/extensions/api/notifications/notifications_api.cc
+++ b/chrome/browser/extensions/api/notifications/notifications_api.cc
@@ -147,14 +147,15 @@ class NotificationsApiDelegate : public NotificationDelegate {
                 : EventRouter::USER_GESTURE_NOT_ENABLED;
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->Append(new base::FundamentalValue(by_user));
-    SendEvent(notifications::OnClosed::kEventName, gesture, args.Pass());
+    SendEvent(events::NOTIFICATIONS_ON_CLOSED,
+              notifications::OnClosed::kEventName, gesture, args.Pass());
   }
 
   void Click() override {
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
-    SendEvent(notifications::OnClicked::kEventName,
-              EventRouter::USER_GESTURE_ENABLED,
-              args.Pass());
+    SendEvent(events::NOTIFICATIONS_ON_CLICKED,
+              notifications::OnClicked::kEventName,
+              EventRouter::USER_GESTURE_ENABLED, args.Pass());
   }
 
   bool HasClickedListener() override {
@@ -168,9 +169,9 @@ class NotificationsApiDelegate : public NotificationDelegate {
   void ButtonClick(int index) override {
     scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->Append(new base::FundamentalValue(index));
-    SendEvent(notifications::OnButtonClicked::kEventName,
-              EventRouter::USER_GESTURE_ENABLED,
-              args.Pass());
+    SendEvent(events::NOTIFICATIONS_ON_BUTTON_CLICKED,
+              notifications::OnButtonClicked::kEventName,
+              EventRouter::USER_GESTURE_ENABLED, args.Pass());
   }
 
   std::string id() const override { return scoped_id_; }
@@ -178,13 +179,14 @@ class NotificationsApiDelegate : public NotificationDelegate {
  private:
   ~NotificationsApiDelegate() override {}
 
-  void SendEvent(const std::string& name,
+  void SendEvent(events::HistogramValue histogram_value,
+                 const std::string& name,
                  EventRouter::UserGestureState user_gesture,
                  scoped_ptr<base::ListValue> args) {
     if (!event_router_)
       return;
 
-    scoped_ptr<Event> event(new Event(events::UNKNOWN, name, args.Pass()));
+    scoped_ptr<Event> event(new Event(histogram_value, name, args.Pass()));
     event->user_gesture = user_gesture;
     event_router_->DispatchEventToExtension(extension_id_, event.Pass());
   }
diff --git a/chrome/browser/extensions/api/preference/chrome_direct_setting_api.cc b/chrome/browser/extensions/api/preference/chrome_direct_setting_api.cc
index 41a4cdf..20030ae 100644
--- a/chrome/browser/extensions/api/preference/chrome_direct_setting_api.cc
+++ b/chrome/browser/extensions/api/preference/chrome_direct_setting_api.cc
@@ -145,8 +145,19 @@ void ChromeDirectSettingAPI::OnPrefChanged(
       const std::string& extension_id = extension->id();
       if (router->ExtensionHasEventListener(extension_id, event_name)) {
         scoped_ptr<base::ListValue> args_copy(args.DeepCopy());
+        // TODO(kalman): Have a histogram value for each pref type.
+        // This isn't so important for the current use case of these
+        // histograms, which is to track which event types are waking up event
+        // pages, or which are delivered to persistent background pages. Simply
+        // "a setting changed" is enough detail for that. However if we try to
+        // use these histograms for any fine-grained logic (like removing the
+        // string event name altogether), or if we discover this event is
+        // firing a lot and want to understand that better, then this will need
+        // to change.
+        events::HistogramValue histogram_value =
+            events::TYPES_PRIVATE_CHROME_DIRECT_SETTING_ON_CHANGE;
         scoped_ptr<Event> event(
-            new Event(events::UNKNOWN, event_name, args_copy.Pass()));
+            new Event(histogram_value, event_name, args_copy.Pass()));
         router->DispatchEventToExtension(extension_id, event.Pass());
       }
     }
diff --git a/chrome/browser/extensions/api/preference/preference_api.cc b/chrome/browser/extensions/api/preference/preference_api.cc
index 0fd2454..ac80eb4 100644
--- a/chrome/browser/extensions/api/preference/preference_api.cc
+++ b/chrome/browser/extensions/api/preference/preference_api.cc
@@ -380,11 +380,19 @@ void PreferenceEventRouter::OnPrefChanged(PrefService* pref_service,
                      ep->HasIncognitoPrefValue(browser_pref));
   }
 
-  helpers::DispatchEventToExtensions(profile_,
-                                     event_name,
-                                     &args,
-                                     permission,
-                                     incognito,
+  // TODO(kalman): Have a histogram value for each pref type.
+  // This isn't so important for the current use case of these
+  // histograms, which is to track which event types are waking up event
+  // pages, or which are delivered to persistent background pages. Simply
+  // "a setting changed" is enough detail for that. However if we try to
+  // use these histograms for any fine-grained logic (like removing the
+  // string event name altogether), or if we discover this event is
+  // firing a lot and want to understand that better, then this will need
+  // to change.
+  events::HistogramValue histogram_value =
+      events::TYPES_CHROME_SETTING_ON_CHANGE;
+  helpers::DispatchEventToExtensions(profile_, histogram_value, event_name,
+                                     &args, permission, incognito,
                                      browser_pref);
 }
 
diff --git a/chrome/browser/extensions/api/preference/preference_helpers.cc b/chrome/browser/extensions/api/preference/preference_helpers.cc
index 7f78ddc..7993e39 100644
--- a/chrome/browser/extensions/api/preference/preference_helpers.cc
+++ b/chrome/browser/extensions/api/preference/preference_helpers.cc
@@ -82,13 +82,13 @@ const char* GetLevelOfControl(
   return kControlledByOtherExtensions;
 }
 
-void DispatchEventToExtensions(
-    Profile* profile,
-    const std::string& event_name,
-    base::ListValue* args,
-    APIPermission::ID permission,
-    bool incognito,
-    const std::string& browser_pref) {
+void DispatchEventToExtensions(Profile* profile,
+                               events::HistogramValue histogram_value,
+                               const std::string& event_name,
+                               base::ListValue* args,
+                               APIPermission::ID permission,
+                               bool incognito,
+                               const std::string& browser_pref) {
   EventRouter* router = EventRouter::Get(profile);
   if (!router || !router->HasEventListener(event_name))
     return;
@@ -127,7 +127,7 @@ void DispatchEventToExtensions(
 
       scoped_ptr<base::ListValue> args_copy(args->DeepCopy());
       scoped_ptr<Event> event(
-          new Event(events::UNKNOWN, event_name, args_copy.Pass()));
+          new Event(histogram_value, event_name, args_copy.Pass()));
       event->restrict_to_browser_context = restrict_to_profile;
       router->DispatchEventToExtension(extension->id(), event.Pass());
     }
diff --git a/chrome/browser/extensions/api/preference/preference_helpers.h b/chrome/browser/extensions/api/preference/preference_helpers.h
index ba227af..02d77ec 100644
--- a/chrome/browser/extensions/api/preference/preference_helpers.h
+++ b/chrome/browser/extensions/api/preference/preference_helpers.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_prefs_scope.h"
 #include "extensions/common/permissions/permission_set.h"
 
@@ -35,13 +36,13 @@ const char* GetLevelOfControl(
 // key-value for the level of control the extension has over |browser_pref| is
 // injected into the first item of |args|, which must be of type
 // DictionaryValue.
-void DispatchEventToExtensions(
-    Profile* profile,
-    const std::string& event_name,
-    base::ListValue* args,
-    extensions::APIPermission::ID permission,
-    bool incognito,
-    const std::string& browser_pref);
+void DispatchEventToExtensions(Profile* profile,
+                               events::HistogramValue histogram_value,
+                               const std::string& event_name,
+                               base::ListValue* args,
+                               extensions::APIPermission::ID permission,
+                               bool incognito,
+                               const std::string& browser_pref);
 
 }  // namespace preference_helpers
 }  // namespace extensions
diff --git a/chrome/browser/extensions/api/processes/processes_api.cc b/chrome/browser/extensions/api/processes/processes_api.cc
index a80b604..2c1b7aa 100644
--- a/chrome/browser/extensions/api/processes/processes_api.cc
+++ b/chrome/browser/extensions/api/processes/processes_api.cc
@@ -314,7 +314,7 @@ void ProcessesEventRouter::OnItemsAdded(int start, int length) {
 
   args->Append(process);
 
-  DispatchEvent(keys::kOnCreated, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_CREATED, keys::kOnCreated, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
@@ -362,7 +362,7 @@ void ProcessesEventRouter::OnItemsChanged(int start, int length) {
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(processes);
-    DispatchEvent(keys::kOnUpdated, args.Pass());
+    DispatchEvent(events::PROCESSES_ON_UPDATED, keys::kOnUpdated, args.Pass());
   }
 
   if (updated_memory) {
@@ -381,7 +381,8 @@ void ProcessesEventRouter::OnItemsChanged(int start, int length) {
 
     scoped_ptr<base::ListValue> args(new base::ListValue());
     args->Append(processes);
-    DispatchEvent(keys::kOnUpdatedWithMemory, args.Pass());
+    DispatchEvent(events::PROCESSES_ON_UPDATED_WITH_MEMORY,
+                  keys::kOnUpdatedWithMemory, args.Pass());
   }
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
@@ -410,7 +411,7 @@ void ProcessesEventRouter::OnItemsToBeRemoved(int start, int length) {
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(0));
 
-  DispatchEvent(keys::kOnExited, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
@@ -439,7 +440,8 @@ void ProcessesEventRouter::ProcessHangEvent(content::RenderWidgetHost* widget) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(process);
 
-  DispatchEvent(keys::kOnUnresponsive, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_UNRESPONSIVE, keys::kOnUnresponsive,
+                args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
@@ -459,17 +461,18 @@ void ProcessesEventRouter::ProcessClosedEvent(
   // Third arg: The exit code for the process.
   args->Append(new base::FundamentalValue(details->exit_code));
 
-  DispatchEvent(keys::kOnExited, args.Pass());
+  DispatchEvent(events::PROCESSES_ON_EXITED, keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::DispatchEvent(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (event_router) {
-    scoped_ptr<extensions::Event> event(new extensions::Event(
-        extensions::events::UNKNOWN, event_name, event_args.Pass()));
+    scoped_ptr<Event> event(
+        new Event(histogram_value, event_name, event_args.Pass()));
     event_router->BroadcastEvent(event.Pass());
   }
 }
@@ -487,9 +490,9 @@ ProcessesAPI::ProcessesAPI(content::BrowserContext* context)
                                  processes_api_constants::kOnUpdatedWithMemory);
   ExtensionFunctionRegistry* registry =
       ExtensionFunctionRegistry::GetInstance();
-  registry->RegisterFunction<extensions::GetProcessIdForTabFunction>();
-  registry->RegisterFunction<extensions::TerminateFunction>();
-  registry->RegisterFunction<extensions::GetProcessInfoFunction>();
+  registry->RegisterFunction<GetProcessIdForTabFunction>();
+  registry->RegisterFunction<TerminateFunction>();
+  registry->RegisterFunction<GetProcessInfoFunction>();
 }
 
 ProcessesAPI::~ProcessesAPI() {
@@ -579,9 +582,8 @@ void GetProcessIdForTabFunction::GetProcessIdForTab() {
                                     NULL,
                                     &contents,
                                     &tab_index)) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        extensions::tabs_constants::kTabNotFoundError,
-        base::IntToString(tab_id_));
+    error_ = ErrorUtils::FormatErrorMessage(tabs_constants::kTabNotFoundError,
+                                            base::IntToString(tab_id_));
     SetResult(new base::FundamentalValue(-1));
     SendResponse(false);
   } else {
@@ -685,9 +687,7 @@ bool GetProcessInfoFunction::RunAsync() {
 
   EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &processes));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &memory_));
-
-  EXTENSION_FUNCTION_VALIDATE(extensions::ReadOneOrMoreIntegers(
-      processes, &process_ids_));
+  EXTENSION_FUNCTION_VALIDATE(ReadOneOrMoreIntegers(processes, &process_ids_));
 
   // Add a reference, which is balanced in GatherProcessInfo to keep the object
   // around and allow for the callback to be invoked.
diff --git a/chrome/browser/extensions/api/processes/processes_api.h b/chrome/browser/extensions/api/processes/processes_api.h
index 522354a..289f161 100644
--- a/chrome/browser/extensions/api/processes/processes_api.h
+++ b/chrome/browser/extensions/api/processes/processes_api.h
@@ -17,6 +17,7 @@
 #include "content/public/browser/render_widget_host.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 
 namespace base {
 class ListValue;
@@ -68,7 +69,8 @@ class ProcessesEventRouter : public TaskManagerModelObserver,
       content::RenderProcessHost* rph,
       content::RenderProcessHost::RendererClosedDetails* details);
 
-  void DispatchEvent(const std::string& event_name,
+  void DispatchEvent(events::HistogramValue histogram_value,
+                     const std::string& event_name,
                      scoped_ptr<base::ListValue> event_args);
 
   // Determines whether there is a registered listener for the specified event.
diff --git a/chrome/browser/extensions/api/proxy/proxy_api.cc b/chrome/browser/extensions/api/proxy/proxy_api.cc
index bbc2248..33a7a9e 100644
--- a/chrome/browser/extensions/api/proxy/proxy_api.cc
+++ b/chrome/browser/extensions/api/proxy/proxy_api.cc
@@ -45,11 +45,13 @@ void ProxyEventRouter::OnProxyError(
   args->Append(dict);
 
   if (profile) {
-    event_router->DispatchEventToRenderers(
-        keys::kProxyEventOnProxyError, args.Pass(), profile, true, GURL());
+    event_router->DispatchEventToRenderers(events::PROXY_ON_PROXY_ERROR,
+                                           keys::kProxyEventOnProxyError,
+                                           args.Pass(), profile, true, GURL());
   } else {
-    event_router->BroadcastEventToRenderers(
-        keys::kProxyEventOnProxyError, args.Pass(), GURL());
+    event_router->BroadcastEventToRenderers(events::PROXY_ON_PROXY_ERROR,
+                                            keys::kProxyEventOnProxyError,
+                                            args.Pass(), GURL());
   }
 }
 
@@ -75,11 +77,13 @@ void ProxyEventRouter::OnPACScriptError(
   args->Append(dict);
 
   if (profile) {
-    event_router->DispatchEventToRenderers(
-        keys::kProxyEventOnProxyError, args.Pass(), profile, true, GURL());
+    event_router->DispatchEventToRenderers(events::PROXY_ON_PROXY_ERROR,
+                                           keys::kProxyEventOnProxyError,
+                                           args.Pass(), profile, true, GURL());
   } else {
-    event_router->BroadcastEventToRenderers(
-        keys::kProxyEventOnProxyError, args.Pass(), GURL());
+    event_router->BroadcastEventToRenderers(events::PROXY_ON_PROXY_ERROR,
+                                            keys::kProxyEventOnProxyError,
+                                            args.Pass(), GURL());
   }
 }
 
diff --git a/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc b/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc
index c9caeed..3b0dca5 100644
--- a/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc
+++ b/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.cc
@@ -79,9 +79,8 @@ void ExtensionSyncEventObserver::OnSyncStateUpdated(
       api::sync_file_system::OnServiceStatusChanged::Create(service_info));
 
   BroadcastOrDispatchEvent(
-      app_origin,
-      api::sync_file_system::OnServiceStatusChanged::kEventName,
-      params.Pass());
+      app_origin, events::SYNC_FILE_SYSTEM_ON_SERVICE_STATUS_CHANGED,
+      api::sync_file_system::OnServiceStatusChanged::kEventName, params.Pass());
 }
 
 void ExtensionSyncEventObserver::OnFileSynced(
@@ -110,13 +109,13 @@ void ExtensionSyncEventObserver::OnFileSynced(
   params->AppendString(api::sync_file_system::ToString(direction_enum));
 
   BroadcastOrDispatchEvent(
-      url.origin(),
-      api::sync_file_system::OnFileStatusChanged::kEventName,
-      params.Pass());
+      url.origin(), events::SYNC_FILE_SYSTEM_ON_FILE_STATUS_CHANGED,
+      api::sync_file_system::OnFileStatusChanged::kEventName, params.Pass());
 }
 
 void ExtensionSyncEventObserver::BroadcastOrDispatchEvent(
     const GURL& app_origin,
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> values) {
   // Check to see whether the event should be broadcasted to all listening
@@ -126,7 +125,7 @@ void ExtensionSyncEventObserver::BroadcastOrDispatchEvent(
   DCHECK(event_router);
 
   scoped_ptr<Event> event(
-      new Event(events::UNKNOWN, event_name, values.Pass()));
+      new Event(histogram_value, event_name, values.Pass()));
   event->restrict_to_browser_context = browser_context_;
 
   // No app_origin, broadcast to all listening extensions for this event name.
diff --git a/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h b/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h
index 413f699..7d2847a 100644
--- a/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h
+++ b/chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h
@@ -11,6 +11,7 @@
 #include "base/values.h"
 #include "chrome/browser/sync_file_system/sync_event_observer.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 
 namespace content {
 class BrowserContext;
@@ -66,6 +67,7 @@ class ExtensionSyncEventObserver : public sync_file_system::SyncEventObserver,
   sync_file_system::SyncFileSystemService* sync_service_;
 
   void BroadcastOrDispatchEvent(const GURL& app_origin,
+                                events::HistogramValue histogram_value,
                                 const std::string& event_name,
                                 scoped_ptr<base::ListValue> value);
 
diff --git a/chrome/browser/extensions/api/system_private/system_private_api.cc b/chrome/browser/extensions/api/system_private/system_private_api.cc
index 54048c1..d98ab2e 100644
--- a/chrome/browser/extensions/api/system_private/system_private_api.cc
+++ b/chrome/browser/extensions/api/system_private/system_private_api.cc
@@ -47,13 +47,16 @@ const char kUpdatingState[] = "Updating";
 #endif  // defined(OS_CHROMEOS)
 
 // Dispatches an extension event with |argument|
-void DispatchEvent(const std::string& event_name, base::Value* argument) {
+void DispatchEvent(extensions::events::HistogramValue histogram_value,
+                   const std::string& event_name,
+                   base::Value* argument) {
   scoped_ptr<base::ListValue> list_args(new base::ListValue());
   if (argument) {
     list_args->Append(argument);
   }
-  g_browser_process->extension_event_router_forwarder()->
-      BroadcastEventToRenderers(event_name, list_args.Pass(), GURL());
+  g_browser_process->extension_event_router_forwarder()
+      ->BroadcastEventToRenderers(histogram_value, event_name, list_args.Pass(),
+                                  GURL());
 }
 
 }  // namespace
@@ -143,22 +146,26 @@ void DispatchVolumeChangedEvent(double volume, bool is_volume_muted) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetDouble(kVolumeKey, volume);
   dict->SetBoolean(kIsVolumeMutedKey, is_volume_muted);
-  DispatchEvent(system_private::OnVolumeChanged::kEventName, dict);
+  DispatchEvent(extensions::events::SYSTEM_PRIVATE_ON_VOLUME_CHANGED,
+                system_private::OnVolumeChanged::kEventName, dict);
 }
 
 void DispatchBrightnessChangedEvent(int brightness, bool user_initiated) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger(kBrightnessKey, brightness);
   dict->SetBoolean(kUserInitiatedKey, user_initiated);
-  DispatchEvent(system_private::OnBrightnessChanged::kEventName, dict);
+  DispatchEvent(extensions::events::SYSTEM_PRIVATE_ON_BRIGHTNESS_CHANGED,
+                system_private::OnBrightnessChanged::kEventName, dict);
 }
 
 void DispatchScreenUnlockedEvent() {
-  DispatchEvent(system_private::OnScreenUnlocked::kEventName, NULL);
+  DispatchEvent(extensions::events::SYSTEM_PRIVATE_ON_SCREEN_UNLOCKED,
+                system_private::OnScreenUnlocked::kEventName, NULL);
 }
 
 void DispatchWokeUpEvent() {
-  DispatchEvent(system_private::OnWokeUp::kEventName, NULL);
+  DispatchEvent(extensions::events::SYSTEM_PRIVATE_ON_WOKE_UP,
+                system_private::OnWokeUp::kEventName, NULL);
 }
 
 }  // namespace extensions
diff --git a/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc b/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc
index 83ca7e0..2e8522f 100644
--- a/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc
+++ b/chrome/browser/extensions/api/web_navigation/web_navigation_api.cc
@@ -319,21 +319,25 @@ void WebNavigationTabObserver::DidCommitProvisionalLoadForFrame(
   if (!navigation_state_.CanSendEvents(render_frame_host))
     return;
 
+  events::HistogramValue histogram_value = events::UNKNOWN;
   std::string event_name;
   if (is_reference_fragment_navigation) {
+    histogram_value = events::WEB_NAVIGATION_ON_REFERENCE_FRAGMENT_UPDATED;
     event_name = web_navigation::OnReferenceFragmentUpdated::kEventName;
   } else if (is_history_state_modification) {
+    histogram_value = events::WEB_NAVIGATION_ON_HISTORY_STATE_UPDATED;
     event_name = web_navigation::OnHistoryStateUpdated::kEventName;
   } else {
     if (navigation_state_.GetIsServerRedirected(render_frame_host)) {
       transition_type = ui::PageTransitionFromInt(
           transition_type | ui::PAGE_TRANSITION_SERVER_REDIRECT);
     }
+    histogram_value = events::WEB_NAVIGATION_ON_COMMITTED;
     event_name = web_navigation::OnCommitted::kEventName;
   }
-  helpers::DispatchOnCommitted(event_name, web_contents(), render_frame_host,
-                               navigation_state_.GetUrl(render_frame_host),
-                               transition_type);
+  helpers::DispatchOnCommitted(
+      histogram_value, event_name, web_contents(), render_frame_host,
+      navigation_state_.GetUrl(render_frame_host), transition_type);
 }
 
 void WebNavigationTabObserver::DidFailProvisionalLoad(
diff --git a/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc b/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc
index ed92ea8..3b04125 100644
--- a/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc
+++ b/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.cc
@@ -39,6 +39,7 @@ double MilliSecondsFromTime(const base::Time& time) {
 
 // Dispatches events to the extension message service.
 void DispatchEvent(content::BrowserContext* browser_context,
+                   events::HistogramValue histogram_value,
                    const std::string& event_name,
                    scoped_ptr<base::ListValue> args,
                    const GURL& url) {
@@ -49,7 +50,7 @@ void DispatchEvent(content::BrowserContext* browser_context,
   EventRouter* event_router = EventRouter::Get(profile);
   if (profile && event_router) {
     scoped_ptr<Event> event(
-        new Event(events::UNKNOWN, event_name, args.Pass()));
+        new Event(histogram_value, event_name, args.Pass()));
     event->restrict_to_browser_context = profile;
     event->filter_info = info;
     event_router->BroadcastEvent(event.Pass());
@@ -83,14 +84,15 @@ void DispatchOnBeforeNavigate(content::WebContents* web_contents,
   args->Append(dict);
 
   DispatchEvent(web_contents->GetBrowserContext(),
-                web_navigation::OnBeforeNavigate::kEventName,
-                args.Pass(),
+                events::WEB_NAVIGATION_ON_BEFORE_NAVIGATE,
+                web_navigation::OnBeforeNavigate::kEventName, args.Pass(),
                 validated_url);
 }
 
 // Constructs and dispatches an onCommitted or onReferenceFragmentUpdated
 // event.
-void DispatchOnCommitted(const std::string& event_name,
+void DispatchOnCommitted(events::HistogramValue histogram_value,
+                         const std::string& event_name,
                          content::WebContents* web_contents,
                          content::RenderFrameHost* frame_host,
                          const GURL& url,
@@ -122,8 +124,8 @@ void DispatchOnCommitted(const std::string& event_name,
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args->Append(dict);
 
-  DispatchEvent(web_contents->GetBrowserContext(), event_name, args.Pass(),
-                url);
+  DispatchEvent(web_contents->GetBrowserContext(), histogram_value, event_name,
+                args.Pass(), url);
 }
 
 // Constructs and dispatches an onDOMContentLoaded event.
@@ -141,8 +143,8 @@ void DispatchOnDOMContentLoaded(content::WebContents* web_contents,
   args->Append(dict);
 
   DispatchEvent(web_contents->GetBrowserContext(),
-                web_navigation::OnDOMContentLoaded::kEventName,
-                args.Pass(),
+                events::WEB_NAVIGATION_ON_DOM_CONTENT_LOADED,
+                web_navigation::OnDOMContentLoaded::kEventName, args.Pass(),
                 url);
 }
 
@@ -161,8 +163,8 @@ void DispatchOnCompleted(content::WebContents* web_contents,
   args->Append(dict);
 
   DispatchEvent(web_contents->GetBrowserContext(),
-                web_navigation::OnCompleted::kEventName,
-                args.Pass(), url);
+                events::WEB_NAVIGATION_ON_COMPLETED,
+                web_navigation::OnCompleted::kEventName, args.Pass(), url);
 }
 
 // Constructs and dispatches an onCreatedNavigationTarget event.
@@ -193,9 +195,9 @@ void DispatchOnCreatedNavigationTarget(
   args->Append(dict);
 
   DispatchEvent(browser_context,
+                events::WEB_NAVIGATION_ON_CREATED_NAVIGATION_TARGET,
                 web_navigation::OnCreatedNavigationTarget::kEventName,
-                args.Pass(),
-                target_url);
+                args.Pass(), target_url);
 }
 
 // Constructs and dispatches an onErrorOccurred event.
@@ -215,8 +217,8 @@ void DispatchOnErrorOccurred(content::WebContents* web_contents,
   args->Append(dict);
 
   DispatchEvent(web_contents->GetBrowserContext(),
-                web_navigation::OnErrorOccurred::kEventName,
-                args.Pass(), url);
+                events::WEB_NAVIGATION_ON_ERROR_OCCURRED,
+                web_navigation::OnErrorOccurred::kEventName, args.Pass(), url);
 }
 
 // Constructs and dispatches an onTabReplaced event.
@@ -234,10 +236,8 @@ void DispatchOnTabReplaced(
   dict->SetDouble(keys::kTimeStampKey, MilliSecondsFromTime(base::Time::Now()));
   args->Append(dict);
 
-  DispatchEvent(browser_context,
-                web_navigation::OnTabReplaced::kEventName,
-                args.Pass(),
-                GURL());
+  DispatchEvent(browser_context, events::WEB_NAVIGATION_ON_TAB_REPLACED,
+                web_navigation::OnTabReplaced::kEventName, args.Pass(), GURL());
 }
 
 }  // namespace web_navigation_api_helpers
diff --git a/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h b/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h
index ab7890a..882cf33 100644
--- a/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h
+++ b/chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h
@@ -8,6 +8,7 @@
 #include <string>
 
 #include "base/basictypes.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
@@ -32,7 +33,8 @@ void DispatchOnBeforeNavigate(content::WebContents* web_contents,
                               content::RenderFrameHost* frame_host,
                               const GURL& validated_url);
 
-void DispatchOnCommitted(const std::string& event_name,
+void DispatchOnCommitted(events::HistogramValue histogram_value,
+                         const std::string& event_name,
                          content::WebContents* web_contents,
                          content::RenderFrameHost* frame_host,
                          const GURL& url,
diff --git a/chrome/browser/extensions/chrome_extensions_browser_client.cc b/chrome/browser/extensions/chrome_extensions_browser_client.cc
index 5dad192..d6d27c2 100644
--- a/chrome/browser/extensions/chrome_extensions_browser_client.cc
+++ b/chrome/browser/extensions/chrome_extensions_browser_client.cc
@@ -282,10 +282,12 @@ ChromeExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 }
 
 void ChromeExtensionsBrowserClient::BroadcastEventToRenderers(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> args) {
   g_browser_process->extension_event_router_forwarder()
-      ->BroadcastEventToRenderers(event_name, args.Pass(), GURL());
+      ->BroadcastEventToRenderers(histogram_value, event_name, args.Pass(),
+                                  GURL());
 }
 
 net::NetLog* ChromeExtensionsBrowserClient::GetNetLog() {
diff --git a/chrome/browser/extensions/chrome_extensions_browser_client.h b/chrome/browser/extensions/chrome_extensions_browser_client.h
index ea2f538..b47d3e9 100644
--- a/chrome/browser/extensions/chrome_extensions_browser_client.h
+++ b/chrome/browser/extensions/chrome_extensions_browser_client.h
@@ -95,7 +95,8 @@ class ChromeExtensionsBrowserClient : public ExtensionsBrowserClient {
       content::BrowserContext* context) const override;
   const ComponentExtensionResourceManager*
   GetComponentExtensionResourceManager() override;
-  void BroadcastEventToRenderers(const std::string& event_name,
+  void BroadcastEventToRenderers(events::HistogramValue histogram_value,
+                                 const std::string& event_name,
                                  scoped_ptr<base::ListValue> args) override;
   net::NetLog* GetNetLog() override;
   ExtensionCache* GetExtensionCache() override;
diff --git a/chrome/browser/extensions/event_router_forwarder.cc b/chrome/browser/extensions/event_router_forwarder.cc
index ccab45d..ff198a1 100644
--- a/chrome/browser/extensions/event_router_forwarder.cc
+++ b/chrome/browser/extensions/event_router_forwarder.cc
@@ -23,13 +23,16 @@ EventRouterForwarder::~EventRouterForwarder() {
 }
 
 void EventRouterForwarder::BroadcastEventToRenderers(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args,
     const GURL& event_url) {
-  HandleEvent(std::string(), event_name, event_args.Pass(), 0, true, event_url);
+  HandleEvent(std::string(), histogram_value, event_name, event_args.Pass(), 0,
+              true, event_url);
 }
 
 void EventRouterForwarder::DispatchEventToRenderers(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args,
     void* profile,
@@ -37,24 +40,23 @@ void EventRouterForwarder::DispatchEventToRenderers(
     const GURL& event_url) {
   if (!profile)
     return;
-  HandleEvent(std::string(),
-              event_name,
-              event_args.Pass(),
-              profile,
-              use_profile_to_restrict_events,
-              event_url);
+  HandleEvent(std::string(), histogram_value, event_name, event_args.Pass(),
+              profile, use_profile_to_restrict_events, event_url);
 }
 
 void EventRouterForwarder::BroadcastEventToExtension(
     const std::string& extension_id,
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args,
     const GURL& event_url) {
-  HandleEvent(extension_id, event_name, event_args.Pass(), 0, true, event_url);
+  HandleEvent(extension_id, histogram_value, event_name, event_args.Pass(), 0,
+              true, event_url);
 }
 
 void EventRouterForwarder::DispatchEventToExtension(
     const std::string& extension_id,
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args,
     void* profile,
@@ -62,11 +64,12 @@ void EventRouterForwarder::DispatchEventToExtension(
     const GURL& event_url) {
   if (!profile)
     return;
-  HandleEvent(extension_id, event_name, event_args.Pass(), profile,
-              use_profile_to_restrict_events, event_url);
+  HandleEvent(extension_id, histogram_value, event_name, event_args.Pass(),
+              profile, use_profile_to_restrict_events, event_url);
 }
 
 void EventRouterForwarder::HandleEvent(const std::string& extension_id,
+                                       events::HistogramValue histogram_value,
                                        const std::string& event_name,
                                        scoped_ptr<base::ListValue> event_args,
                                        void* profile_ptr,
@@ -75,8 +78,8 @@ void EventRouterForwarder::HandleEvent(const std::string& extension_id,
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&EventRouterForwarder::HandleEvent, this,
-                   extension_id, event_name, base::Passed(&event_args),
+        base::Bind(&EventRouterForwarder::HandleEvent, this, extension_id,
+                   histogram_value, event_name, base::Passed(&event_args),
                    profile_ptr, use_profile_to_restrict_events, event_url));
     return;
   }
@@ -92,16 +95,18 @@ void EventRouterForwarder::HandleEvent(const std::string& extension_id,
       return;
   }
   if (profile) {
-    CallEventRouter(profile, extension_id, event_name, event_args.Pass(),
+    CallEventRouter(profile, extension_id, histogram_value, event_name,
+                    event_args.Pass(),
                     use_profile_to_restrict_events ? profile : NULL, event_url);
   } else {
     std::vector<Profile*> profiles(profile_manager->GetLoadedProfiles());
     for (size_t i = 0; i < profiles.size(); ++i) {
       scoped_ptr<base::ListValue> per_profile_event_args(
           event_args->DeepCopy());
-      CallEventRouter(
-          profiles[i], extension_id, event_name, per_profile_event_args.Pass(),
-          use_profile_to_restrict_events ? profiles[i] : NULL, event_url);
+      CallEventRouter(profiles[i], extension_id, histogram_value, event_name,
+                      per_profile_event_args.Pass(),
+                      use_profile_to_restrict_events ? profiles[i] : NULL,
+                      event_url);
     }
   }
 }
@@ -109,6 +114,7 @@ void EventRouterForwarder::HandleEvent(const std::string& extension_id,
 void EventRouterForwarder::CallEventRouter(
     Profile* profile,
     const std::string& extension_id,
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> event_args,
     Profile* restrict_to_profile,
@@ -122,7 +128,7 @@ void EventRouterForwarder::CallEventRouter(
 #endif
 
   scoped_ptr<Event> event(
-      new Event(events::UNKNOWN, event_name, event_args.Pass()));
+      new Event(histogram_value, event_name, event_args.Pass()));
   event->restrict_to_browser_context = restrict_to_profile;
   event->event_url = event_url;
   if (extension_id.empty()) {
diff --git a/chrome/browser/extensions/event_router_forwarder.h b/chrome/browser/extensions/event_router_forwarder.h
index f03debe..92b4bc7 100644
--- a/chrome/browser/extensions/event_router_forwarder.h
+++ b/chrome/browser/extensions/event_router_forwarder.h
@@ -11,6 +11,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 
 class GURL;
 
@@ -34,7 +35,8 @@ class EventRouterForwarder
   //   DispatchEventToRenderers(event_name, event_args, profile, event_url)
   // on all (original) profiles' EventRouters.
   // May be called on any thread.
-  void BroadcastEventToRenderers(const std::string& event_name,
+  void BroadcastEventToRenderers(events::HistogramValue histogram_value,
+                                 const std::string& event_name,
                                  scoped_ptr<base::ListValue> event_args,
                                  const GURL& event_url);
 
@@ -44,6 +46,7 @@ class EventRouterForwarder
   // on all (original) profiles' EventRouters.
   // May be called on any thread.
   void BroadcastEventToExtension(const std::string& extension_id,
+                                 events::HistogramValue histogram_value,
                                  const std::string& event_name,
                                  scoped_ptr<base::ListValue> event_args,
                                  const GURL& event_url);
@@ -52,7 +55,8 @@ class EventRouterForwarder
   //   DispatchEventToRenderers(event_name, event_args,
   //       use_profile_to_restrict_events ? profile : NULL, event_url)
   // on |profile|'s EventRouter. May be called on any thread.
-  void DispatchEventToRenderers(const std::string& event_name,
+  void DispatchEventToRenderers(events::HistogramValue histogram_value,
+                                const std::string& event_name,
                                 scoped_ptr<base::ListValue> event_args,
                                 void* profile,
                                 bool use_profile_to_restrict_events,
@@ -63,6 +67,7 @@ class EventRouterForwarder
   //       use_profile_to_restrict_events ? profile : NULL, event_url)
   // on |profile|'s EventRouter. May be called on any thread.
   void DispatchEventToExtension(const std::string& extension_id,
+                                events::HistogramValue histogram_value,
                                 const std::string& event_name,
                                 scoped_ptr<base::ListValue> event_args,
                                 void* profile,
@@ -76,6 +81,7 @@ class EventRouterForwarder
   // Helper function for {Broadcast,Dispatch}EventTo{Extension,Renderers}.
   // Virtual for testing.
   virtual void HandleEvent(const std::string& extension_id,
+                           events::HistogramValue histogram_value,
                            const std::string& event_name,
                            scoped_ptr<base::ListValue> event_args,
                            void* profile,
@@ -88,6 +94,7 @@ class EventRouterForwarder
   // Virtual for testing.
   virtual void CallEventRouter(Profile* profile,
                                const std::string& extension_id,
+                               events::HistogramValue histogram_value,
                                const std::string& event_name,
                                scoped_ptr<base::ListValue> event_args,
                                Profile* restrict_to_profile,
diff --git a/chrome/browser/extensions/event_router_forwarder_unittest.cc b/chrome/browser/extensions/event_router_forwarder_unittest.cc
index fc3c29e..e171018 100644
--- a/chrome/browser/extensions/event_router_forwarder_unittest.cc
+++ b/chrome/browser/extensions/event_router_forwarder_unittest.cc
@@ -25,21 +25,29 @@ namespace extensions {
 
 namespace {
 
+const events::HistogramValue kHistogramValue = events::FOR_TEST;
 const char kEventName[] = "event_name";
 const char kExt[] = "extension";
 
 class MockEventRouterForwarder : public EventRouterForwarder {
  public:
-  MOCK_METHOD5(CallEventRouter,
-      void(Profile*, const std::string&, const std::string&, Profile*,
-           const GURL&));
-
-  virtual void CallEventRouter(
-      Profile* profile, const std::string& extension_id,
-      const std::string& event_name, scoped_ptr<base::ListValue> event_args,
-      Profile* restrict_to_profile, const GURL& event_url) {
-    CallEventRouter(profile, extension_id, event_name,
-                             restrict_to_profile, event_url);
+  MOCK_METHOD6(CallEventRouter,
+               void(Profile*,
+                    const std::string&,
+                    events::HistogramValue,
+                    const std::string&,
+                    Profile*,
+                    const GURL&));
+
+  virtual void CallEventRouter(Profile* profile,
+                               const std::string& extension_id,
+                               events::HistogramValue histogram_value,
+                               const std::string& event_name,
+                               scoped_ptr<base::ListValue> event_args,
+                               Profile* restrict_to_profile,
+                               const GURL& event_url) {
+    CallEventRouter(profile, extension_id, histogram_value, event_name,
+                    restrict_to_profile, event_url);
   }
 
  protected:
@@ -47,41 +55,47 @@ class MockEventRouterForwarder : public EventRouterForwarder {
 };
 
 static void BroadcastEventToRenderers(EventRouterForwarder* event_router,
+                                      events::HistogramValue histogram_value,
                                       const std::string& event_name,
                                       const GURL& url) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
-  event_router->BroadcastEventToRenderers(event_name, args.Pass(), url);
+  event_router->BroadcastEventToRenderers(histogram_value, event_name,
+                                          args.Pass(), url);
 }
 
 static void DispatchEventToRenderers(EventRouterForwarder* event_router,
+                                     events::HistogramValue histogram_value,
                                      const std::string& event_name,
                                      void* profile,
                                      bool use_profile_to_restrict_events,
                                      const GURL& url) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
-  event_router->DispatchEventToRenderers(event_name, args.Pass(), profile,
+  event_router->DispatchEventToRenderers(histogram_value, event_name,
+                                         args.Pass(), profile,
                                          use_profile_to_restrict_events, url);
 }
 
 static void BroadcastEventToExtension(EventRouterForwarder* event_router,
                                       const std::string& extension,
+                                      events::HistogramValue histogram_value,
                                       const std::string& event_name,
                                       const GURL& url) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
-  event_router->BroadcastEventToExtension(extension, event_name, args.Pass(),
-                                          url);
+  event_router->BroadcastEventToExtension(extension, histogram_value,
+                                          event_name, args.Pass(), url);
 }
 
 static void DispatchEventToExtension(EventRouterForwarder* event_router,
                                      const std::string& extension,
+                                     events::HistogramValue histogram_value,
                                      const std::string& event_name,
                                      void* profile,
                                      bool use_profile_to_restrict_events,
                                      const GURL& url) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
-  event_router->DispatchEventToExtension(
-      extension, event_name, args.Pass(), profile,
-      use_profile_to_restrict_events, url);
+  event_router->DispatchEventToExtension(extension, histogram_value, event_name,
+                                         args.Pass(), profile,
+                                         use_profile_to_restrict_events, url);
 }
 
 }  // namespace
@@ -121,10 +135,13 @@ TEST_F(EventRouterForwarderTest, BroadcastRendererUI) {
       new MockEventRouterForwarder);
   GURL url;
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, profile1_, url));
+              CallEventRouter(profile1_, "", kHistogramValue, kEventName,
+                              profile1_, url));
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile2_, "", kEventName, profile2_, url));
-  BroadcastEventToRenderers(event_router.get(), kEventName, url);
+              CallEventRouter(profile2_, "", kHistogramValue, kEventName,
+                              profile2_, url));
+  BroadcastEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                            url);
 }
 
 TEST_F(EventRouterForwarderTest, BroadcastRendererUIIncognito) {
@@ -134,12 +151,15 @@ TEST_F(EventRouterForwarderTest, BroadcastRendererUIIncognito) {
   GURL url;
   Profile* incognito = profile1_->GetOffTheRecordProfile();
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, profile1_, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(incognito, _, _, _, _))
+              CallEventRouter(profile1_, "", kHistogramValue, kEventName,
+                              profile1_, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(incognito, _, _, _, _, _))
       .Times(0);
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile2_, "", kEventName, profile2_, url));
-  BroadcastEventToRenderers(event_router.get(), kEventName, url);
+              CallEventRouter(profile2_, "", kHistogramValue, kEventName,
+                              profile2_, url));
+  BroadcastEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                            url);
 }
 
 // This is the canonical test for passing control flow from the IO thread
@@ -150,13 +170,15 @@ TEST_F(EventRouterForwarderTest, BroadcastRendererIO) {
       new MockEventRouterForwarder);
   GURL url;
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, profile1_, url));
+              CallEventRouter(profile1_, "", kHistogramValue, kEventName,
+                              profile1_, url));
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile2_, "", kEventName, profile2_, url));
+              CallEventRouter(profile2_, "", kHistogramValue, kEventName,
+                              profile2_, url));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-      base::Bind(
-          &BroadcastEventToRenderers, base::Unretained(event_router.get()),
-          kEventName, url));
+                          base::Bind(&BroadcastEventToRenderers,
+                                     base::Unretained(event_router.get()),
+                                     kHistogramValue, kEventName, url));
 
   // Wait for IO thread's message loop to be processed
   scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
@@ -172,11 +194,12 @@ TEST_F(EventRouterForwarderTest, UnicastRendererUIRestricted) {
   using ::testing::_;
   GURL url;
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, profile1_, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+              CallEventRouter(profile1_, "", kHistogramValue, kEventName,
+                              profile1_, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToRenderers(event_router.get(), kEventName, profile1_, true,
-                           url);
+  DispatchEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                           profile1_, true, url);
 }
 
 TEST_F(EventRouterForwarderTest, UnicastRendererUIRestrictedIncognito1) {
@@ -186,13 +209,14 @@ TEST_F(EventRouterForwarderTest, UnicastRendererUIRestrictedIncognito1) {
   using ::testing::_;
   GURL url;
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, profile1_, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(incognito, _, _, _, _))
+              CallEventRouter(profile1_, "", kHistogramValue, kEventName,
+                              profile1_, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(incognito, _, _, _, _, _))
       .Times(0);
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToRenderers(event_router.get(), kEventName, profile1_, true,
-                           url);
+  DispatchEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                           profile1_, true, url);
 }
 
 TEST_F(EventRouterForwarderTest, UnicastRendererUIRestrictedIncognito2) {
@@ -201,14 +225,15 @@ TEST_F(EventRouterForwarderTest, UnicastRendererUIRestrictedIncognito2) {
   Profile* incognito = profile1_->GetOffTheRecordProfile();
   using ::testing::_;
   GURL url;
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile1_, _, _, _, _))
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile1_, _, _, _, _, _))
       .Times(0);
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(incognito, "", kEventName, incognito, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+              CallEventRouter(incognito, "", kHistogramValue, kEventName,
+                              incognito, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToRenderers(event_router.get(), kEventName, incognito, true,
-                           url);
+  DispatchEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                           incognito, true, url);
 }
 
 TEST_F(EventRouterForwarderTest, UnicastRendererUIUnrestricted) {
@@ -216,12 +241,13 @@ TEST_F(EventRouterForwarderTest, UnicastRendererUIUnrestricted) {
       new MockEventRouterForwarder);
   using ::testing::_;
   GURL url;
-  EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, NULL, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+  EXPECT_CALL(
+      *event_router.get(),
+      CallEventRouter(profile1_, "", kHistogramValue, kEventName, NULL, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToRenderers(event_router.get(), kEventName, profile1_, false,
-                           url);
+  DispatchEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                           profile1_, false, url);
 }
 
 TEST_F(EventRouterForwarderTest, UnicastRendererUIUnrestrictedIncognito) {
@@ -230,14 +256,15 @@ TEST_F(EventRouterForwarderTest, UnicastRendererUIUnrestrictedIncognito) {
   Profile* incognito = profile1_->GetOffTheRecordProfile();
   using ::testing::_;
   GURL url;
-  EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, "", kEventName, NULL, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(incognito, _, _, _, _))
+  EXPECT_CALL(
+      *event_router.get(),
+      CallEventRouter(profile1_, "", kHistogramValue, kEventName, NULL, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(incognito, _, _, _, _, _))
       .Times(0);
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToRenderers(event_router.get(), kEventName, profile1_, false,
-                           url);
+  DispatchEventToRenderers(event_router.get(), kHistogramValue, kEventName,
+                           profile1_, false, url);
 }
 
 TEST_F(EventRouterForwarderTest, BroadcastExtensionUI) {
@@ -245,10 +272,13 @@ TEST_F(EventRouterForwarderTest, BroadcastExtensionUI) {
       new MockEventRouterForwarder);
   GURL url;
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, kExt, kEventName, profile1_, url));
+              CallEventRouter(profile1_, kExt, kHistogramValue, kEventName,
+                              profile1_, url));
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile2_, kExt, kEventName, profile2_, url));
-  BroadcastEventToExtension(event_router.get(), kExt, kEventName, url);
+              CallEventRouter(profile2_, kExt, kHistogramValue, kEventName,
+                              profile2_, url));
+  BroadcastEventToExtension(event_router.get(), kExt, kHistogramValue,
+                            kEventName, url);
 }
 
 TEST_F(EventRouterForwarderTest, UnicastExtensionUIRestricted) {
@@ -257,11 +287,12 @@ TEST_F(EventRouterForwarderTest, UnicastExtensionUIRestricted) {
   using ::testing::_;
   GURL url;
   EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, kExt, kEventName, profile1_, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+              CallEventRouter(profile1_, kExt, kHistogramValue, kEventName,
+                              profile1_, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToExtension(event_router.get(), kExt, kEventName, profile1_,
-                           true, url);
+  DispatchEventToExtension(event_router.get(), kExt, kHistogramValue,
+                           kEventName, profile1_, true, url);
 }
 
 TEST_F(EventRouterForwarderTest, UnicastExtensionUIUnrestricted) {
@@ -269,12 +300,13 @@ TEST_F(EventRouterForwarderTest, UnicastExtensionUIUnrestricted) {
       new MockEventRouterForwarder);
   using ::testing::_;
   GURL url;
-  EXPECT_CALL(*event_router.get(),
-              CallEventRouter(profile1_, kExt, kEventName, NULL, url));
-  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _))
+  EXPECT_CALL(
+      *event_router.get(),
+      CallEventRouter(profile1_, kExt, kHistogramValue, kEventName, NULL, url));
+  EXPECT_CALL(*event_router.get(), CallEventRouter(profile2_, _, _, _, _, _))
       .Times(0);
-  DispatchEventToExtension(event_router.get(), kExt, kEventName, profile1_,
-                           false, url);
+  DispatchEventToExtension(event_router.get(), kExt, kHistogramValue,
+                           kEventName, profile1_, false, url);
 }
 
 }  // namespace extensions
diff --git a/chrome/browser/net/chrome_extensions_network_delegate.cc b/chrome/browser/net/chrome_extensions_network_delegate.cc
index bbbc56b..331d941 100644
--- a/chrome/browser/net/chrome_extensions_network_delegate.cc
+++ b/chrome/browser/net/chrome_extensions_network_delegate.cc
@@ -21,6 +21,7 @@
 
 using content::BrowserThread;
 using content::ResourceRequestInfo;
+using extensions::ExtensionWebRequestEventRouter;
 
 namespace {
 
diff --git a/chrome/browser/profiles/off_the_record_profile_impl.cc b/chrome/browser/profiles/off_the_record_profile_impl.cc
index 871769e..e61f0ac 100644
--- a/chrome/browser/profiles/off_the_record_profile_impl.cc
+++ b/chrome/browser/profiles/off_the_record_profile_impl.cc
@@ -97,14 +97,14 @@ namespace {
 
 void NotifyOTRProfileCreatedOnIOThread(void* original_profile,
                                        void* otr_profile) {
-  ExtensionWebRequestEventRouter::GetInstance()->OnOTRBrowserContextCreated(
-      original_profile, otr_profile);
+  extensions::ExtensionWebRequestEventRouter::GetInstance()
+      ->OnOTRBrowserContextCreated(original_profile, otr_profile);
 }
 
 void NotifyOTRProfileDestroyedOnIOThread(void* original_profile,
                                          void* otr_profile) {
-  ExtensionWebRequestEventRouter::GetInstance()->OnOTRBrowserContextDestroyed(
-      original_profile, otr_profile);
+  extensions::ExtensionWebRequestEventRouter::GetInstance()
+      ->OnOTRBrowserContextDestroyed(original_profile, otr_profile);
 }
 
 }  // namespace
diff --git a/extensions/browser/api/hid/hid_device_manager.cc b/extensions/browser/api/hid/hid_device_manager.cc
index 39b969f..bcfd4ae 100644
--- a/extensions/browser/api/hid/hid_device_manager.cc
+++ b/extensions/browser/api/hid/hid_device_manager.cc
@@ -220,7 +220,8 @@ void HidDeviceManager::OnDeviceAdded(scoped_refptr<HidDeviceInfo> device_info) {
     if (api_device_info.collections.size() > 0) {
       scoped_ptr<base::ListValue> args(
           hid::OnDeviceAdded::Create(api_device_info));
-      DispatchEvent(hid::OnDeviceAdded::kEventName, args.Pass(), device_info);
+      DispatchEvent(events::HID_ON_DEVICE_ADDED, hid::OnDeviceAdded::kEventName,
+                    args.Pass(), device_info);
     }
   }
 }
@@ -239,7 +240,8 @@ void HidDeviceManager::OnDeviceRemoved(
   if (event_router_) {
     DCHECK(enumeration_ready_);
     scoped_ptr<base::ListValue> args(hid::OnDeviceRemoved::Create(resource_id));
-    DispatchEvent(hid::OnDeviceRemoved::kEventName, args.Pass(), device_info);
+    DispatchEvent(events::HID_ON_DEVICE_REMOVED,
+                  hid::OnDeviceRemoved::kEventName, args.Pass(), device_info);
   }
 }
 
@@ -315,11 +317,12 @@ void HidDeviceManager::OnEnumerationComplete(
   pending_enumerations_.clear();
 }
 
-void HidDeviceManager::DispatchEvent(const std::string& event_name,
+void HidDeviceManager::DispatchEvent(events::HistogramValue histogram_value,
+                                     const std::string& event_name,
                                      scoped_ptr<base::ListValue> event_args,
                                      scoped_refptr<HidDeviceInfo> device_info) {
   scoped_ptr<Event> event(
-      new Event(events::UNKNOWN, event_name, event_args.Pass()));
+      new Event(histogram_value, event_name, event_args.Pass()));
   event->will_dispatch_callback = base::Bind(
       &WillDispatchDeviceEvent, weak_factory_.GetWeakPtr(), device_info);
   event_router_->BroadcastEvent(event.Pass());
diff --git a/extensions/browser/api/hid/hid_device_manager.h b/extensions/browser/api/hid/hid_device_manager.h
index a3adb36..8479901 100644
--- a/extensions/browser/api/hid/hid_device_manager.h
+++ b/extensions/browser/api/hid/hid_device_manager.h
@@ -16,6 +16,7 @@
 #include "device/hid/hid_service.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/common/api/hid.h"
 
 namespace device {
@@ -106,7 +107,8 @@ class HidDeviceManager : public BrowserContextKeyedAPI,
   void OnEnumerationComplete(
       const std::vector<scoped_refptr<device::HidDeviceInfo>>& devices);
 
-  void DispatchEvent(const std::string& event_name,
+  void DispatchEvent(events::HistogramValue histogram_value,
+                     const std::string& event_name,
                      scoped_ptr<base::ListValue> event_args,
                      scoped_refptr<device::HidDeviceInfo> device_info);
 
diff --git a/extensions/browser/api/management/management_api.cc b/extensions/browser/api/management/management_api.cc
index 1581414..c2202c8 100644
--- a/extensions/browser/api/management/management_api.cc
+++ b/extensions/browser/api/management/management_api.cc
@@ -832,32 +832,38 @@ ManagementEventRouter::~ManagementEventRouter() {
 void ManagementEventRouter::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
-  BroadcastEvent(extension, management::OnEnabled::kEventName);
+  BroadcastEvent(extension, events::MANAGEMENT_ON_ENABLED,
+                 management::OnEnabled::kEventName);
 }
 
 void ManagementEventRouter::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
-  BroadcastEvent(extension, management::OnDisabled::kEventName);
+  BroadcastEvent(extension, events::MANAGEMENT_ON_DISABLED,
+                 management::OnDisabled::kEventName);
 }
 
 void ManagementEventRouter::OnExtensionInstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     bool is_update) {
-  BroadcastEvent(extension, management::OnInstalled::kEventName);
+  BroadcastEvent(extension, events::MANAGEMENT_ON_INSTALLED,
+                 management::OnInstalled::kEventName);
 }
 
 void ManagementEventRouter::OnExtensionUninstalled(
     content::BrowserContext* browser_context,
     const Extension* extension,
     extensions::UninstallReason reason) {
-  BroadcastEvent(extension, management::OnUninstalled::kEventName);
+  BroadcastEvent(extension, events::MANAGEMENT_ON_UNINSTALLED,
+                 management::OnUninstalled::kEventName);
 }
 
-void ManagementEventRouter::BroadcastEvent(const Extension* extension,
-                                           const char* event_name) {
+void ManagementEventRouter::BroadcastEvent(
+    const Extension* extension,
+    events::HistogramValue histogram_value,
+    const char* event_name) {
   if (ShouldNotBeVisible(extension, browser_context_))
     return;  // Don't dispatch events for built-in extenions.
   scoped_ptr<base::ListValue> args(new base::ListValue());
@@ -871,7 +877,7 @@ void ManagementEventRouter::BroadcastEvent(const Extension* extension,
 
   EventRouter::Get(browser_context_)
       ->BroadcastEvent(scoped_ptr<Event>(
-          new Event(events::UNKNOWN, event_name, args.Pass())));
+          new Event(histogram_value, event_name, args.Pass())));
 }
 
 ManagementAPI::ManagementAPI(content::BrowserContext* context)
diff --git a/extensions/browser/api/management/management_api.h b/extensions/browser/api/management/management_api.h
index 8b77ff6..95006b6 100644
--- a/extensions/browser/api/management/management_api.h
+++ b/extensions/browser/api/management/management_api.h
@@ -12,6 +12,7 @@
 #include "extensions/browser/api/management/management_api_delegate.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/event_router.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_registry_observer.h"
 
@@ -243,7 +244,9 @@ class ManagementEventRouter : public ExtensionRegistryObserver {
                               extensions::UninstallReason reason) override;
 
   // Dispatches management api events to listening extensions.
-  void BroadcastEvent(const Extension* extension, const char* event_name);
+  void BroadcastEvent(const Extension* extension,
+                      events::HistogramValue histogram_value,
+                      const char* event_name);
 
   content::BrowserContext* browser_context_;
 
diff --git a/extensions/browser/api/system_info/system_info_api.cc b/extensions/browser/api/system_info/system_info_api.cc
index a5b85bf..07d2dbd 100644
--- a/extensions/browser/api/system_info/system_info_api.cc
+++ b/extensions/browser/api/system_info/system_info_api.cc
@@ -73,7 +73,8 @@ class SystemInfoEventRouter : public gfx::DisplayObserver,
 
   // Called from any thread to dispatch the systemInfo event to all extension
   // processes cross multiple profiles.
-  void DispatchEvent(const std::string& event_name,
+  void DispatchEvent(events::HistogramValue histogram_value,
+                     const std::string& event_name,
                      scoped_ptr<base::ListValue> args);
 
   // Called to dispatch the systemInfo.display.onDisplayChanged event.
@@ -164,7 +165,8 @@ void SystemInfoEventRouter::OnRemovableStorageAttached(
   systeminfo::BuildStorageUnitInfo(info, &unit);
   scoped_ptr<base::ListValue> args(new base::ListValue);
   args->Append(unit.ToValue().release());
-  DispatchEvent(system_storage::OnAttached::kEventName, args.Pass());
+  DispatchEvent(events::SYSTEM_STORAGE_ON_ATTACHED,
+                system_storage::OnAttached::kEventName, args.Pass());
 }
 
 void SystemInfoEventRouter::OnRemovableStorageDetached(
@@ -175,7 +177,8 @@ void SystemInfoEventRouter::OnRemovableStorageDetached(
           info.device_id());
   args->AppendString(transient_id);
 
-  DispatchEvent(system_storage::OnDetached::kEventName, args.Pass());
+  DispatchEvent(events::SYSTEM_STORAGE_ON_DETACHED,
+                system_storage::OnDetached::kEventName, args.Pass());
 }
 
 void SystemInfoEventRouter::OnDisplayAdded(const gfx::Display& new_display) {
@@ -193,13 +196,16 @@ void SystemInfoEventRouter::OnDisplayMetricsChanged(const gfx::Display& display,
 
 void SystemInfoEventRouter::OnDisplayChanged() {
   scoped_ptr<base::ListValue> args(new base::ListValue());
-  DispatchEvent(system_display::OnDisplayChanged::kEventName, args.Pass());
+  DispatchEvent(events::SYSTEM_DISPLAY_ON_DISPLAY_CHANGED,
+                system_display::OnDisplayChanged::kEventName, args.Pass());
 }
 
-void SystemInfoEventRouter::DispatchEvent(const std::string& event_name,
-                                          scoped_ptr<base::ListValue> args) {
-  ExtensionsBrowserClient::Get()->BroadcastEventToRenderers(event_name,
-                                                            args.Pass());
+void SystemInfoEventRouter::DispatchEvent(
+    events::HistogramValue histogram_value,
+    const std::string& event_name,
+    scoped_ptr<base::ListValue> args) {
+  ExtensionsBrowserClient::Get()->BroadcastEventToRenderers(
+      histogram_value, event_name, args.Pass());
 }
 
 void AddEventListener(const std::string& event_name) {
diff --git a/extensions/browser/api/vpn_provider/vpn_service.cc b/extensions/browser/api/vpn_provider/vpn_service.cc
index 5eaed3e..c65488e 100644
--- a/extensions/browser/api/vpn_provider/vpn_service.cc
+++ b/extensions/browser/api/vpn_provider/vpn_service.cc
@@ -100,7 +100,8 @@ void VpnService::VpnConfiguration::OnPacketReceived(
   scoped_ptr<base::ListValue> event_args =
       api_vpn::OnPacketReceived::Create(data);
   vpn_service_->SendSignalToExtension(
-      extension_id_, api_vpn::OnPacketReceived::kEventName, event_args.Pass());
+      extension_id_, extensions::events::VPN_PROVIDER_ON_PACKET_RECEIVED,
+      api_vpn::OnPacketReceived::kEventName, event_args.Pass());
 }
 
 void VpnService::VpnConfiguration::OnPlatformMessage(uint32_t message) {
@@ -120,7 +121,8 @@ void VpnService::VpnConfiguration::OnPlatformMessage(uint32_t message) {
       configuration_name_, platform_message, std::string());
 
   vpn_service_->SendSignalToExtension(
-      extension_id_, api_vpn::OnPlatformMessage::kEventName, event_args.Pass());
+      extension_id_, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
+      api_vpn::OnPlatformMessage::kEventName, event_args.Pass());
 }
 
 VpnService::VpnService(
@@ -159,7 +161,9 @@ VpnService::~VpnService() {
 }
 
 void VpnService::SendShowAddDialogToExtension(const std::string& extension_id) {
-  SendSignalToExtension(extension_id, api_vpn::OnUIEvent::kEventName,
+  SendSignalToExtension(extension_id,
+                        extensions::events::VPN_PROVIDER_ON_UI_EVENT,
+                        api_vpn::OnUIEvent::kEventName,
                         api_vpn::OnUIEvent::Create(
                             api_vpn::UI_EVENT_SHOWADDDIALOG, std::string()));
 }
@@ -168,7 +172,8 @@ void VpnService::SendShowConfigureDialogToExtension(
     const std::string& extension_id,
     const std::string& configuration_id) {
   SendSignalToExtension(
-      extension_id, api_vpn::OnUIEvent::kEventName,
+      extension_id, extensions::events::VPN_PROVIDER_ON_UI_EVENT,
+      api_vpn::OnUIEvent::kEventName,
       api_vpn::OnUIEvent::Create(api_vpn::UI_EVENT_SHOWCONFIGUREDIALOG,
                                  configuration_id));
 }
@@ -177,7 +182,8 @@ void VpnService::SendPlatformError(const std::string& extension_id,
                                    const std::string& configuration_id,
                                    const std::string& error_message) {
   SendSignalToExtension(
-      extension_id, api_vpn::OnPlatformMessage::kEventName,
+      extension_id, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
+      api_vpn::OnPlatformMessage::kEventName,
       api_vpn::OnPlatformMessage::Create(
           configuration_id, api_vpn::PLATFORM_MESSAGE_ERROR, error_message));
 }
@@ -215,6 +221,7 @@ void VpnService::OnConfigurationRemoved(const std::string& service_path,
   scoped_ptr<base::ListValue> event_args =
       api_vpn::OnConfigRemoved::Create(configuration->configuration_name());
   SendSignalToExtension(configuration->extension_id(),
+                        extensions::events::VPN_PROVIDER_ON_CONFIG_REMOVED,
                         api_vpn::OnConfigRemoved::kEventName,
                         event_args.Pass());
 
@@ -514,12 +521,13 @@ void VpnService::OnRemoveConfigurationFailure(
   callback.Run(error_name, std::string());
 }
 
-void VpnService::SendSignalToExtension(const std::string& extension_id,
-                                       const std::string& event_name,
-                                       scoped_ptr<base::ListValue> event_args) {
-  scoped_ptr<extensions::Event> event(
-      new extensions::Event(extensions::events::UNKNOWN, event_name,
-                            event_args.Pass(), browser_context_));
+void VpnService::SendSignalToExtension(
+    const std::string& extension_id,
+    extensions::events::HistogramValue histogram_value,
+    const std::string& event_name,
+    scoped_ptr<base::ListValue> event_args) {
+  scoped_ptr<extensions::Event> event(new extensions::Event(
+      histogram_value, event_name, event_args.Pass(), browser_context_));
 
   event_router_->DispatchEventToExtension(extension_id, event.Pass());
 }
diff --git a/extensions/browser/api/vpn_provider/vpn_service.h b/extensions/browser/api/vpn_provider/vpn_service.h
index 72c6240..dff70ae 100644
--- a/extensions/browser/api/vpn_provider/vpn_service.h
+++ b/extensions/browser/api/vpn_provider/vpn_service.h
@@ -16,6 +16,7 @@
 #include "chromeos/network/network_configuration_observer.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "components/keyed_service/core/keyed_service.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/api/vpn_provider.h"
 
@@ -212,6 +213,7 @@ class VpnService : public KeyedService,
   // Send an event with name |event_name| and arguments |event_args| to the
   // extension with id |extension_id|.
   void SendSignalToExtension(const std::string& extension_id,
+                             extensions::events::HistogramValue histogram_value,
                              const std::string& event_name,
                              scoped_ptr<base::ListValue> event_args);
 
diff --git a/extensions/browser/api/web_request/web_request_api.cc b/extensions/browser/api/web_request/web_request_api.cc
index 8821232..ad11257 100644
--- a/extensions/browser/api/web_request/web_request_api.cc
+++ b/extensions/browser/api/web_request/web_request_api.cc
@@ -69,20 +69,15 @@ using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using content::ResourceType;
-using extensions::ErrorUtils;
-using extensions::Extension;
-using extensions::InfoMap;
-using extensions::Feature;
-using extensions::RulesRegistryService;
-using extensions::Warning;
-using extensions::WarningService;
-using extensions::WarningSet;
-
-namespace activitylog = activity_log_web_request_constants;
+
+namespace activity_log = activity_log_web_request_constants;
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
-namespace web_request = extensions::core_api::web_request;
-namespace declarative_keys = extensions::declarative_webrequest_constants;
+
+namespace extensions {
+
+namespace declarative_keys = declarative_webrequest_constants;
+namespace web_request = core_api::web_request;
 
 namespace {
 
@@ -181,14 +176,13 @@ void ExtractRequestRoutingInfo(net::URLRequest* request,
 // a <webview> guest process or not. If it is from a <webview> guest process,
 // then |web_view_info| is returned with information about the instance ID
 // that uniquely identifies the <webview> and its embedder.
-bool GetWebViewInfo(
-    net::URLRequest* request,
-    extensions::WebViewRendererState::WebViewInfo* web_view_info) {
+bool GetWebViewInfo(net::URLRequest* request,
+                    WebViewRendererState::WebViewInfo* web_view_info) {
   int render_process_host_id = -1;
   int routing_id = -1;
   ExtractRequestRoutingInfo(request, &render_process_host_id, &routing_id);
-  return extensions::WebViewRendererState::GetInstance()->
-      GetInfo(render_process_host_id, routing_id, web_view_info);
+  return WebViewRendererState::GetInstance()->GetInfo(
+      render_process_host_id, routing_id, web_view_info);
 }
 
 void ExtractRequestInfoDetails(net::URLRequest* request,
@@ -229,11 +223,11 @@ void ExtractRequestInfoBody(const net::URLRequest* request,
   out->Set(keys::kRequestBodyKey, request_body);
 
   // Get the data presenters, ordered by how specific they are.
-  extensions::ParsedDataPresenter parsed_data_presenter(*request);
-  extensions::RawDataPresenter raw_data_presenter;
-  extensions::UploadDataPresenter* const presenters[] = {
-    &parsed_data_presenter,    // 1: any parseable forms? (Specific to forms.)
-    &raw_data_presenter        // 2: any data at all? (Non-specific.)
+  ParsedDataPresenter parsed_data_presenter(*request);
+  RawDataPresenter raw_data_presenter;
+  UploadDataPresenter* const presenters[] = {
+      &parsed_data_presenter,  // 1: any parseable forms? (Specific to forms.)
+      &raw_data_presenter      // 2: any data at all? (Non-specific.)
   };
   // Keys for the results of the corresponding presenters.
   static const char* const kKeys[] = {
@@ -330,39 +324,39 @@ void SendOnMessageEventOnUI(
     void* browser_context_id,
     const std::string& extension_id,
     bool is_web_view_guest,
-    const extensions::WebViewRendererState::WebViewInfo& web_view_info,
+    const WebViewRendererState::WebViewInfo& web_view_info,
     scoped_ptr<base::DictionaryValue> event_argument) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   content::BrowserContext* browser_context =
       reinterpret_cast<content::BrowserContext*>(browser_context_id);
-  if (!extensions::ExtensionsBrowserClient::Get()->IsValidContext(
-      browser_context))
+  if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
     return;
 
   scoped_ptr<base::ListValue> event_args(new base::ListValue);
   event_args->Append(event_argument.release());
 
-  extensions::EventRouter* event_router =
-      extensions::EventRouter::Get(browser_context);
+  EventRouter* event_router = EventRouter::Get(browser_context);
 
-  extensions::EventFilteringInfo event_filtering_info;
+  EventFilteringInfo event_filtering_info;
 
+  events::HistogramValue histogram_value = events::UNKNOWN;
   std::string event_name;
   // The instance ID uniquely identifies a <webview> instance within an embedder
   // process. We use a filter here so that only event listeners for a particular
   // <webview> will fire.
   if (is_web_view_guest) {
     event_filtering_info.SetInstanceID(web_view_info.instance_id);
+    histogram_value = events::WEB_VIEW_INTERNAL_ON_MESSAGE;
     event_name = webview::kEventMessage;
   } else {
+    histogram_value = events::DECLARATIVE_WEB_REQUEST_ON_MESSAGE;
     event_name = declarative_keys::kOnMessage;
   }
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      extensions::events::UNKNOWN, event_name, event_args.Pass(),
-      browser_context, GURL(), extensions::EventRouter::USER_GESTURE_UNKNOWN,
-      event_filtering_info));
+  scoped_ptr<Event> event(new Event(
+      histogram_value, event_name, event_args.Pass(), browser_context, GURL(),
+      EventRouter::USER_GESTURE_UNKNOWN, event_filtering_info));
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
@@ -380,8 +374,6 @@ void RemoveEventListenerOnIOThread(
 
 }  // namespace
 
-namespace extensions {
-
 WebRequestAPI::WebRequestAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
@@ -428,8 +420,6 @@ void WebRequestAPI::OnListenerRemoved(const EventListenerInfo& details) {
                                      0 /* web_view_instance_id */));
 }
 
-}  // namespace extensions
-
 // Represents a single unique listener to an event, along with whatever filter
 // parameters and extra_info_spec were specified at the time the listener was
 // added.
@@ -648,8 +638,7 @@ ExtensionWebRequestEventRouter* ExtensionWebRequestEventRouter::GetInstance() {
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter()
     : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
   web_request_event_router_delegate_.reset(
-      extensions::ExtensionsAPIClient::Get()->
-          CreateWebRequestEventRouterDelegate());
+      ExtensionsAPIClient::Get()->CreateWebRequestEventRouterDelegate());
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
@@ -658,7 +647,7 @@ ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 void ExtensionWebRequestEventRouter::RegisterRulesRegistry(
     void* browser_context,
     int rules_registry_id,
-    scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
+    scoped_refptr<WebRequestRulesRegistry> rules_registry) {
   RulesRegistryKey key(browser_context, rules_registry_id);
   if (rules_registry.get())
     rules_registries_[key] = rules_registry;
@@ -724,7 +713,7 @@ int ExtensionWebRequestEventRouter::OnBeforeRequest(
   initialize_blocked_requests |=
       ProcessDeclarativeRules(browser_context, extension_info_map,
                               web_request::OnBeforeRequest::kEventName, request,
-                              extensions::ON_BEFORE_REQUEST, NULL);
+                              ON_BEFORE_REQUEST, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
@@ -778,10 +767,9 @@ int ExtensionWebRequestEventRouter::OnBeforeSendHeaders(
 
   bool initialize_blocked_requests = false;
 
-  initialize_blocked_requests |=
-      ProcessDeclarativeRules(browser_context, extension_info_map,
-                              keys::kOnBeforeSendHeadersEvent, request,
-                              extensions::ON_BEFORE_SEND_HEADERS, NULL);
+  initialize_blocked_requests |= ProcessDeclarativeRules(
+      browser_context, extension_info_map, keys::kOnBeforeSendHeadersEvent,
+      request, ON_BEFORE_SEND_HEADERS, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
@@ -870,11 +858,9 @@ int ExtensionWebRequestEventRouter::OnHeadersReceived(
 
   bool initialize_blocked_requests = false;
 
-  initialize_blocked_requests |=
-      ProcessDeclarativeRules(browser_context, extension_info_map,
-                              keys::kOnHeadersReceivedEvent, request,
-                              extensions::ON_HEADERS_RECEIVED,
-                              original_response_headers);
+  initialize_blocked_requests |= ProcessDeclarativeRules(
+      browser_context, extension_info_map, keys::kOnHeadersReceivedEvent,
+      request, ON_HEADERS_RECEIVED, original_response_headers);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
@@ -1210,12 +1196,10 @@ bool ExtensionWebRequestEventRouter::DispatchEvent(
     if (!((*it)->extra_info_spec & ExtraInfoSpec::RESPONSE_HEADERS))
       dict->Remove(keys::kResponseHeadersKey, NULL);
 
-    extensions::EventRouter::DispatchEvent(
-        (*it)->ipc_sender.get(), browser_context,
-        (*it)->extension_id, (*it)->sub_event_name,
-        args_filtered.Pass(),
-        extensions::EventRouter::USER_GESTURE_UNKNOWN,
-        extensions::EventFilteringInfo());
+    EventRouter::DispatchEvent(
+        (*it)->ipc_sender.get(), browser_context, (*it)->extension_id,
+        (*it)->sub_event_name, args_filtered.Pass(),
+        EventRouter::USER_GESTURE_UNKNOWN, EventFilteringInfo());
     if ((*it)->extra_info_spec &
         (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) {
       (*it)->blocked_requests.insert(request->identifier());
@@ -1311,8 +1295,7 @@ void ExtensionWebRequestEventRouter::RemoveEventListener(
     const std::string& sub_event_name,
     int embedder_process_id,
     int web_view_instance_id) {
-  std::string event_name =
-      extensions::EventRouter::GetBaseEventName(sub_event_name);
+  std::string event_name = EventRouter::GetBaseEventName(sub_event_name);
   DCHECK(IsWebRequestEvent(event_name));
 
   EventListener listener;
@@ -1464,9 +1447,9 @@ void ExtensionWebRequestEventRouter::GetMatchingListenersImpl(
     std::vector<const ExtensionWebRequestEventRouter::EventListener*>*
         matching_listeners) {
   std::string web_request_event_name(event_name);
-  extensions::WebViewRendererState::WebViewInfo web_view_info;
-  bool is_web_view_guest = extensions::WebViewRendererState::GetInstance()->
-      GetInfo(render_process_host_id, routing_id, &web_view_info);
+  WebViewRendererState::WebViewInfo web_view_info;
+  bool is_web_view_guest = WebViewRendererState::GetInstance()->GetInfo(
+      render_process_host_id, routing_id, &web_view_info);
   if (is_web_view_guest) {
     web_request_event_name.replace(
         0, sizeof(kWebRequestEventPrefix) - 1, webview::kWebViewEventPrefix);
@@ -1645,32 +1628,32 @@ base::ListValue* SummarizeCookieModifications(
     const CookieType& mod = *i->get();
     switch (mod.type) {
       case helpers::ADD:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationAdd);
+        summary->SetString(activity_log::kCookieModificationTypeKey,
+                           activity_log::kCookieModificationAdd);
         break;
       case helpers::EDIT:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationEdit);
+        summary->SetString(activity_log::kCookieModificationTypeKey,
+                           activity_log::kCookieModificationEdit);
         break;
       case helpers::REMOVE:
-        summary->SetString(activitylog::kCookieModificationTypeKey,
-                           activitylog::kCookieModificationRemove);
+        summary->SetString(activity_log::kCookieModificationTypeKey,
+                           activity_log::kCookieModificationRemove);
         break;
     }
     if (mod.filter) {
       if (mod.filter->name)
-        summary->SetString(activitylog::kCookieFilterNameKey,
+        summary->SetString(activity_log::kCookieFilterNameKey,
                            *mod.modification->name);
       if (mod.filter->domain)
-        summary->SetString(activitylog::kCookieFilterDomainKey,
+        summary->SetString(activity_log::kCookieFilterDomainKey,
                            *mod.modification->name);
     }
     if (mod.modification) {
       if (mod.modification->name)
-        summary->SetString(activitylog::kCookieModDomainKey,
+        summary->SetString(activity_log::kCookieModDomainKey,
                            *mod.modification->name);
       if (mod.modification->domain)
-        summary->SetString(activitylog::kCookieModDomainKey,
+        summary->SetString(activity_log::kCookieModDomainKey,
                            *mod.modification->name);
     }
     cookie_modifications->Append(summary.release());
@@ -1685,10 +1668,10 @@ scoped_ptr<base::DictionaryValue> SummarizeResponseDelta(
     const helpers::EventResponseDelta& delta) {
   scoped_ptr<base::DictionaryValue> details(new base::DictionaryValue());
   if (delta.cancel) {
-    details->SetBoolean(activitylog::kCancelKey, true);
+    details->SetBoolean(activity_log::kCancelKey, true);
   }
   if (!delta.new_url.is_empty()) {
-      details->SetString(activitylog::kNewUrlKey, delta.new_url.spec());
+    details->SetString(activity_log::kNewUrlKey, delta.new_url.spec());
   }
 
   scoped_ptr<base::ListValue> modified_headers(new base::ListValue());
@@ -1698,34 +1681,34 @@ scoped_ptr<base::DictionaryValue> SummarizeResponseDelta(
         helpers::CreateHeaderDictionary(iter.name(), iter.value()));
   }
   if (!modified_headers->empty()) {
-    details->Set(activitylog::kModifiedRequestHeadersKey,
+    details->Set(activity_log::kModifiedRequestHeadersKey,
                  modified_headers.release());
   }
 
   scoped_ptr<base::ListValue> deleted_headers(new base::ListValue());
   deleted_headers->AppendStrings(delta.deleted_request_headers);
   if (!deleted_headers->empty()) {
-    details->Set(activitylog::kDeletedRequestHeadersKey,
+    details->Set(activity_log::kDeletedRequestHeadersKey,
                  deleted_headers.release());
   }
 
   if (!delta.added_response_headers.empty()) {
-    details->Set(activitylog::kAddedRequestHeadersKey,
+    details->Set(activity_log::kAddedRequestHeadersKey,
                  SerializeResponseHeaders(delta.added_response_headers));
   }
   if (!delta.deleted_response_headers.empty()) {
-    details->Set(activitylog::kDeletedResponseHeadersKey,
+    details->Set(activity_log::kDeletedResponseHeadersKey,
                  SerializeResponseHeaders(delta.deleted_response_headers));
   }
   if (delta.auth_credentials) {
-    details->SetString(activitylog::kAuthCredentialsKey,
-                       base::UTF16ToUTF8(
-                           delta.auth_credentials->username()) + ":*");
+    details->SetString(
+        activity_log::kAuthCredentialsKey,
+        base::UTF16ToUTF8(delta.auth_credentials->username()) + ":*");
   }
 
   if (!delta.response_cookie_modifications.empty()) {
     details->Set(
-        activitylog::kResponseCookieModificationsKey,
+        activity_log::kResponseCookieModificationsKey,
         SummarizeCookieModifications(delta.response_cookie_modifications));
   }
 
@@ -1838,7 +1821,7 @@ void ExtensionWebRequestEventRouter::SendMessages(
          message != messages.end(); ++message) {
       scoped_ptr<base::DictionaryValue> argument(new base::DictionaryValue);
       ExtractRequestInfo(blocked_request.request, argument.get());
-      extensions::WebViewRendererState::WebViewInfo web_view_info;
+      WebViewRendererState::WebViewInfo web_view_info;
       bool is_web_view_guest = GetWebViewInfo(blocked_request.request,
                                               &web_view_info);
       argument->SetString(keys::kMessageKey, *message);
@@ -1965,9 +1948,9 @@ bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
-    extensions::RequestStage request_stage,
+    RequestStage request_stage,
     const net::HttpResponseHeaders* original_response_headers) {
-  extensions::WebViewRendererState::WebViewInfo web_view_info;
+  WebViewRendererState::WebViewInfo web_view_info;
   bool is_web_view_guest = GetWebViewInfo(request, &web_view_info);
   int rules_registry_id = is_web_view_guest
                               ? web_view_info.rules_registry_id
@@ -1976,7 +1959,7 @@ bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
   RulesRegistryKey rules_key(browser_context, rules_registry_id);
   // If this check fails, check that the active stages are up-to-date in
   // extensions/browser/api/declarative_webrequest/request_stage.h .
-  DCHECK(request_stage & extensions::kActiveStages);
+  DCHECK(request_stage & kActiveStages);
 
   // Rules of the current |browser_context| may apply but we need to check also
   // whether there are applicable rules from extensions whose background page
@@ -1984,8 +1967,7 @@ bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
 
   // First parameter identifies the registry, the second indicates whether the
   // registry belongs to the cross browser_context.
-  typedef std::pair<extensions::WebRequestRulesRegistry*, bool>
-      RelevantRegistry;
+  typedef std::pair<WebRequestRulesRegistry*, bool> RelevantRegistry;
   typedef std::vector<RelevantRegistry> RelevantRegistries;
   RelevantRegistries relevant_registries;
 
@@ -2009,7 +1991,7 @@ bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
   // logged with UMA Extensions.NetworkDelayRegistryLoad. crbug.com/175961
   for (RelevantRegistries::iterator i = relevant_registries.begin();
        i != relevant_registries.end(); ++i) {
-    extensions::WebRequestRulesRegistry* rules_registry = i->first;
+    WebRequestRulesRegistry* rules_registry = i->first;
     if (!rules_registry->ready().is_signaled()) {
       // The rules registry is still loading. Block this request until it
       // finishes.
@@ -2040,14 +2022,11 @@ bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
   bool deltas_created = false;
   for (RelevantRegistries::iterator i = relevant_registries.begin();
        i != relevant_registries.end(); ++i) {
-    extensions::WebRequestRulesRegistry* rules_registry =
-        i->first;
-    helpers::EventResponseDeltas result =
-        rules_registry->CreateDeltas(
-            extension_info_map,
-            extensions::WebRequestData(
-                request, request_stage, original_response_headers),
-            i->second);
+    WebRequestRulesRegistry* rules_registry = i->first;
+    helpers::EventResponseDeltas result = rules_registry->CreateDeltas(
+        extension_info_map,
+        WebRequestData(request, request_stage, original_response_headers),
+        i->second);
 
     if (!result.empty()) {
       helpers::EventResponseDeltas& deltas =
@@ -2068,7 +2047,7 @@ void ExtensionWebRequestEventRouter::OnRulesRegistryReady(
     void* browser_context,
     const std::string& event_name,
     uint64 request_id,
-    extensions::RequestStage request_stage) {
+    RequestStage request_stage) {
   // It's possible that this request was deleted, or cancelled by a previous
   // event handler. If so, ignore this response.
   if (blocked_requests_.find(request_id) == blocked_requests_.end())
@@ -2124,7 +2103,7 @@ void ExtensionWebRequestEventRouter::ClearSignaled(uint64 request_id,
 // webRequest.handlerBehaviorChanged() should trigger a quota violation at the
 // time it is called. Instead we only decrement the bucket counter at the time
 // when the cache is cleared (when page loads happen).
-class ClearCacheQuotaHeuristic : public extensions::QuotaLimitHeuristic {
+class ClearCacheQuotaHeuristic : public QuotaLimitHeuristic {
  public:
   ClearCacheQuotaHeuristic(const Config& config, BucketMapper* map)
       : QuotaLimitHeuristic(
@@ -2210,8 +2189,7 @@ bool WebRequestInternalAddEventListenerFunction::RunSync() {
   int web_view_instance_id = 0;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(5, &web_view_instance_id));
 
-  base::WeakPtr<extensions::IOThreadExtensionMessageFilter> ipc_sender =
-      ipc_sender_weak();
+  base::WeakPtr<IOThreadExtensionMessageFilter> ipc_sender = ipc_sender_weak();
   int embedder_process_id =
       ipc_sender.get() && web_view_instance_id > 0 ?
           ipc_sender->render_process_id() : 0;
@@ -2229,7 +2207,7 @@ bool WebRequestInternalAddEventListenerFunction::RunSync() {
          (ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING |
           ExtensionWebRequestEventRouter::ExtraInfoSpec::ASYNC_BLOCKING)) &&
         !extension->permissions_data()->HasAPIPermission(
-            extensions::APIPermission::kWebRequestBlocking)) {
+            APIPermission::kWebRequestBlocking)) {
       error_ = keys::kBlockingPermissionRequired;
       return false;
     }
@@ -2434,13 +2412,13 @@ bool WebRequestInternalEventHandledFunction::RunSync() {
 }
 
 void WebRequestHandlerBehaviorChangedFunction::GetQuotaLimitHeuristics(
-    extensions::QuotaLimitHeuristics* heuristics) const {
-  extensions::QuotaLimitHeuristic::Config config = {
+    QuotaLimitHeuristics* heuristics) const {
+  QuotaLimitHeuristic::Config config = {
       // See web_request.json for current value.
       web_request::MAX_HANDLER_BEHAVIOR_CHANGED_CALLS_PER_10_MINUTES,
       base::TimeDelta::FromMinutes(10)};
-  extensions::QuotaLimitHeuristic::BucketMapper* bucket_mapper =
-      new extensions::QuotaLimitHeuristic::SingletonBucketMapper();
+  QuotaLimitHeuristic::BucketMapper* bucket_mapper =
+      new QuotaLimitHeuristic::SingletonBucketMapper();
   ClearCacheQuotaHeuristic* heuristic =
       new ClearCacheQuotaHeuristic(config, bucket_mapper);
   heuristics->push_back(heuristic);
@@ -2465,3 +2443,5 @@ bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
+
+}  // namespace extensions
diff --git a/extensions/browser/api/web_request/web_request_api.h b/extensions/browser/api/web_request/web_request_api.h
index 3a692ea..49bed01 100644
--- a/extensions/browser/api/web_request/web_request_api.h
+++ b/extensions/browser/api/web_request/web_request_api.h
@@ -85,8 +85,6 @@ class WebRequestAPI : public BrowserContextKeyedAPI,
   DISALLOW_COPY_AND_ASSIGN(WebRequestAPI);
 };
 
-}  // namespace extensions
-
 // This class observes network events and routes them to the appropriate
 // extensions listening to those events. All methods must be called on the IO
 // thread unless otherwise specified.
@@ -556,4 +554,6 @@ class WebRequestHandlerBehaviorChangedFunction
   bool RunSync() override;
 };
 
+}  // namespace extensions
+
 #endif  // EXTENSIONS_BROWSER_API_WEB_REQUEST_WEB_REQUEST_API_H_
diff --git a/extensions/browser/event_listener_map_unittest.cc b/extensions/browser/event_listener_map_unittest.cc
index 6fae050..c82e36f 100644
--- a/extensions/browser/event_listener_map_unittest.cc
+++ b/extensions/browser/event_listener_map_unittest.cc
@@ -65,9 +65,9 @@ class EventListenerMapTest : public testing::Test {
                                 const GURL& url) {
     EventFilteringInfo info;
     info.SetURL(url);
-    scoped_ptr<Event> result(
-        new Event(events::UNKNOWN, event_name, make_scoped_ptr(new ListValue()),
-                  NULL, GURL(), EventRouter::USER_GESTURE_UNKNOWN, info));
+    scoped_ptr<Event> result(new Event(
+        events::FOR_TEST, event_name, make_scoped_ptr(new ListValue()), NULL,
+        GURL(), EventRouter::USER_GESTURE_UNKNOWN, info));
     return result.Pass();
   }
 
diff --git a/extensions/browser/event_router.cc b/extensions/browser/event_router.cc
index 7b37920..7701c5a 100644
--- a/extensions/browser/event_router.cc
+++ b/extensions/browser/event_router.cc
@@ -797,41 +797,41 @@ void EventRouter::OnExtensionUnloaded(content::BrowserContext* browser_context,
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
              scoped_ptr<base::ListValue> event_args)
-    : histogram_value(histogram_value),
-      event_name(event_name),
-      event_args(event_args.Pass()),
-      restrict_to_browser_context(NULL),
-      user_gesture(EventRouter::USER_GESTURE_UNKNOWN) {
-  DCHECK(this->event_args.get());
-}
+    : Event(histogram_value, event_name, event_args.Pass(), nullptr) {}
 
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
              scoped_ptr<base::ListValue> event_args,
              BrowserContext* restrict_to_browser_context)
-    : histogram_value(histogram_value),
-      event_name(event_name),
-      event_args(event_args.Pass()),
-      restrict_to_browser_context(restrict_to_browser_context),
-      user_gesture(EventRouter::USER_GESTURE_UNKNOWN) {
-  DCHECK(this->event_args.get());
-}
+    : Event(histogram_value,
+            event_name,
+            event_args.Pass(),
+            restrict_to_browser_context,
+            GURL(),
+            EventRouter::USER_GESTURE_UNKNOWN,
+            EventFilteringInfo()) {}
 
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
-             scoped_ptr<ListValue> event_args,
+             scoped_ptr<ListValue> event_args_tmp,
              BrowserContext* restrict_to_browser_context,
              const GURL& event_url,
              EventRouter::UserGestureState user_gesture,
              const EventFilteringInfo& filter_info)
     : histogram_value(histogram_value),
       event_name(event_name),
-      event_args(event_args.Pass()),
+      event_args(event_args_tmp.Pass()),
       restrict_to_browser_context(restrict_to_browser_context),
       event_url(event_url),
       user_gesture(user_gesture),
       filter_info(filter_info) {
-  DCHECK(this->event_args.get());
+  DCHECK(event_args);
+  DCHECK_NE(events::UNKNOWN, histogram_value)
+      << "events::UNKNOWN cannot be used as a histogram value.\n"
+      << "If this is a test, use events::FOR_TEST.\n"
+      << "If this is production code, it is important that you use a realistic "
+      << "value so that we can accurately track event usage. "
+      << "See extension_event_histogram_value.h for inspiration.";
 }
 
 Event::~Event() {}
diff --git a/extensions/browser/extension_event_histogram_value.h b/extensions/browser/extension_event_histogram_value.h
index 9057d6a..92054c0 100644
--- a/extensions/browser/extension_event_histogram_value.h
+++ b/extensions/browser/extension_event_histogram_value.h
@@ -360,6 +360,10 @@ enum HistogramValue {
   CAST_CHANNEL_ON_ERROR,
   SCREENLOCK_PRIVATE_ON_CHANGED,
   SCREENLOCK_PRIVATE_ON_AUTH_ATTEMPTED,
+  TYPES_CHROME_SETTING_ON_CHANGE,
+  TYPES_PRIVATE_CHROME_DIRECT_SETTING_ON_CHANGE,
+  WEB_VIEW_INTERNAL_ON_MESSAGE,  // TODO(kalman): where are the rest of the
+                                 // webview events?
   // Last entry: Add new entries above, then run:
   // python tools/metrics/histograms/update_extension_histograms.py
   ENUM_BOUNDARY
diff --git a/extensions/browser/extensions_browser_client.h b/extensions/browser/extensions_browser_client.h
index 4aefa37..883afc8 100644
--- a/extensions/browser/extensions_browser_client.h
+++ b/extensions/browser/extensions_browser_client.h
@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
+#include "extensions/browser/extension_event_histogram_value.h"
 #include "extensions/browser/extension_prefs_observer.h"
 
 class ExtensionFunctionRegistry;
@@ -196,7 +197,8 @@ class ExtensionsBrowserClient {
 
   // Propagate a event to all the renderers in every browser context. The
   // implementation must be safe to call from any thread.
-  virtual void BroadcastEventToRenderers(const std::string& event_name,
+  virtual void BroadcastEventToRenderers(events::HistogramValue histogram_value,
+                                         const std::string& event_name,
                                          scoped_ptr<base::ListValue> args) = 0;
 
   // Returns the embedder's net::NetLog.
diff --git a/extensions/browser/test_extensions_browser_client.cc b/extensions/browser/test_extensions_browser_client.cc
index 6f2821d..979707b 100644
--- a/extensions/browser/test_extensions_browser_client.cc
+++ b/extensions/browser/test_extensions_browser_client.cc
@@ -177,9 +177,9 @@ TestExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 }
 
 void TestExtensionsBrowserClient::BroadcastEventToRenderers(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
-    scoped_ptr<base::ListValue> args) {
-}
+    scoped_ptr<base::ListValue> args) {}
 
 net::NetLog* TestExtensionsBrowserClient::GetNetLog() {
   return NULL;
diff --git a/extensions/browser/test_extensions_browser_client.h b/extensions/browser/test_extensions_browser_client.h
index 9adf4d5..c0eb20f 100644
--- a/extensions/browser/test_extensions_browser_client.h
+++ b/extensions/browser/test_extensions_browser_client.h
@@ -88,7 +88,8 @@ class TestExtensionsBrowserClient : public ExtensionsBrowserClient {
       content::BrowserContext* context) const override;
   const ComponentExtensionResourceManager*
   GetComponentExtensionResourceManager() override;
-  void BroadcastEventToRenderers(const std::string& event_name,
+  void BroadcastEventToRenderers(events::HistogramValue histogram_value,
+                                 const std::string& event_name,
                                  scoped_ptr<base::ListValue> args) override;
   net::NetLog* GetNetLog() override;
   ExtensionCache* GetExtensionCache() override;
diff --git a/extensions/shell/browser/shell_extensions_browser_client.cc b/extensions/shell/browser/shell_extensions_browser_client.cc
index 7a14a93..df0f872 100644
--- a/extensions/shell/browser/shell_extensions_browser_client.cc
+++ b/extensions/shell/browser/shell_extensions_browser_client.cc
@@ -202,20 +202,19 @@ ShellExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 }
 
 void ShellExtensionsBrowserClient::BroadcastEventToRenderers(
+    events::HistogramValue histogram_value,
     const std::string& event_name,
     scoped_ptr<base::ListValue> args) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
+        BrowserThread::UI, FROM_HERE,
         base::Bind(&ShellExtensionsBrowserClient::BroadcastEventToRenderers,
-                   base::Unretained(this),
-                   event_name,
+                   base::Unretained(this), histogram_value, event_name,
                    base::Passed(&args)));
     return;
   }
 
-  scoped_ptr<Event> event(new Event(events::UNKNOWN, event_name, args.Pass()));
+  scoped_ptr<Event> event(new Event(histogram_value, event_name, args.Pass()));
   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
diff --git a/extensions/shell/browser/shell_extensions_browser_client.h b/extensions/shell/browser/shell_extensions_browser_client.h
index 24ca6d9..9995d73 100644
--- a/extensions/shell/browser/shell_extensions_browser_client.h
+++ b/extensions/shell/browser/shell_extensions_browser_client.h
@@ -79,7 +79,8 @@ class ShellExtensionsBrowserClient : public ExtensionsBrowserClient {
       content::BrowserContext* context) const override;
   const ComponentExtensionResourceManager*
   GetComponentExtensionResourceManager() override;
-  void BroadcastEventToRenderers(const std::string& event_name,
+  void BroadcastEventToRenderers(events::HistogramValue histogram_value,
+                                 const std::string& event_name,
                                  scoped_ptr<base::ListValue> args) override;
   net::NetLog* GetNetLog() override;
   ExtensionCache* GetExtensionCache() override;
diff --git a/tools/metrics/histograms/histograms.xml b/tools/metrics/histograms/histograms.xml
index 264bafe..985069e 100644
--- a/tools/metrics/histograms/histograms.xml
+++ b/tools/metrics/histograms/histograms.xml
@@ -55403,6 +55403,9 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
   <int value="339" label="CAST_CHANNEL_ON_ERROR"/>
   <int value="340" label="SCREENLOCK_PRIVATE_ON_CHANGED"/>
   <int value="341" label="SCREENLOCK_PRIVATE_ON_AUTH_ATTEMPTED"/>
+  <int value="342" label="TYPES_CHROME_SETTING_ON_CHANGE"/>
+  <int value="343" label="TYPES_PRIVATE_CHROME_DIRECT_SETTING_ON_CHANGE"/>
+  <int value="344" label="WEB_VIEW_INTERNAL_ON_MESSAGE"/>
 </enum>
 
 <enum name="ExtensionFileWriteResult" type="int">