Watch the preferences for changes per profile instead of per tab.

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 <set>
 #include <string>
 
+#include "base/memory/singleton.h"
 #include "base/prefs/overlay_user_pref_store.h"
+#include "base/prefs/pref_change_registrar.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ui/zoom/chrome_zoom_level_prefs.h"
 #include "chrome/common/pref_font_webkit_names.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_names_util.h"
 #include "chrome/grit/locale_settings.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+#include "components/keyed_service/core/keyed_service.h"
 #include "components/pref_registry/pref_registry_syncable.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 "content/public/common/renderer_preferences.h"
 #include "content/public/common/web_preferences.h"
 #include "grit/platform_locale_settings.h"
 #include "third_party/icu/source/common/unicode/uchar.h"
 #include "third_party/icu/source/common/unicode/uscript.h"
@@ skipping 287 matching lines @@
     user_prefs::PrefRegistrySyncable::PrefSyncStatus status) {
   int val = 0;
   bool success = base::StringToInt(l10n_util::GetStringUTF8(
       default_message_id), &val);
   DCHECK(success);
   registry->RegisterIntegerPref(path, val, status);
 }
 
 }  // namespace
 
-PrefsTabHelper::PrefsTabHelper(WebContents* contents)
-    : web_contents_(contents),
-      weak_ptr_factory_(this) {
-  PrefService* prefs = GetProfile()->GetPrefs();
-  pref_change_registrar_.Init(prefs);
-  if (prefs) {
-    // If the tab is in an incognito profile, we track changes in the default
-    // zoom level of the parent profile instead.
-    Profile* profile_to_track = GetProfile()->GetOriginalProfile();
-    chrome::ChromeZoomLevelPrefs* zoom_level_prefs =
-        profile_to_track->GetZoomLevelPrefs();
+// Watching all these settings per tab is slow when a user has a lot of tabs and
+// and they use session restore. So watch them once per profile.
+// http://crbug.com/452693
+class PrefWatcher : public KeyedService {
+ public:
+  explicit PrefWatcher(Profile* profile) : profile_(profile) {
+    pref_change_registrar_.Init(profile_->GetPrefs());
 
     base::Closure renderer_callback = base::Bind(
-        &PrefsTabHelper::UpdateRendererPreferences, base::Unretained(this));
-    // Tests should not need to create a ZoomLevelPrefs.
-    if (zoom_level_prefs) {
-      default_zoom_level_subscription_ =
-          zoom_level_prefs->RegisterDefaultZoomLevelCallback(renderer_callback);
-    }
+        &PrefWatcher::UpdateRendererPreferences, base::Unretained(this));
     pref_change_registrar_.Add(prefs::kAcceptLanguages, renderer_callback);
     pref_change_registrar_.Add(prefs::kEnableDoNotTrack, renderer_callback);
     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));
+        &PrefWatcher::OnWebPrefChanged, base::Unretained(this));
     for (int i = 0; i < kPrefsToObserveLength; ++i) {
       const char* pref_name = kPrefsToObserve[i];
       pref_change_registrar_.Add(pref_name, webkit_callback);
     }
 
     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);
   }
 
