Cache the current WebPreferences on RenderViewHostImpl.

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/prefs/pref_service.h"
@@ skipping 31 matching lines @@
 using content::WebContents;
 using content::WebPreferences;
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(PrefsTabHelper);
 
 namespace {
 
 // The list of prefs we want to observe.
 const char* kPrefsToObserve[] = {
   prefs::kDefaultCharset,
+  prefs::kDisable3DAPIs,
+  prefs::kEnableHyperlinkAuditing,
   prefs::kWebKitAllowDisplayingInsecureContent,
   prefs::kWebKitAllowRunningInsecureContent,
   prefs::kWebKitDefaultFixedFontSize,
   prefs::kWebKitDefaultFontSize,
+  prefs::kWebKitDomPasteEnabled,
 #if defined(OS_ANDROID)
   prefs::kWebKitFontScaleFactor,
   prefs::kWebKitForceEnableZoom,
   prefs::kWebKitPasswordEchoEnabled,
 #endif
+  prefs::kWebKitInspectorSettings,
+  prefs::kWebKitJavascriptCanOpenWindowsAutomatically,
   prefs::kWebKitJavascriptEnabled,
   prefs::kWebKitJavaEnabled,
   prefs::kWebKitLoadsImagesAutomatically,
   prefs::kWebKitMinimumFontSize,
   prefs::kWebKitMinimumLogicalFontSize,
   prefs::kWebKitPluginsEnabled,
+  prefs::kWebKitShrinksStandaloneImagesToFit,
   prefs::kWebkitTabsToLinks,
-  prefs::kWebKitUsesUniversalDetector
+  prefs::kWebKitTextAreasAreResizable,
+  prefs::kWebKitUsesUniversalDetector,
+  prefs::kWebKitWebSecurityEnabled,
 };
 
 const int kPrefsToObserveLength = arraysize(kPrefsToObserve);
 
 #if !defined(OS_ANDROID)
 // Registers a preference under the path |pref_name| for each script used for
 // per-script font prefs.
 // For example, for WEBKIT_WEBPREFS_FONTS_SERIF ("fonts.serif"):
 // "fonts.serif.Arab", "fonts.serif.Hang", etc. are registered.
 // |fonts_with_defaults| contains all |pref_names| already registered since they
@@ skipping 26 matching lines @@
     if (fonts_with_defaults.find(pref_name) == fonts_with_defaults.end()) {
       // We haven't already set a default value for this font preference, so set
       // an empty string as the default.
       registry->RegisterStringPref(
           pref_name,
           std::string(),
           user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
     }
   }
 }
+#endif  // !defined(OS_ANDROID)
 
 // Registers |obs| to observe per-script font prefs under the path |map_name|.
 // On android, there's no exposed way to change these prefs, so we can save
 // ~715KB of heap and some startup cycles by avoiding observing these prefs
 // since they will never change.
 void RegisterFontFamilyMapObserver(
     PrefChangeRegistrar* registrar,
     const char* map_name,
     const PrefChangeRegistrar::NamedChangeCallback& obs) {
   DCHECK(StartsWithASCII(map_name, "webkit.webprefs.", true));
   for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
     const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
     std::string pref_name = base::StringPrintf("%s.%s", map_name, script);
     registrar->Add(pref_name.c_str(), obs);
   }
 }
-#endif  // !defined(OS_ANDROID)
 
 #if defined(OS_WIN)
 // On Windows with antialising we want to use an alternate fixed font like
 // Consolas, which looks much better than Courier New.
 bool ShouldUseAlternateDefaultFixedFont(const std::string& script) {
   if (!StartsWithASCII(script, "courier", false))
     return false;
   UINT smooth_type = 0;
   SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &smooth_type, 0);
   return (base::win::GetVersion() >= base::win::VERSION_WIN7) &&
@@ skipping 177 matching lines @@
     pref_change_registrar_.Add(prefs::kEnableReferrers, renderer_callback);
 
 #if !defined(OS_MACOSX)
     pref_change_registrar_.Add(prefs::kFullscreenAllowed, renderer_callback);
 #endif
 
     PrefChangeRegistrar::NamedChangeCallback webkit_callback = base::Bind(
         &PrefsTabHelper::OnWebPrefChanged, base::Unretained(this));
     for (int i = 0; i < kPrefsToObserveLength; ++i) {
       const char* pref_name = kPrefsToObserve[i];
-      DCHECK(std::string(pref_name) == prefs::kDefaultCharset ||
-             StartsWithASCII(pref_name, "webkit.webprefs.", true));
       pref_change_registrar_.Add(pref_name, webkit_callback);
     }
 
-#if !defined(OS_ANDROID)
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitStandardFontFamilyMap,
                                   webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitFixedFontFamilyMap,
                                   webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitSerifFontFamilyMap,
                                   webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitSansSerifFontFamilyMap,
                                   webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitCursiveFontFamilyMap,
                                   webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitFantasyFontFamilyMap,
                                   webkit_callback);
     RegisterFontFamilyMapObserver(&pref_change_registrar_,
                                   prefs::kWebKitPictographFontFamilyMap,
                                   webkit_callback);
-#endif  // !defined(OS_ANDROID)
   }
 
   renderer_preferences_util::UpdateFromSystemSettings(
       web_contents_->GetMutableRendererPrefs(), GetProfile());
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
   registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  content::Source<ThemeService>(
                      ThemeServiceFactory::GetForProfile(GetProfile())));
 #endif
@@ skipping 202 matching lines @@
 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) {
+void PrefsTabHelper::OnFontFamilyPrefChanged(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, std::string());
       web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(web_prefs);
       return;
     }
   }
+}
 
-  UpdateWebPreferences();
+void PrefsTabHelper::OnWebPrefChanged(const std::string& pref_name) {
+#if !defined(OS_ANDROID)
+  OnFontFamilyPrefChanged(pref_name);
+#endif
+
+  web_contents_->GetRenderViewHost()->OnWebkitPreferencesChanged();
 }