Add character encoding to Font Settings Extension API.

chrome/browser/extensions/extension_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.
 
 #include "chrome/browser/extensions/extension_font_settings_api.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/stringprintf.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/font.h"
 #include "ui/gfx/platform_font_win.h"
 #endif
 
 namespace {
 
+const char kCharsetKey[] = "charset";
+const char kFontNameKey[] = "fontName";
 const char kGenericFamilyKey[] = "genericFamily";
-const char kFontNameKey[] = "fontName";
 const char kLocalizedNameKey[] = "localizedName";
 const char kPixelSizeKey[] = "pixelSize";
 const char kScriptKey[] = "script";
 
+const char kOnDefaultCharacterSetChanged[] =
+    "experimental.fontSettings.onDefaultCharacterSetChanged";
 const char kOnDefaultFixedFontSizeChanged[] =
     "experimental.fontSettings.onDefaultFixedFontSizeChanged";
 const char kOnDefaultFontSizeChanged[] =
     "experimental.fontSettings.onDefaultFontSizeChanged";
 const char kOnFontChanged[] = "experimental.fontSettings.onFontChanged";
 const char kOnMinimumFontSizeChanged[] =
     "experimental.fontSettings.onMinimumFontSizeChanged";
 
 // Format for per-script font preference keys.
 // E.g., "webkit.webprefs.fonts.standard.Hrkt"
@@ skipping 85 matching lines @@
 }  // namespace
 
 ExtensionFontSettingsEventRouter::ExtensionFontSettingsEventRouter(
     Profile* profile) : profile_(profile) {}
 
 ExtensionFontSettingsEventRouter::~ExtensionFontSettingsEventRouter() {}
 
 void ExtensionFontSettingsEventRouter::Init() {
   registrar_.Init(profile_->GetPrefs());
 
-  registrar_.Add(prefs::kWebKitGlobalDefaultFixedFontSize, this);
-  pref_event_map_[prefs::kWebKitGlobalDefaultFixedFontSize] =
-      kOnDefaultFixedFontSizeChanged;
-
-  registrar_.Add(prefs::kWebKitGlobalDefaultFontSize, this);
-  pref_event_map_[prefs::kWebKitGlobalDefaultFontSize] =
-      kOnDefaultFontSizeChanged;
-
-  registrar_.Add(prefs::kWebKitGlobalMinimumFontSize, this);
-  pref_event_map_[prefs::kWebKitGlobalMinimumFontSize] =
-      kOnMinimumFontSizeChanged;
+  AddPrefToObserve(prefs::kWebKitGlobalDefaultFixedFontSize,
+                   kOnDefaultFixedFontSizeChanged,
+                   kPixelSizeKey);
+  AddPrefToObserve(prefs::kWebKitGlobalDefaultFontSize,
+                   kOnDefaultFontSizeChanged,
+                   kPixelSizeKey);
+  AddPrefToObserve(prefs::kWebKitGlobalMinimumFontSize,
+                   kOnMinimumFontSizeChanged,
+                   kPixelSizeKey);
+  AddPrefToObserve(prefs::kGlobalDefaultCharset,
+                   kOnDefaultCharacterSetChanged,
+                   kCharsetKey);
 
   registrar_.Add(prefs::kWebKitGlobalStandardFontFamily, this);
   registrar_.Add(prefs::kWebKitGlobalSerifFontFamily, this);
   registrar_.Add(prefs::kWebKitGlobalSansSerifFontFamily, this);
   registrar_.Add(prefs::kWebKitGlobalFixedFontFamily, this);
   registrar_.Add(prefs::kWebKitGlobalCursiveFontFamily, this);
   registrar_.Add(prefs::kWebKitGlobalFantasyFontFamily, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitStandardFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitSerifFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitSansSerifFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFixedFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitCursiveFontFamilyMap, this);
   RegisterFontFamilyMapObserver(&registrar_,
                                 prefs::kWebKitFantasyFontFamilyMap, this);
 }
 
+void ExtensionFontSettingsEventRouter::AddPrefToObserve(const char* pref_name,
+                                                        const char* event_name,
+                                                        const char* key) {
+  registrar_.Add(pref_name, this);
+  pref_event_map_[pref_name] = std::make_pair(event_name, key);
+}
+
 void ExtensionFontSettingsEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type != chrome::NOTIFICATION_PREF_CHANGED) {
     NOTREACHED();
     return;
   }
 
   PrefService* pref_service = content::Source<PrefService>(source).ptr();
   bool incognito = (pref_service != profile_->GetPrefs());
   // We're only observing pref changes on the regular profile.
   DCHECK(!incognito);
-  const std::string* pref_key =
+  const std::string* pref_name =
       content::Details<const std::string>(details).ptr();
 
-  PrefEventMap::iterator iter = pref_event_map_.find(*pref_key);
+  PrefEventMap::iterator iter = pref_event_map_.find(*pref_name);
   if (iter != pref_event_map_.end()) {
-    OnFontSizePrefChanged(pref_service, *pref_key, iter->second, incognito);
+    const std::string& event_name = iter->second.first;
+    const std::string& key = iter->second.second;
+    OnFontPrefChanged(pref_service, *pref_name, event_name, key, incognito);
     return;
   }
 
   std::string generic_family;
   std::string script;
