Pass per-script fonts to WebKit settings.

chrome/browser/ui/tab_contents/tab_contents_wrapper.cc

Index: chrome/browser/ui/tab_contents/tab_contents_wrapper.cc
diff --git a/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc b/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc
index 438c02159ea10aeb831ee54b3e54deffdcf85c59..654799e19f548e83c95d8d8822bfdb77c7f65fc7 100644
--- a/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc
+++ b/chrome/browser/ui/tab_contents/tab_contents_wrapper.cc
@@ -28,6 +28,7 @@
 #include "chrome/browser/pdf_unsupported_feature.h"
 #include "chrome/browser/plugin_observer.h"
 #include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/prerender/prerender_observer.h"
 #include "chrome/browser/printing/print_preview_message_handler.h"
 #include "chrome/browser/profiles/profile.h"
@@ -278,6 +279,64 @@ void TabContentsWrapper::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterLocalizedStringPref(prefs::kWebKitFantasyFontFamily,
                                      IDS_FANTASY_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kWebKitStandardFontFamilyMap,
+                                PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kWebKitFixedFontFamilyMap,
+                                PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kWebKitSerifFontFamilyMap,
+                                PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kWebKitSansSerifFontFamilyMap,
+                                PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kWebKitCursiveFontFamilyMap,
+                                PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterDictionaryPref(prefs::kWebKitFantasyFontFamilyMap,
+                                PrefService::UNSYNCABLE_PREF);
+
+  DictionaryPrefUpdate update_standard(prefs,
+                                       prefs::kWebKitStandardFontFamilyMap);
+  DictionaryPrefUpdate update_fixed(prefs,
+                                    prefs::kWebKitFixedFontFamilyMap);
+  DictionaryPrefUpdate update_serif(prefs,
+                                    prefs::kWebKitSerifFontFamilyMap);
+  DictionaryPrefUpdate update_sans_serif(prefs,
+                                         prefs::kWebKitSansSerifFontFamilyMap);
+
+#if defined(OS_CHROMEOS)
+  update_standard->SetString(uscript_getShortName(USCRIPT_KATAKANA_OR_HIRAGANA),
+      l10n_util::GetStringUTF16(IDS_STANDARD_FONT_FAMILY_JAPANESE));

[falken, 2011/08/10 13:06:53]

This seems flawed because it overrides the user's preferences, when I just want
to set a default value.  Is it possible to set a default value within a
Dictionary?

[tony, 2011/08/10 19:23:40]

Can we just make pref values for each string in the dictionaries?  E.g.,
webkit.webprefs.standard_font_family_map.katakana_or_hiragana

Also, it might be good to hardcode the script names rather than using
uscript_getShortName.  If that method hits disk, it might slow down startup.

[falken, 2011/08/11 08:54:20]

This would be good, but if I register
"webkit.webprefs.standard_font_family_map.katakana_or_hiragana" and later call
GetDictionary("webkit.webprefs.standard_font_family_map"), the pref doesn't
appear in the returned value.

It seems like DictionaryPrefUpdate is the proper way to update values within a
dictionary, but I don't see how to set defaults for them.

Am I missing something about the pref service?

Otherwise, perhaps a solution is to register prefs for the things we have a
default for, and when getting the dictionary, check if each registered pref is
in the dictionary, and if not, retrieve the pref itself.

Perhaps another option is to not use a dictionary and just have pref values for
each possible entry.  But it seems ugly since there are over 100 scripts (though
we can perhaps limit them to commonly used ones) and 6 generic font families.

[Mattias Nissler (ping if slow), 2011/08/12 09:24:13]

That's by design. The PrefService is a key-value store and there's no way to
register a pref that accesses a path in a different dictionary pref.
What you can do is just call the 3-parameter version of RegisterDictionaryPref()
and pass a DictionaryValue* as the default you want to set.
I strongly advise against this. The PrefService nowadays has a stack of sources
(aka PrefStores) for prefs, and the default values should be handled by the
least-priority PrefStore. The RegisterXYZPref() calls take care of putting the
default in place.

[falken, 2011/08/12 09:37:00]

I see.  What happens if the user preferences have a dictionary like: { "a": "1"
}
and the registered default is { "a": "2", "b": "3" }

Is only the "a" key overridden and the "b" key is as set in the default?  Or is
the entire default overridden so "b" does not exist?

I could test myself but I wonder if there is an intended behavior.

[Mattias Nissler (ping if slow), 2011/08/12 09:51:05]

Values from lower-priority sources are hidden by higher-priority sources, there
is no merging implemented at the moment (although in some other contexts we have
thought about doing it already). So if you write a user setting through
PrefService::Set() or DictionaryPrefUpdate, it will hide the whole defaults
dictionary and you'll not see the default values any longer in Get() calls.

I take it you'd like to have merging behavior? The reason why we haven't
implemented it yet is mainly that there's no generic way to do it, i.e.
different consumers will probably require different merging behavior.

[falken, 2011/08/15 05:28:46]

Thanks, I see.  I thought merging would be useful here in case the user sets the
font for one script, so:

user dictionary is: { "Hang" : "MyKoreanFont" }
default dictionary is: { "Hang" : "DefaultKoreanFont", "Hrkt" :
"DefaultJapaneseFont", ... }

Then later we might change the default dictionary, e.g., to add new scripts or
change default fonts.  But without merging behavior it seems like the new
defaults would not have effect.

But I see what you mean about strongly advising against handling defaults
manually.

Perhaps it is better to do the other idea of using fixed strings instead of a
dictionary.  The number of possible entries is (num of scripts) * (num of font
families).  ICU's uscript.h has about 150 scripts and there are currently 6 font
families, so 900 entries.  But probably supporting about 30 scripts is enough (I
notice the Firefox Preferences UI exposes about 30 "language groups"), which
would make it 180 entries.

+  update_fixed->SetString(uscript_getShortName(USCRIPT_KATAKANA_OR_HIRAGANA),
+      l10n_util::GetStringUTF16(IDS_FIXED_FONT_FAMILY_JAPANESE));
+  update_serif->SetString(uscript_getShortName(USCRIPT_KATAKANA_OR_HIRAGANA),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_JAPANESE));
+  update_sans_serif->SetString(
+      uscript_getShortName(USCRIPT_KATAKANA_OR_HIRAGANA),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_JAPANESE));
+  update_standard->SetString(uscript_getShortName(USCRIPT_HANGUL),
+      l10n_util::GetStringUTF16(IDS_STANDARD_FONT_FAMILY_KOREAN));
+  update_fixed->SetString(uscript_getShortName(USCRIPT_HANGUL),
+      l10n_util::GetStringUTF16(IDS_FIXED_FONT_FAMILY_KOREAN));
+  update_serif->SetString(uscript_getShortName(USCRIPT_HANGUL),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_KOREAN));
+  update_sans_serif->SetString(uscript_getShortName(USCRIPT_HANGUL),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_KOREAN));
+  update_standard->SetString(uscript_getShortName(USCRIPT_SIMPLIFIED_HAN),
+      l10n_util::GetStringUTF16(IDS_STANDARD_FONT_FAMILY_SIMPLIFIED_HAN));
+  update_fixed->SetString(uscript_getShortName(USCRIPT_SIMPLIFIED_HAN),
+      l10n_util::GetStringUTF16(IDS_FIXED_FONT_FAMILY_SIMPLIFIED_HAN));
+  update_serif->SetString(uscript_getShortName(USCRIPT_SIMPLIFIED_HAN),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN));
+  update_sans_serif->SetString(uscript_getShortName(USCRIPT_SIMPLIFIED_HAN),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN));
+  update_standard->SetString(uscript_getShortName(USCRIPT_TRADITIONAL_HAN),
+      l10n_util::GetStringUTF16(IDS_STANDARD_FONT_FAMILY_TRADITIONAL_HAN));
+  update_fixed->SetString(uscript_getShortName(USCRIPT_TRADITIONAL_HAN),
+      l10n_util::GetStringUTF16(IDS_FIXED_FONT_FAMILY_TRADITIONAL_HAN));
+  update_serif->SetString(uscript_getShortName(USCRIPT_TRADITIONAL_HAN),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_TRADITIONAL_HAN));
+  update_sans_serif->SetString(uscript_getShortName(USCRIPT_TRADITIONAL_HAN),
+      l10n_util::GetStringUTF16(IDS_SERIF_FONT_FAMILY_TRADITIONAL_HAN));
+#endif
+
   prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
                                       IDS_DEFAULT_FONT_SIZE,
                                       PrefService::UNSYNCABLE_PREF);