1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/prefs/prefs_tab_helper.h" 6 7 #include <string> 8 9 #include "base/prefs/overlay_user_pref_store.h" 10 #include "base/prefs/pref_service.h" 11 #include "base/strings/string_util.h" 12 #include "base/strings/stringprintf.h" 13 #include "base/strings/utf_string_conversions.h" 14 #include "chrome/browser/browser_process.h" 15 #include "chrome/browser/chrome_notification_types.h" 16 #include "chrome/browser/profiles/profile.h" 17 #include "chrome/browser/renderer_preferences_util.h" 18 #include "chrome/common/pref_font_webkit_names.h" 19 #include "chrome/common/pref_names.h" 20 #include "chrome/common/pref_names_util.h" 21 #include "components/user_prefs/pref_registry_syncable.h" 22 #include "content/public/browser/notification_details.h" 23 #include "content/public/browser/notification_service.h" 24 #include "content/public/browser/render_view_host.h" 25 #include "content/public/browser/web_contents.h" 26 #include "grit/locale_settings.h" 27 #include "grit/platform_locale_settings.h" 28 #include "third_party/icu/source/common/unicode/uchar.h" 29 #include "third_party/icu/source/common/unicode/uscript.h" 30 #include "webkit/common/webpreferences.h" 31 32 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES) 33 #include "chrome/browser/themes/theme_service.h" 34 #include "chrome/browser/themes/theme_service_factory.h" 35 #endif 36 37 using content::WebContents; 38 39 DEFINE_WEB_CONTENTS_USER_DATA_KEY(PrefsTabHelper); 40 41 namespace { 42 43 // The list of prefs we want to observe. 44 const char* kPrefsToObserve[] = { 45 prefs::kDefaultCharset, 46 prefs::kWebKitAllowDisplayingInsecureContent, 47 prefs::kWebKitAllowRunningInsecureContent, 48 prefs::kWebKitDefaultFixedFontSize, 49 prefs::kWebKitDefaultFontSize, 50 #if defined(OS_ANDROID) 51 prefs::kWebKitFontScaleFactor, 52 prefs::kWebKitForceEnableZoom, 53 prefs::kWebKitPasswordEchoEnabled, 54 #endif 55 prefs::kWebKitJavascriptEnabled, 56 prefs::kWebKitJavaEnabled, 57 prefs::kWebKitLoadsImagesAutomatically, 58 prefs::kWebKitMinimumFontSize, 59 prefs::kWebKitMinimumLogicalFontSize, 60 prefs::kWebKitPluginsEnabled, 61 prefs::kWebkitTabsToLinks, 62 prefs::kWebKitUsesUniversalDetector 63 }; 64 65 const int kPrefsToObserveLength = arraysize(kPrefsToObserve); 66 67 #if !defined(OS_ANDROID) 68 // Registers a preference under the path |pref_name| for each script used for 69 // per-script font prefs. 70 // For example, for WEBKIT_WEBPREFS_FONTS_SERIF ("fonts.serif"): 71 // "fonts.serif.Arab", "fonts.serif.Hang", etc. are registered. 72 // |fonts_with_defaults| contains all |pref_names| already registered since they 73 // have a specified default value. 74 // On Android there are no default values for these properties and there is no 75 // way to set them (because extensions are not supported so the Font Settings 76 // API cannot be used), so we can avoid registering them altogether. 77 void RegisterFontFamilyPrefs(user_prefs::PrefRegistrySyncable* registry, 78 const std::set<std::string>& fonts_with_defaults) { 79 80 // Expand the font concatenated with script name so this stays at RO memory 81 // rather than allocated in heap. 82 static const char* const kFontFamilyMap[] = { 83 #define EXPAND_SCRIPT_FONT(map_name, script_name) map_name "." script_name, 84 85 #include "chrome/common/pref_font_script_names-inl.h" 86 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_CURSIVE) 87 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_FANTASY) 88 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_FIXED) 89 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_PICTOGRAPH) 90 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_SANSERIF) 91 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_SERIF) 92 ALL_FONT_SCRIPTS(WEBKIT_WEBPREFS_FONTS_STANDARD) 93 94 #undef EXPAND_SCRIPT_FONT 95 }; 96 97 for (size_t i = 0; i < arraysize(kFontFamilyMap); ++i) { 98 const char* pref_name = kFontFamilyMap[i]; 99 if (fonts_with_defaults.find(pref_name) == fonts_with_defaults.end()) { 100 // We haven't already set a default value for this font preference, so set 101 // an empty string as the default. 102 registry->RegisterStringPref( 103 pref_name, 104 std::string(), 105 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 106 } 107 } 108 } 109 110 // Registers |obs| to observe per-script font prefs under the path |map_name|. 111 // On android, there's no exposed way to change these prefs, so we can save 112 // ~715KB of heap and some startup cycles by avoiding observing these prefs 113 // since they will never change. 114 void RegisterFontFamilyMapObserver( 115 PrefChangeRegistrar* registrar, 116 const char* map_name, 117 const PrefChangeRegistrar::NamedChangeCallback& obs) { 118 DCHECK(StartsWithASCII(map_name, "webkit.webprefs.", true)); 119 for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) { 120 const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i]; 121 std::string pref_name = base::StringPrintf("%s.%s", map_name, script); 122 registrar->Add(pref_name.c_str(), obs); 123 } 124 } 125 #endif // !defined(OS_ANDROID) 126 127 struct FontDefault { 128 const char* pref_name; 129 int resource_id; 130 }; 131 132 // Font pref defaults. The prefs that have defaults vary by platform, since not 133 // all platforms have fonts for all scripts for all generic families. 134 // TODO(falken): add proper defaults when possible for all 135 // platforms/scripts/generic families. 136 const FontDefault kFontDefaults[] = { 137 { prefs::kWebKitStandardFontFamily, IDS_STANDARD_FONT_FAMILY }, 138 { prefs::kWebKitFixedFontFamily, IDS_FIXED_FONT_FAMILY }, 139 { prefs::kWebKitSerifFontFamily, IDS_SERIF_FONT_FAMILY }, 140 { prefs::kWebKitSansSerifFontFamily, IDS_SANS_SERIF_FONT_FAMILY }, 141 { prefs::kWebKitCursiveFontFamily, IDS_CURSIVE_FONT_FAMILY }, 142 { prefs::kWebKitFantasyFontFamily, IDS_FANTASY_FONT_FAMILY }, 143 { prefs::kWebKitPictographFontFamily, IDS_PICTOGRAPH_FONT_FAMILY }, 144 #if defined(OS_CHROMEOS) || defined(OS_MACOSX) || defined(OS_WIN) 145 { prefs::kWebKitStandardFontFamilyJapanese, 146 IDS_STANDARD_FONT_FAMILY_JAPANESE }, 147 { prefs::kWebKitFixedFontFamilyJapanese, IDS_FIXED_FONT_FAMILY_JAPANESE }, 148 { prefs::kWebKitSerifFontFamilyJapanese, IDS_SERIF_FONT_FAMILY_JAPANESE }, 149 { prefs::kWebKitSansSerifFontFamilyJapanese, 150 IDS_SANS_SERIF_FONT_FAMILY_JAPANESE }, 151 { prefs::kWebKitStandardFontFamilyKorean, IDS_STANDARD_FONT_FAMILY_KOREAN }, 152 { prefs::kWebKitSerifFontFamilyKorean, IDS_SERIF_FONT_FAMILY_KOREAN }, 153 { prefs::kWebKitSansSerifFontFamilyKorean, 154 IDS_SANS_SERIF_FONT_FAMILY_KOREAN }, 155 { prefs::kWebKitStandardFontFamilySimplifiedHan, 156 IDS_STANDARD_FONT_FAMILY_SIMPLIFIED_HAN }, 157 { prefs::kWebKitSerifFontFamilySimplifiedHan, 158 IDS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN }, 159 { prefs::kWebKitSansSerifFontFamilySimplifiedHan, 160 IDS_SANS_SERIF_FONT_FAMILY_SIMPLIFIED_HAN }, 161 { prefs::kWebKitStandardFontFamilyTraditionalHan, 162 IDS_STANDARD_FONT_FAMILY_TRADITIONAL_HAN }, 163 { prefs::kWebKitSerifFontFamilyTraditionalHan, 164 IDS_SERIF_FONT_FAMILY_TRADITIONAL_HAN }, 165 { prefs::kWebKitSansSerifFontFamilyTraditionalHan, 166 IDS_SANS_SERIF_FONT_FAMILY_TRADITIONAL_HAN }, 167 #endif 168 #if defined(OS_CHROMEOS) 169 { prefs::kWebKitStandardFontFamilyArabic, IDS_STANDARD_FONT_FAMILY_ARABIC }, 170 { prefs::kWebKitSerifFontFamilyArabic, IDS_SERIF_FONT_FAMILY_ARABIC }, 171 { prefs::kWebKitSansSerifFontFamilyArabic, 172 IDS_SANS_SERIF_FONT_FAMILY_ARABIC }, 173 { prefs::kWebKitFixedFontFamilyKorean, IDS_FIXED_FONT_FAMILY_KOREAN }, 174 { prefs::kWebKitFixedFontFamilySimplifiedHan, 175 IDS_FIXED_FONT_FAMILY_SIMPLIFIED_HAN }, 176 { prefs::kWebKitFixedFontFamilyTraditionalHan, 177 IDS_FIXED_FONT_FAMILY_TRADITIONAL_HAN }, 178 #elif defined(OS_WIN) 179 { prefs::kWebKitStandardFontFamilyCyrillic, 180 IDS_STANDARD_FONT_FAMILY_CYRILLIC }, 181 { prefs::kWebKitFixedFontFamilyCyrillic, IDS_FIXED_FONT_FAMILY_CYRILLIC }, 182 { prefs::kWebKitSerifFontFamilyCyrillic, IDS_SERIF_FONT_FAMILY_CYRILLIC }, 183 { prefs::kWebKitSansSerifFontFamilyCyrillic, 184 IDS_SANS_SERIF_FONT_FAMILY_CYRILLIC }, 185 { prefs::kWebKitStandardFontFamilyGreek, IDS_STANDARD_FONT_FAMILY_GREEK }, 186 { prefs::kWebKitFixedFontFamilyGreek, IDS_FIXED_FONT_FAMILY_GREEK }, 187 { prefs::kWebKitSerifFontFamilyGreek, IDS_SERIF_FONT_FAMILY_GREEK }, 188 { prefs::kWebKitSansSerifFontFamilyGreek, IDS_SANS_SERIF_FONT_FAMILY_GREEK }, 189 { prefs::kWebKitFixedFontFamilyKorean, IDS_FIXED_FONT_FAMILY_KOREAN }, 190 { prefs::kWebKitCursiveFontFamilyKorean, IDS_CURSIVE_FONT_FAMILY_KOREAN }, 191 { prefs::kWebKitFixedFontFamilySimplifiedHan, 192 IDS_FIXED_FONT_FAMILY_SIMPLIFIED_HAN }, 193 { prefs::kWebKitFixedFontFamilyTraditionalHan, 194 IDS_FIXED_FONT_FAMILY_TRADITIONAL_HAN }, 195 #endif 196 }; 197 198 const size_t kFontDefaultsLength = arraysize(kFontDefaults); 199 200 // Returns the script of the font pref |pref_name|. For example, suppose 201 // |pref_name| is "webkit.webprefs.fonts.serif.Hant". Since the script code for 202 // the script name "Hant" is USCRIPT_TRADITIONAL_HAN, the function returns 203 // USCRIPT_TRADITIONAL_HAN. |pref_name| must be a valid font pref name. 204 UScriptCode GetScriptOfFontPref(const char* pref_name) { 205 // ICU script names are four letters. 206 static const size_t kScriptNameLength = 4; 207 208 size_t len = strlen(pref_name); 209 DCHECK_GT(len, kScriptNameLength); 210 const char* scriptName = &pref_name[len - kScriptNameLength]; 211 int32 code = u_getPropertyValueEnum(UCHAR_SCRIPT, scriptName); 212 DCHECK(code >= 0 && code < USCRIPT_CODE_LIMIT); 213 return static_cast<UScriptCode>(code); 214 } 215 216 // If |scriptCode| is a member of a family of "similar" script codes, returns 217 // the script code in that family that is used in font pref names. For example, 218 // USCRIPT_HANGUL and USCRIPT_KOREAN are considered equivalent for the purposes 219 // of font selection. Chrome uses the script code USCRIPT_HANGUL (script name 220 // "Hang") in Korean font pref names (for example, 221 // "webkit.webprefs.fonts.serif.Hang"). So, if |scriptCode| is USCRIPT_KOREAN, 222 // the function returns USCRIPT_HANGUL. If |scriptCode| is not a member of such 223 // a family, returns |scriptCode|. 224 UScriptCode GetScriptForFontPrefMatching(UScriptCode scriptCode) { 225 switch (scriptCode) { 226 case USCRIPT_HIRAGANA: 227 case USCRIPT_KATAKANA: 228 case USCRIPT_KATAKANA_OR_HIRAGANA: 229 return USCRIPT_JAPANESE; 230 case USCRIPT_KOREAN: 231 return USCRIPT_HANGUL; 232 default: 233 return scriptCode; 234 } 235 } 236 237 // Returns the primary script used by the browser's UI locale. For example, if 238 // the locale is "ru", the function returns USCRIPT_CYRILLIC, and if the locale 239 // is "en", the function returns USCRIPT_LATIN. 240 UScriptCode GetScriptOfBrowserLocale() { 241 std::string locale = g_browser_process->GetApplicationLocale(); 242 243 // For Chinese locales, uscript_getCode() just returns USCRIPT_HAN but our 244 // per-script fonts are for USCRIPT_SIMPLIFIED_HAN and 245 // USCRIPT_TRADITIONAL_HAN. 246 if (locale == "zh-CN") 247 return USCRIPT_SIMPLIFIED_HAN; 248 if (locale == "zh-TW") 249 return USCRIPT_TRADITIONAL_HAN; 250 251 UScriptCode code = USCRIPT_INVALID_CODE; 252 UErrorCode err = U_ZERO_ERROR; 253 uscript_getCode(locale.c_str(), &code, 1, &err); 254 255 // Ignore the error that multiple scripts could be returned, since we only 256 // want one script. 257 if (U_FAILURE(err) && err != U_BUFFER_OVERFLOW_ERROR) 258 code = USCRIPT_INVALID_CODE; 259 return GetScriptForFontPrefMatching(code); 260 } 261 262 // Sets a font family pref in |prefs| to |pref_value|. 263 void OverrideFontFamily(WebPreferences* prefs, 264 const std::string& generic_family, 265 const std::string& script, 266 const std::string& pref_value) { 267 webkit_glue::ScriptFontFamilyMap* map = NULL; 268 if (generic_family == "standard") 269 map = &prefs->standard_font_family_map; 270 else if (generic_family == "fixed") 271 map = &prefs->fixed_font_family_map; 272 else if (generic_family == "serif") 273 map = &prefs->serif_font_family_map; 274 else if (generic_family == "sansserif") 275 map = &prefs->sans_serif_font_family_map; 276 else if (generic_family == "cursive") 277 map = &prefs->cursive_font_family_map; 278 else if (generic_family == "fantasy") 279 map = &prefs->fantasy_font_family_map; 280 else if (generic_family == "pictograph") 281 map = &prefs->pictograph_font_family_map; 282 else 283 NOTREACHED() << "Unknown generic font family: " << generic_family; 284 (*map)[script] = UTF8ToUTF16(pref_value); 285 } 286 287 } // namespace 288 289 PrefsTabHelper::PrefsTabHelper(WebContents* contents) 290 : web_contents_(contents), 291 weak_ptr_factory_(this) { 292 PrefService* prefs = GetProfile()->GetPrefs(); 293 pref_change_registrar_.Init(prefs); 294 if (prefs) { 295 base::Closure renderer_callback = base::Bind( 296 &PrefsTabHelper::UpdateRendererPreferences, base::Unretained(this)); 297 pref_change_registrar_.Add(prefs::kAcceptLanguages, renderer_callback); 298 pref_change_registrar_.Add(prefs::kDefaultZoomLevel, renderer_callback); 299 pref_change_registrar_.Add(prefs::kEnableDoNotTrack, renderer_callback); 300 pref_change_registrar_.Add(prefs::kEnableReferrers, renderer_callback); 301 302 #if !defined(OS_MACOSX) 303 pref_change_registrar_.Add(prefs::kFullscreenAllowed, renderer_callback); 304 #endif 305 306 PrefChangeRegistrar::NamedChangeCallback webkit_callback = base::Bind( 307 &PrefsTabHelper::OnWebPrefChanged, base::Unretained(this)); 308 for (int i = 0; i < kPrefsToObserveLength; ++i) { 309 const char* pref_name = kPrefsToObserve[i]; 310 DCHECK(std::string(pref_name) == prefs::kDefaultCharset || 311 StartsWithASCII(pref_name, "webkit.webprefs.", true)); 312 pref_change_registrar_.Add(pref_name, webkit_callback); 313 } 314 315 #if !defined(OS_ANDROID) 316 RegisterFontFamilyMapObserver(&pref_change_registrar_, 317 prefs::kWebKitStandardFontFamilyMap, 318 webkit_callback); 319 RegisterFontFamilyMapObserver(&pref_change_registrar_, 320 prefs::kWebKitFixedFontFamilyMap, 321 webkit_callback); 322 RegisterFontFamilyMapObserver(&pref_change_registrar_, 323 prefs::kWebKitSerifFontFamilyMap, 324 webkit_callback); 325 RegisterFontFamilyMapObserver(&pref_change_registrar_, 326 prefs::kWebKitSansSerifFontFamilyMap, 327 webkit_callback); 328 RegisterFontFamilyMapObserver(&pref_change_registrar_, 329 prefs::kWebKitCursiveFontFamilyMap, 330 webkit_callback); 331 RegisterFontFamilyMapObserver(&pref_change_registrar_, 332 prefs::kWebKitFantasyFontFamilyMap, 333 webkit_callback); 334 RegisterFontFamilyMapObserver(&pref_change_registrar_, 335 prefs::kWebKitPictographFontFamilyMap, 336 webkit_callback); 337 #endif // !defined(OS_ANDROID) 338 } 339 340 renderer_preferences_util::UpdateFromSystemSettings( 341 web_contents_->GetMutableRendererPrefs(), GetProfile()); 342 343 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES) 344 registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED, 345 content::Source<ThemeService>( 346 ThemeServiceFactory::GetForProfile(GetProfile()))); 347 #endif 348 #if defined(USE_AURA) 349 registrar_.Add(this, 350 chrome::NOTIFICATION_BROWSER_FLING_CURVE_PARAMETERS_CHANGED, 351 content::NotificationService::AllSources()); 352 #endif 353 } 354 355 PrefsTabHelper::~PrefsTabHelper() { 356 } 357 358 // static 359 void PrefsTabHelper::InitIncognitoUserPrefStore( 360 OverlayUserPrefStore* pref_store) { 361 // List of keys that cannot be changed in the user prefs file by the incognito 362 // profile. All preferences that store information about the browsing history 363 // or behavior of the user should have this property. 364 pref_store->RegisterOverlayPref(prefs::kBrowserWindowPlacement); 365 pref_store->RegisterOverlayPref(prefs::kSaveFileDefaultDirectory); 366 #if defined(OS_ANDROID) || defined(OS_IOS) 367 pref_store->RegisterOverlayPref(prefs::kProxy); 368 #endif // defined(OS_ANDROID) || defined(OS_IOS) 369 } 370 371 // static 372 void PrefsTabHelper::RegisterProfilePrefs( 373 user_prefs::PrefRegistrySyncable* registry) { 374 WebPreferences pref_defaults; 375 registry->RegisterBooleanPref( 376 prefs::kWebKitJavascriptEnabled, 377 pref_defaults.javascript_enabled, 378 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 379 registry->RegisterBooleanPref( 380 prefs::kWebKitWebSecurityEnabled, 381 pref_defaults.web_security_enabled, 382 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 383 registry->RegisterBooleanPref( 384 prefs::kWebKitJavascriptCanOpenWindowsAutomatically, 385 true, 386 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 387 registry->RegisterBooleanPref( 388 prefs::kWebKitLoadsImagesAutomatically, 389 pref_defaults.loads_images_automatically, 390 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 391 registry->RegisterBooleanPref( 392 prefs::kWebKitPluginsEnabled, 393 pref_defaults.plugins_enabled, 394 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 395 registry->RegisterBooleanPref( 396 prefs::kWebKitDomPasteEnabled, 397 pref_defaults.dom_paste_enabled, 398 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 399 registry->RegisterBooleanPref( 400 prefs::kWebKitShrinksStandaloneImagesToFit, 401 pref_defaults.shrinks_standalone_images_to_fit, 402 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 403 registry->RegisterDictionaryPref( 404 prefs::kWebKitInspectorSettings, 405 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 406 registry->RegisterBooleanPref( 407 prefs::kWebKitTextAreasAreResizable, 408 pref_defaults.text_areas_are_resizable, 409 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 410 registry->RegisterBooleanPref( 411 prefs::kWebKitJavaEnabled, 412 pref_defaults.java_enabled, 413 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 414 registry->RegisterBooleanPref( 415 prefs::kWebkitTabsToLinks, 416 pref_defaults.tabs_to_links, 417 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 418 registry->RegisterBooleanPref( 419 prefs::kWebKitAllowRunningInsecureContent, 420 false, 421 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 422 registry->RegisterBooleanPref( 423 prefs::kWebKitAllowDisplayingInsecureContent, 424 true, 425 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 426 registry->RegisterBooleanPref( 427 prefs::kEnableReferrers, 428 true, 429 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 430 #if defined(OS_ANDROID) 431 registry->RegisterDoublePref( 432 prefs::kWebKitFontScaleFactor, 433 1.0, 434 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 435 registry->RegisterBooleanPref( 436 prefs::kWebKitForceEnableZoom, 437 pref_defaults.force_enable_zoom, 438 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 439 registry->RegisterBooleanPref( 440 prefs::kWebKitPasswordEchoEnabled, 441 pref_defaults.password_echo_enabled, 442 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 443 #endif 444 registry->RegisterLocalizedStringPref( 445 prefs::kAcceptLanguages, 446 IDS_ACCEPT_LANGUAGES, 447 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); 448 registry->RegisterLocalizedStringPref( 449 prefs::kDefaultCharset, 450 IDS_DEFAULT_ENCODING, 451 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); 452 453 // Register font prefs that have defaults. 454 std::set<std::string> fonts_with_defaults; 455 UScriptCode browser_script = GetScriptOfBrowserLocale(); 456 for (size_t i = 0; i < kFontDefaultsLength; ++i) { 457 const FontDefault& pref = kFontDefaults[i]; 458 UScriptCode pref_script = GetScriptOfFontPref(pref.pref_name); 459 460 // Suppress this default font pref value if it is for the primary script of 461 // the browser's UI locale. For example, if the pref is for the sans-serif 462 // font for the Cyrillic script, and the browser locale is "ru" (Russian), 463 // the default is suppressed. Otherwise, the default would override the 464 // user's font preferences when viewing pages in their native language. 465 // This is because users have no way yet of customizing their per-script 466 // font preferences. The font prefs accessible in the options UI are for 467 // the default, unknown script; these prefs have less priority than the 468 // per-script font prefs when the script of the content is known. This code 469 // can possibly be removed later if users can easily access per-script font 470 // prefs (e.g., via the extensions workflow), or the problem turns out to 471 // not be really critical after all. 472 if (browser_script != pref_script) { 473 registry->RegisterLocalizedStringPref( 474 pref.pref_name, 475 pref.resource_id, 476 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 477 fonts_with_defaults.insert(pref.pref_name); 478 } 479 } 480 481 // Register per-script font prefs that don't have defaults. 482 #if !defined(OS_ANDROID) 483 RegisterFontFamilyPrefs(registry, fonts_with_defaults); 484 #endif 485 486 registry->RegisterLocalizedIntegerPref( 487 prefs::kWebKitDefaultFontSize, 488 IDS_DEFAULT_FONT_SIZE, 489 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 490 registry->RegisterLocalizedIntegerPref( 491 prefs::kWebKitDefaultFixedFontSize, 492 IDS_DEFAULT_FIXED_FONT_SIZE, 493 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 494 registry->RegisterLocalizedIntegerPref( 495 prefs::kWebKitMinimumFontSize, 496 IDS_MINIMUM_FONT_SIZE, 497 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 498 registry->RegisterLocalizedIntegerPref( 499 prefs::kWebKitMinimumLogicalFontSize, 500 IDS_MINIMUM_LOGICAL_FONT_SIZE, 501 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 502 registry->RegisterLocalizedBooleanPref( 503 prefs::kWebKitUsesUniversalDetector, 504 IDS_USES_UNIVERSAL_DETECTOR, 505 user_prefs::PrefRegistrySyncable::SYNCABLE_PREF); 506 registry->RegisterLocalizedStringPref( 507 prefs::kStaticEncodings, 508 IDS_STATIC_ENCODING_LIST, 509 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 510 registry->RegisterStringPref( 511 prefs::kRecentlySelectedEncoding, 512 std::string(), 513 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 514 } 515 516 void PrefsTabHelper::Observe(int type, 517 const content::NotificationSource& source, 518 const content::NotificationDetails& details) { 519 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES) 520 if (type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED) { 521 UpdateRendererPreferences(); 522 return; 523 } 524 #endif 525 526 #if defined(USE_AURA) 527 if (type == chrome::NOTIFICATION_BROWSER_FLING_CURVE_PARAMETERS_CHANGED) { 528 UpdateRendererPreferences(); 529 return; 530 } 531 #endif // defined(USE_AURA) 532 533 NOTREACHED(); 534 } 535 536 void PrefsTabHelper::UpdateWebPreferences() { 537 web_contents_->GetRenderViewHost()->UpdateWebkitPreferences( 538 web_contents_->GetRenderViewHost()->GetWebkitPreferences()); 539 } 540 541 void PrefsTabHelper::UpdateRendererPreferences() { 542 renderer_preferences_util::UpdateFromSystemSettings( 543 web_contents_->GetMutableRendererPrefs(), GetProfile()); 544 web_contents_->GetRenderViewHost()->SyncRendererPrefs(); 545 } 546 547 Profile* PrefsTabHelper::GetProfile() { 548 return Profile::FromBrowserContext(web_contents_->GetBrowserContext()); 549 } 550 551 void PrefsTabHelper::OnWebPrefChanged(const std::string& pref_name) { 552 // When a font family pref's value goes from non-empty to the empty string, we 553 // must add it to the usual WebPreferences struct passed to the renderer. 554 // 555 // The empty string means to fall back to the pref for the Common script 556 // ("Zyyy"). For example, if chrome.fonts.serif.Cyrl is the empty string, it 557 // means to use chrome.fonts.serif.Zyyy for Cyrillic script. Prefs that are 558 // the empty string are normally not passed to WebKit, since there are so many 559 // of them that it would cause a performance regression. Not passing the pref 560 // is normally okay since WebKit does the desired fallback behavior regardless 561 // of whether the empty string is passed or the pref is not passed at all. But 562 // if the pref has changed from non-empty to the empty string, we must let 563 // WebKit know. 564 std::string generic_family; 565 std::string script; 566 if (pref_names_util::ParseFontNamePrefPath(pref_name, 567 &generic_family, 568 &script)) { 569 PrefService* prefs = GetProfile()->GetPrefs(); 570 std::string pref_value = prefs->GetString(pref_name.c_str()); 571 if (pref_value.empty()) { 572 WebPreferences web_prefs = 573 web_contents_->GetRenderViewHost()->GetWebkitPreferences(); 574 OverrideFontFamily(&web_prefs, generic_family, script, std::string()); 575 web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(web_prefs); 576 return; 577 } 578 } 579 580 UpdateWebPreferences(); 581 } 582
