Migrate WebKit "global script" font prefs.

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 32 matching lines @@
 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"
-const char kWebKitPerScriptFontPrefFormat[] = "webkit.webprefs.fonts.%s.%s";
-const char kWebKitPerScriptFontPrefPrefix[] = "webkit.webprefs.fonts.";
-
-// Format for global (non per-script) font preference keys.
-// E.g., "webkit.webprefs.global.fixed_font_family"
-// Note: there are two meanings of "global" here. The "Global" in the const name
-// means "not per-script". The "global" in the key itself means "not per-tab"
-// (per-profile).
-const char kWebKitGlobalFontPrefFormat[] =
-    "webkit.webprefs.global.%s_font_family";
-const char kWebKitGlobalFontPrefPrefix[] = "webkit.webprefs.global.";
-const char kWebKitGlobalFontPrefSuffix[] = "_font_family";
+// Format for font preference keys.
+const char kWebKitFontPrefFormat[] = "webkit.webprefs.fonts.%s.%s";
+const char kWebKitFontPrefPrefix[] = "webkit.webprefs.fonts.";
 
 // Gets the font name preference path from |details| which contains key
 // |kGenericFamilyKey| and optionally |kScriptKey|.
 bool GetFontNamePrefPath(DictionaryValue* details, std::string* pref_path) {
   std::string generic_family;
   if (!details->GetString(kGenericFamilyKey, &generic_family))
     return false;
 
-  if (details->HasKey(kScriptKey)) {
-    std::string script;
-    if (!details->GetString(kScriptKey, &script))
-      return false;
-    *pref_path = StringPrintf(kWebKitPerScriptFontPrefFormat,
-                                   generic_family.c_str(),
-                                   script.c_str());
-  } else {
-    *pref_path = StringPrintf(kWebKitGlobalFontPrefFormat,
-                                   generic_family.c_str());
-  }
-
+  std::string script;
+  if (!details->HasKey(kScriptKey))
+    script = prefs::kWebKitCommonScript;
+  else if (!details->GetString(kScriptKey, &script))
+    return false;
+  *pref_path = StringPrintf(kWebKitFontPrefFormat,
+                            generic_family.c_str(),
+                            script.c_str());
   return true;
 }
 
 // Extracts the generic family and script from font name pref path |pref_path|.
 bool ParseFontNamePrefPath(std::string pref_path,
                            std::string* generic_family,
                            std::string* script) {
-  if (StartsWithASCII(pref_path, kWebKitPerScriptFontPrefPrefix, true)) {
-    size_t start = strlen(kWebKitPerScriptFontPrefPrefix);
-    size_t pos = pref_path.find('.', start);
-    if (pos == std::string::npos || pos + 1 == pref_path.length())
-      return false;
-    *generic_family = pref_path.substr(start, pos - start);
-    *script = pref_path.substr(pos + 1);
-    return true;
-  } else if (StartsWithASCII(pref_path, kWebKitGlobalFontPrefPrefix, true) &&
-             EndsWith(pref_path, kWebKitGlobalFontPrefSuffix, true)) {
-    size_t start = strlen(kWebKitGlobalFontPrefPrefix);
-    size_t pos = pref_path.find('_', start);
-    if (pos == std::string::npos || pos + 1 == pref_path.length())
-      return false;
-    *generic_family = pref_path.substr(start, pos - start);
-    *script = "";
-    return true;
-  }
-  return false;
+  if (!StartsWithASCII(pref_path, kWebKitFontPrefPrefix, true))
+    return false;
+
+  size_t start = strlen(kWebKitFontPrefPrefix);
+  size_t pos = pref_path.find('.', start);
+  if (pos == std::string::npos || pos + 1 == pref_path.length())
+    return false;
+  *generic_family = pref_path.substr(start, pos - start);
+  *script = pref_path.substr(pos + 1);
+  return true;
 }
 
 // Returns the localized name of a font so that it can be matched within the
 // list of system fonts. On Windows, the list of system fonts has names only
 // for the system locale, but the pref value may be in the English name.
 std::string MaybeGetLocalizedFontName(const std::string& font_name) {
 #if defined(OS_WIN)
   if (!font_name.empty()) {
     gfx::Font font(font_name, 12);  // dummy font size
     return static_cast<gfx::PlatformFontWin*>(font.platform_font())->
@@ skipping 30 matching lines @@
   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);
@@ skipping 58 matching lines @@
     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);
+  dict->SetString(kScriptKey, script);
 
   extension_preference_helpers::DispatchEventToExtensions(
       profile_,
       kOnFontChanged,
       &args,
       ExtensionAPIPermission::kExperimental,
       incognito,
       pref_name);
 }
 
@@ skipping 84 matching lines @@
 
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
 
   std::string pref_path;
   EXTENSION_FUNCTION_VALIDATE(GetFontNamePrefPath(details, &pref_path));
 
   std::string font_name;
   EXTENSION_FUNCTION_VALIDATE(details->GetString(kFontNameKey, &font_name));
 
-  // Ensure |pref_path| really is for a registered per-script font pref.
+  // Ensure |pref_path| really is for a registered font pref.
   EXTENSION_FUNCTION_VALIDATE(
       profile_->GetPrefs()->FindPreference(pref_path.c_str()));
 
   ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
   prefs->SetExtensionControlledPref(extension_id(), pref_path.c_str(),
                                     kExtensionPrefsScopeRegular,
                                     Value::CreateStringValue(font_name));
   return true;
 }
 
@@ skipping 166 matching lines @@
   return kCharsetKey;
 }
 
 const char* SetDefaultCharacterSetFunction::GetPrefName() {
   return prefs::kGlobalDefaultCharset;
 }
 
 const char* SetDefaultCharacterSetFunction::GetKey() {
   return kCharsetKey;
 }