-  if (ParseFontNamePrefPath(*pref_key, &generic_family, &script)) {
-    OnFontNamePrefChanged(pref_service, *pref_key, generic_family, script,
+  if (ParseFontNamePrefPath(*pref_name, &generic_family, &script)) {
+    OnFontNamePrefChanged(pref_service, *pref_name, generic_family, script,
                           incognito);
     return;
   }
 
   NOTREACHED();
 }
 
 void ExtensionFontSettingsEventRouter::OnFontNamePrefChanged(
     PrefService* pref_service,
-    const std::string& pref_key,
+    const std::string& pref_name,
     const std::string& generic_family,
     const std::string& script,
     bool incognito) {
   const PrefService::Preference* pref = pref_service->FindPreference(
-      pref_key.c_str());
+      pref_name.c_str());
   CHECK(pref);
 
   std::string font_name;
   if (!pref->GetValue()->GetAsString(&font_name)) {
     NOTREACHED();
     return;
   }
   font_name = MaybeGetLocalizedFontName(font_name);
 
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
   dict->SetString(kFontNameKey, font_name);
   dict->SetString(kGenericFamilyKey, generic_family);
   if (!script.empty())
     dict->SetString(kScriptKey, script);
 
   extension_preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       ExtensionAPIPermission::kExperimental,
       incognito,
-      pref_key);
+      pref_name);
 }
 
-void ExtensionFontSettingsEventRouter::OnFontSizePrefChanged(
+void ExtensionFontSettingsEventRouter::OnFontPrefChanged(
     PrefService* pref_service,
-    const std::string& pref_key,
+    const std::string& pref_name,
     const std::string& event_name,
+    const std::string& key,
     bool incognito) {
   const PrefService::Preference* pref = pref_service->FindPreference(
-      pref_key.c_str());
+      pref_name.c_str());
   CHECK(pref);
 
-  int size;
-  if (!pref->GetValue()->GetAsInteger(&size)) {
-    NOTREACHED();
-    return;
-  }
-
   ListValue args;
   DictionaryValue* dict = new DictionaryValue();
   args.Append(dict);
-  dict->SetInteger(kPixelSizeKey, size);
+  dict->Set(key, pref->GetValue()->DeepCopy());
 
   extension_preference_helpers::DispatchEventToExtensions(
       profile_,
       event_name,
       &args,
       ExtensionAPIPermission::kExperimental,
       incognito,
-      pref_key);
+      pref_name);
 }
 
 bool GetFontFunction::RunImpl() {
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
 
   std::string pref_path;
   EXTENSION_FUNCTION_VALIDATE(GetFontNamePrefPath(details, &pref_path));
 
   PrefService* prefs = profile_->GetPrefs();
@@ skipping 67 matching lines @@
     DictionaryValue* font_name = new DictionaryValue();
     font_name->Set(kFontNameKey, Value::CreateStringValue(name));
     font_name->Set(kLocalizedNameKey, Value::CreateStringValue(localized_name));
     result->Append(font_name);
   }
 
   result_.reset(result.release());
   return true;
 }
 
-bool GetFontSizeExtensionFunction::RunImpl() {
+bool GetFontPrefExtensionFunction::RunImpl() {
   PrefService* prefs = profile_->GetPrefs();
-  int size = prefs->GetInteger(GetPrefName());
+  const PrefService::Preference* pref = prefs->FindPreference(GetPrefName());
+  EXTENSION_FUNCTION_VALIDATE(pref);
 
   DictionaryValue* result = new DictionaryValue();
-  result->SetInteger(kPixelSizeKey, size);
+  result->Set(GetKey(), pref->GetValue()->DeepCopy());
   result_.reset(result);
   return true;
 }
 
-bool SetFontSizeExtensionFunction::RunImpl() {
+bool SetFontPrefExtensionFunction::RunImpl() {
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
 
-  int size;
-  EXTENSION_FUNCTION_VALIDATE(details->GetInteger(kPixelSizeKey, &size));
+  Value* value;
+  EXTENSION_FUNCTION_VALIDATE(details->Get(GetKey(), &value));
 
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->SetExtensionControlledPref(extension_id(),
                                     GetPrefName(),
                                     kExtensionPrefsScopeRegular,
-                                    Value::CreateIntegerValue(size));
+                                    value->DeepCopy());
   return true;
 }
 
 const char* GetDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitGlobalDefaultFontSize;
 }
 
+const char* GetDefaultFontSizeFunction::GetKey() {
+  return kPixelSizeKey;
+}
+
 const char* SetDefaultFontSizeFunction::GetPrefName() {
   return prefs::kWebKitGlobalDefaultFontSize;
 }
 
+const char* SetDefaultFontSizeFunction::GetKey() {
+  return kPixelSizeKey;
+}
+
 const char* GetDefaultFixedFontSizeFunction::GetPrefName() {
   return prefs::kWebKitGlobalDefaultFixedFontSize;
 }
 
+const char* GetDefaultFixedFontSizeFunction::GetKey() {
+  return kPixelSizeKey;
+}
+
 const char* SetDefaultFixedFontSizeFunction::GetPrefName() {
   return prefs::kWebKitGlobalDefaultFixedFontSize;
 }
 
+const char* SetDefaultFixedFontSizeFunction::GetKey() {
+  return kPixelSizeKey;
+}
+
 const char* GetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitGlobalMinimumFontSize;
 }
 
+const char* GetMinimumFontSizeFunction::GetKey() {
+  return kPixelSizeKey;
+}
+
 const char* SetMinimumFontSizeFunction::GetPrefName() {
   return prefs::kWebKitGlobalMinimumFontSize;
 }
+
+const char* SetMinimumFontSizeFunction::GetKey() {
+  return kPixelSizeKey;
+}
+
+const char* GetDefaultCharacterSetFunction::GetPrefName() {
+  return prefs::kGlobalDefaultCharset;
+}
+
+const char* GetDefaultCharacterSetFunction::GetKey() {
+  return kCharsetKey;
+}
+
+const char* SetDefaultCharacterSetFunction::GetPrefName() {
+  return prefs::kGlobalDefaultCharset;
+}
+
+const char* SetDefaultCharacterSetFunction::GetKey() {
+  return kCharsetKey;
+}