+  static PrefWatcher* Get(Profile* profile);
+
+  void RegisterHelper(PrefsTabHelper* helper) {
+    helpers_.insert(helper);
+  }
+
+  void UnregisterHelper(PrefsTabHelper* helper) {
+    helpers_.erase(helper);
+  }
+
+ private:
+  // KeyedService overrides:
+  void Shutdown() override {
+    pref_change_registrar_.RemoveAll();
+  }
+
+  void UpdateRendererPreferences() {
+    for (const auto& helper : helpers_)
+      helper->UpdateRendererPreferences();
+  }
+
+  void OnWebPrefChanged(const std::string& pref_name) {
+    for (const auto& helper : helpers_)
+      helper->OnWebPrefChanged(pref_name);
+  }
+
+  Profile* profile_;
+  PrefChangeRegistrar pref_change_registrar_;
+  std::set<PrefsTabHelper*> helpers_;
+};
+
+class PrefWatcherFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  static PrefWatcher* GetForProfile(Profile* profile) {
+    return static_cast<PrefWatcher*>(
+        GetInstance()->GetServiceForBrowserContext(profile, true));
+  }
+
+  static PrefWatcherFactory* GetInstance() {
+    return Singleton<PrefWatcherFactory>::get();
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<PrefWatcherFactory>;
+
+  PrefWatcherFactory() : BrowserContextKeyedServiceFactory(
+      "PrefWatcher",
+      BrowserContextDependencyManager::GetInstance()) {
+  }
+
+  ~PrefWatcherFactory() override {}
+
+  // BrowserContextKeyedServiceFactory:
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* browser_context) const override {
+    return new PrefWatcher(Profile::FromBrowserContext(browser_context));
+  }
+
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override {
+    return chrome::GetBrowserContextOwnInstanceInIncognito(context);
+  }
+};
+
+// static
+PrefWatcher* PrefWatcher::Get(Profile* profile) {
+  return PrefWatcherFactory::GetForProfile(profile);
+}
+
+PrefsTabHelper::PrefsTabHelper(WebContents* contents)
+    : web_contents_(contents),
+      profile_(Profile::FromBrowserContext(web_contents_->GetBrowserContext())),
+      weak_ptr_factory_(this) {
+  PrefService* prefs = profile_->GetPrefs();
+  if (prefs) {
+    // If the tab is in an incognito profile, we track changes in the default
+    // zoom level of the parent profile instead.
+    Profile* profile_to_track = profile_->GetOriginalProfile();
+    chrome::ChromeZoomLevelPrefs* zoom_level_prefs =
+        profile_to_track->GetZoomLevelPrefs();
+
+    base::Closure renderer_callback = base::Bind(
+        &PrefsTabHelper::UpdateRendererPreferences, base::Unretained(this));
+    // Tests should not need to create a ZoomLevelPrefs.
+    if (zoom_level_prefs) {
+      default_zoom_level_subscription_ =
+          zoom_level_prefs->RegisterDefaultZoomLevelCallback(renderer_callback);
+    }
+
+    PrefWatcher::Get(profile_)->RegisterHelper(this);
+  }
+
   content::RendererPreferences* render_prefs =
       web_contents_->GetMutableRendererPrefs();
   renderer_preferences_util::UpdateFromSystemSettings(render_prefs,
-                                                      GetProfile(),
+                                                      profile_,
                                                       web_contents_);
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
   registrar_.Add(this,
                  chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  content::Source<ThemeService>(
-                     ThemeServiceFactory::GetForProfile(GetProfile())));
+                     ThemeServiceFactory::GetForProfile(profile_)));
 #endif
 #if defined(USE_AURA)
   registrar_.Add(this,
                  chrome::NOTIFICATION_BROWSER_FLING_CURVE_PARAMETERS_CHANGED,
                  content::NotificationService::AllSources());
 #endif
 }
 
 PrefsTabHelper::~PrefsTabHelper() {
+  PrefWatcher::Get(profile_)->UnregisterHelper(this);
 }
 
 // static
 void PrefsTabHelper::InitIncognitoUserPrefStore(
     OverlayUserPrefStore* pref_store) {
   // List of keys that cannot be changed in the user prefs file by the incognito
   // profile.  All preferences that store information about the browsing history
   // or behavior of the user should have this property.
   pref_store->RegisterOverlayPref(prefs::kBrowserWindowPlacement);
   pref_store->RegisterOverlayPref(prefs::kSaveFileDefaultDirectory);
@@ skipping 150 matching lines @@
   registry->RegisterStringPref(
       prefs::kStaticEncodings,
       l10n_util::GetStringUTF8(IDS_STATIC_ENCODING_LIST),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
       prefs::kRecentlySelectedEncoding,
       std::string(),
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
+// static
+void PrefsTabHelper::GetServiceInstance() {
+  PrefWatcherFactory::GetInstance();
+}
+
 void PrefsTabHelper::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
   if (type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED) {
     UpdateRendererPreferences();
     return;
   }
 #endif
 
 #if defined(USE_AURA)
   if (type == chrome::NOTIFICATION_BROWSER_FLING_CURVE_PARAMETERS_CHANGED) {
     UpdateRendererPreferences();
     return;
   }
 #endif  // defined(USE_AURA)
 
   NOTREACHED();
 }
 
 void PrefsTabHelper::UpdateWebPreferences() {
   web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(
       web_contents_->GetRenderViewHost()->GetWebkitPreferences());
 }
 
 void PrefsTabHelper::UpdateRendererPreferences() {
   content::RendererPreferences* prefs =
       web_contents_->GetMutableRendererPrefs();
   renderer_preferences_util::UpdateFromSystemSettings(
-      prefs, GetProfile(), web_contents_);
+      prefs, profile_, web_contents_);
   web_contents_->GetRenderViewHost()->SyncRendererPrefs();
 }
-
-Profile* PrefsTabHelper::GetProfile() {
-  return Profile::FromBrowserContext(web_contents_->GetBrowserContext());
-}
-
 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();
+    PrefService* prefs = profile_->GetPrefs();
     std::string pref_value = prefs->GetString(pref_name);
     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;
     }
   }
 }
 
 void PrefsTabHelper::OnWebPrefChanged(const std::string& pref_name) {
 #if !defined(OS_ANDROID)
   OnFontFamilyPrefChanged(pref_name);
 #endif
 
   web_contents_->GetRenderViewHost()->OnWebkitPreferencesChanged();
 }