Final batch adding real histogram values for extension events.

chrome/browser/extensions/api/font_settings/font_settings_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Font Settings Extension API implementation.
 
 #include "chrome/browser/extensions/api/font_settings/font_settings_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 84 matching lines @@
 }  // namespace
 
 FontSettingsEventRouter::FontSettingsEventRouter(
     Profile* profile) : profile_(profile) {
   TRACE_EVENT0("browser,startup", "FontSettingsEventRouter::ctor")
   SCOPED_UMA_HISTOGRAM_TIMER("Extensions.FontSettingsEventRouterCtorTime");
 
   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,
                  base::Unretained(this));
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitStandardFontFamilyMap, callback);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitSerifFontFamilyMap, callback);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitSansSerifFontFamilyMap, callback);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFixedFontFamilyMap, callback);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitCursiveFontFamilyMap, callback);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFantasyFontFamilyMap, callback);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitPictographFontFamilyMap,
                                 callback);
 }
 
 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(
     const std::string& pref_name) {
   std::string generic_family;
   std::string script;
   if (pref_names_util::ParseFontNamePrefPath(pref_name, &generic_family,
                                              &script)) {
     OnFontNamePrefChanged(pref_name, generic_family, script);
     return;
@@ skipping 18 matching lines @@
   font_name = MaybeGetLocalizedFontName(font_name);
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   args.Append(dict);
   dict->SetString(kFontIdKey, font_name);
   dict->SetString(kGenericFamilyKey, generic_family);
   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) {
   const PrefService::Preference* pref = registrar_.prefs()->FindPreference(
       pref_name);
   CHECK(pref);
 
   base::ListValue args;
   base::DictionaryValue* dict = new base::DictionaryValue();
   args.Append(dict);
   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)
     : font_settings_event_router_(
           new FontSettingsEventRouter(Profile::FromBrowserContext(context))) {}
 
 FontSettingsAPI::~FontSettingsAPI() {
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<FontSettingsAPI> >
@@ skipping 233 matching lines @@
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitMinimumFontSize;
 }
 
 const char* FontSettingsSetMinimumFontSizeFunction::GetKey() {
   return kPixelSizeKey;
 }
 
 }  // namespace extensions