When a font family pref changes to the empty string, pass it to WebKit.

chrome/browser/ui/prefs/prefs_tab_helper.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/ui/prefs/prefs_tab_helper.h"
 
 #include <string>
 
 #include "base/prefs/overlay_user_pref_store.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/pref_names_util.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/locale_settings.h"
 #include "grit/platform_locale_settings.h"
 #include "unicode/uchar.h"
 #include "unicode/uscript.h"
 #include "webkit/glue/webpreferences.h"
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/themes/theme_service_factory.h"
 #endif
 
 using content::WebContents;
 using webkit_glue::WebPreferences;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(PrefsTabHelper)
 
 namespace {
 
 // Registers prefs only used for migration.
-static void RegisterPrefsToMigrate(PrefService* prefs) {
+void RegisterPrefsToMigrate(PrefService* prefs) {
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldStandardFontFamily,
                                      IDS_STANDARD_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldFixedFontFamily,
                                      IDS_FIXED_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldSerifFontFamily,
                                      IDS_SERIF_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldSansSerifFontFamily,
@@ skipping 273 matching lines @@
   { prefs::kWebKitGlobalSansSerifFontFamily,
     prefs::kWebKitSansSerifFontFamily },
   { prefs::kWebKitGlobalSerifFontFamily,
     prefs::kWebKitSerifFontFamily },
   { prefs::kWebKitGlobalStandardFontFamily,
     prefs::kWebKitStandardFontFamily }
 };
 
 const int kPrefsToMigrateLength = ARRAYSIZE_UNSAFE(kPrefNamesToMigrate);
 
-static void MigratePreferences(PrefService* prefs) {
+void MigratePreferences(PrefService* prefs) {
   RegisterPrefsToMigrate(prefs);
   for (int i = 0; i < kPrefsToMigrateLength; ++i) {
     const PrefService::Preference* pref =
         prefs->FindPreference(kPrefNamesToMigrate[i].from);
     if (!pref) continue;
     if (!pref->IsDefaultValue()) {
       prefs->Set(kPrefNamesToMigrate[i].to, *pref->GetValue());
     }
     prefs->ClearPref(kPrefNamesToMigrate[i].from);
     prefs->UnregisterPreference(kPrefNamesToMigrate[i].from);
   }
 }
 
+// Sets a font family pref in |prefs| to |pref_value|.
+void OverrideFontFamily(WebPreferences* prefs,
+                        const std::string& generic_family,
+                        const std::string& script,
+                        const std::string& pref_value) {
+  WebPreferences::ScriptFontFamilyMap* map = NULL;
+  if (generic_family == "standard")
+    map = &prefs->standard_font_family_map;
+  else if (generic_family == "fixed")
+    map = &prefs->fixed_font_family_map;
+  else if (generic_family == "serif")
+    map = &prefs->serif_font_family_map;
+  else if (generic_family == "sansserif")
+    map = &prefs->sans_serif_font_family_map;
+  else if (generic_family == "cursive")
+    map = &prefs->cursive_font_family_map;
+  else if (generic_family == "fantasy")
+    map = &prefs->fantasy_font_family_map;
+  else if (generic_family == "pictograph")
+    map = &prefs->pictograph_font_family_map;
+  else
+    NOTREACHED() << "Unknown generic font family: " << generic_family;
+  (*map)[script] = UTF8ToUTF16(pref_value);
+}
+
 }  // namespace
 
 PrefsTabHelper::PrefsTabHelper(WebContents* contents)
     : web_contents_(contents) {
   PrefService* prefs = GetProfile()->GetPrefs();
   pref_change_registrar_.Init(prefs);
   if (prefs) {
     for (int i = 0; i < kPrefsToObserveLength; ++i)
       pref_change_registrar_.Add(kPrefsToObserve[i], this);
 
@@ skipping 179 matching lines @@
       UpdateRendererPreferences();
       break;
     }
 #endif
     case chrome::NOTIFICATION_PREF_CHANGED: {
       std::string* pref_name_in = content::Details<std::string>(details).ptr();
       DCHECK(content::Source<PrefService>(source).ptr() ==
                  GetProfile()->GetPrefs());
       if (*pref_name_in == prefs::kDefaultCharset ||
           StartsWithASCII(*pref_name_in, "webkit.webprefs.", true)) {
-        UpdateWebPreferences();
+        OnWebPrefChanged(*pref_name_in);
       } else if (*pref_name_in == prefs::kDefaultZoomLevel ||
                  *pref_name_in == prefs::kEnableReferrers ||
                  *pref_name_in == prefs::kEnableDoNotTrack) {
         UpdateRendererPreferences();
       } else {
         NOTREACHED() << "unexpected pref change notification" << *pref_name_in;
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void PrefsTabHelper::UpdateWebPreferences() {
   web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(
       web_contents_->GetRenderViewHost()->GetWebkitPreferences());
 }
 
 void PrefsTabHelper::UpdateRendererPreferences() {
   renderer_preferences_util::UpdateFromSystemSettings(
       web_contents_->GetMutableRendererPrefs(), GetProfile());
   web_contents_->GetRenderViewHost()->SyncRendererPrefs();
 }
 
 Profile* PrefsTabHelper::GetProfile() {
   return Profile::FromBrowserContext(web_contents_->GetBrowserContext());
 }
+
+void PrefsTabHelper::OnWebPrefChanged(const std::string& pref_name) {
+  // When a font family pref's value goes from non-empty to the empty string, we
+  // must add it to the usual WebPreferences struct passed to the renderer.
+  //
+  // The empty string means to fall back to the pref for the Common script
+  // ("Zyyy").  For example, if chrome.fonts.serif.Cyrl is the empty string, it
+  // means to use chrome.fonts.serif.Zyyy for Cyrillic script. Prefs that are
+  // the empty string are normally not passed to WebKit, since there are so many
+  // of them that it would cause a performance regression. Not passing the pref
+  // is normally okay since WebKit does the desired fallback behavior regardless
+  // of whether the empty string is passed or the pref is not passed at all. But
+  // if the pref has changed from non-empty to the empty string, we must let
+  // WebKit know.
+  std::string generic_family;
+  std::string script;
+  if (pref_names_util::ParseFontNamePrefPath(pref_name,
+                                             &generic_family,
+                                             &script)) {
+    PrefService* prefs = GetProfile()->GetPrefs();
+    std::string pref_value = prefs->GetString(pref_name.c_str());
+    if (pref_value.empty()) {
+      WebPreferences web_prefs =
+          web_contents_->GetRenderViewHost()->GetWebkitPreferences();
+      OverrideFontFamily(&web_prefs, generic_family, script, "");
+      web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(web_prefs);
+      return;
+    }
+  }
+
+  UpdateWebPreferences();
+}