Introduce PrefRegistrySyncable, simplifying PrefServiceSyncable.

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_registry_syncable.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 "third_party/icu/public/common/unicode/uchar.h"
 #include "third_party/icu/public/common/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.
-void RegisterPrefsToMigrate(PrefServiceSyncable* prefs) {
+void RegisterPrefsToMigrate(PrefRegistrySyncable* prefs) {
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldStandardFontFamily,
                                      IDS_STANDARD_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldFixedFontFamily,
                                      IDS_FIXED_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldSerifFontFamily,
                                      IDS_SERIF_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldSansSerifFontFamily,
                                      IDS_SANS_SERIF_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldCursiveFontFamily,
                                      IDS_CURSIVE_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitOldFantasyFontFamily,
                                      IDS_FANTASY_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kGlobalDefaultCharset,
                                      IDS_DEFAULT_ENCODING,
-                                     PrefServiceSyncable::SYNCABLE_PREF);
+                                     PrefRegistrySyncable::SYNCABLE_PREF);
   prefs->RegisterLocalizedIntegerPref(prefs::kWebKitGlobalDefaultFontSize,
                                       IDS_DEFAULT_FONT_SIZE,
-                                      PrefServiceSyncable::UNSYNCABLE_PREF);
+                                      PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedIntegerPref(prefs::kWebKitGlobalDefaultFixedFontSize,
                                       IDS_DEFAULT_FIXED_FONT_SIZE,
-                                      PrefServiceSyncable::UNSYNCABLE_PREF);
+                                      PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedIntegerPref(prefs::kWebKitGlobalMinimumFontSize,
                                       IDS_MINIMUM_FONT_SIZE,
-                                      PrefServiceSyncable::UNSYNCABLE_PREF);
+                                      PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedIntegerPref(
       prefs::kWebKitGlobalMinimumLogicalFontSize,
       IDS_MINIMUM_LOGICAL_FONT_SIZE,
-      PrefServiceSyncable::UNSYNCABLE_PREF);
+      PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalStandardFontFamily,
                                      IDS_STANDARD_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalFixedFontFamily,
                                      IDS_FIXED_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalSerifFontFamily,
                                      IDS_SERIF_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalSansSerifFontFamily,
                                      IDS_SANS_SERIF_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalCursiveFontFamily,
                                      IDS_CURSIVE_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalFantasyFontFamily,
                                      IDS_FANTASY_FONT_FAMILY,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+                                     PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // The list of prefs we want to observe.
 const char* kPrefsToObserve[] = {
   prefs::kDefaultCharset,
   prefs::kWebKitAllowDisplayingInsecureContent,
   prefs::kWebKitAllowRunningInsecureContent,
   prefs::kWebKitDefaultFixedFontSize,
   prefs::kWebKitDefaultFontSize,
 #if defined(OS_ANDROID)
   prefs::kWebKitFontScaleFactor,
   prefs::kWebKitForceEnableZoom,
 #endif
   prefs::kWebKitJavascriptEnabled,
   prefs::kWebKitJavaEnabled,
   prefs::kWebKitLoadsImagesAutomatically,
   prefs::kWebKitMinimumFontSize,
   prefs::kWebKitMinimumLogicalFontSize,
   prefs::kWebKitPluginsEnabled,
   prefs::kWebkitTabsToLinks,
   prefs::kWebKitUsesUniversalDetector
 };
 
 const int kPrefsToObserveLength = arraysize(kPrefsToObserve);
 
 // Registers a preference under the path |map_name| for each script used for
 // per-script font prefs.  For example, if |map_name| is "fonts.serif", then
 // "fonts.serif.Arab", "fonts.serif.Hang", etc. are registered.
-void RegisterFontFamilyMap(PrefServiceSyncable* prefs,
+void RegisterFontFamilyMap(PrefRegistrySyncable* registry,
                            const char* map_name,
                            const std::set<std::string>& fonts_with_defaults) {
   for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) {
     const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i];
     std::string pref_name_str = base::StringPrintf("%s.%s", map_name, script);
     const char* pref_name = pref_name_str.c_str();
     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.
-      prefs->RegisterStringPref(
-          pref_name, "", PrefServiceSyncable::UNSYNCABLE_PREF);
+      registry->RegisterStringPref(
+          pref_name, "", PrefRegistrySyncable::UNSYNCABLE_PREF);
     }
   }
 }
 
 // Registers |obs| to observe per-script font prefs under the path |map_name|.
 void RegisterFontFamilyMapObserver(
     PrefChangeRegistrar* registrar,
     const char* map_name,
     const PrefChangeRegistrar::NamedChangeCallback& obs) {
   DCHECK(StartsWithASCII(map_name, "webkit.webprefs.", true));
@@ skipping 186 matching lines @@
   { prefs::kWebKitGlobalSansSerifFontFamily,
     prefs::kWebKitSansSerifFontFamily },
   { prefs::kWebKitGlobalSerifFontFamily,
     prefs::kWebKitSerifFontFamily },
   { prefs::kWebKitGlobalStandardFontFamily,
     prefs::kWebKitStandardFontFamily }
 };
 
 const int kPrefsToMigrateLength = ARRAYSIZE_UNSAFE(kPrefNamesToMigrate);
 
-void MigratePreferences(PrefServiceSyncable* 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;
@@ skipping 83 matching lines @@
   // 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);
 #if defined(OS_ANDROID)
   pref_store->RegisterOverlayPref(prefs::kProxy);
 #endif
 }
 
 // static
-void PrefsTabHelper::RegisterUserPrefs(PrefServiceSyncable* prefs) {
+void PrefsTabHelper::RegisterUserPrefs(PrefRegistrySyncable* registry) {
   WebPreferences pref_defaults;
-  prefs->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled,
-                             pref_defaults.javascript_enabled,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitWebSecurityEnabled,
-                             pref_defaults.web_security_enabled,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(
+  registry->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled,
+                                pref_defaults.javascript_enabled,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitWebSecurityEnabled,
+                                pref_defaults.web_security_enabled,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(
       prefs::kWebKitJavascriptCanOpenWindowsAutomatically,
       true,
-      PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically,
-                             pref_defaults.loads_images_automatically,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitPluginsEnabled,
-                             pref_defaults.plugins_enabled,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitDomPasteEnabled,
-                             pref_defaults.dom_paste_enabled,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitShrinksStandaloneImagesToFit,
-                             pref_defaults.shrinks_standalone_images_to_fit,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterDictionaryPref(prefs::kWebKitInspectorSettings,
-                                PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitTextAreasAreResizable,
-                             pref_defaults.text_areas_are_resizable,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitJavaEnabled,
-                             pref_defaults.java_enabled,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebkitTabsToLinks,
-                             pref_defaults.tabs_to_links,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitAllowRunningInsecureContent,
-                             false,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitAllowDisplayingInsecureContent,
-                             true,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kEnableReferrers,
-                             true,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
+      PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically,
+                                pref_defaults.loads_images_automatically,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitPluginsEnabled,
+                                pref_defaults.plugins_enabled,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitDomPasteEnabled,
+                                pref_defaults.dom_paste_enabled,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitShrinksStandaloneImagesToFit,
+                                pref_defaults.shrinks_standalone_images_to_fit,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterDictionaryPref(prefs::kWebKitInspectorSettings,
+                                   PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitTextAreasAreResizable,
+                                pref_defaults.text_areas_are_resizable,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitJavaEnabled,
+                                pref_defaults.java_enabled,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebkitTabsToLinks,
+                                pref_defaults.tabs_to_links,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitAllowRunningInsecureContent,
+                                false,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitAllowDisplayingInsecureContent,
+                                true,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kEnableReferrers,
+                                true,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 #if defined(OS_ANDROID)
-  prefs->RegisterDoublePref(prefs::kWebKitFontScaleFactor,
-                            pref_defaults.font_scale_factor,
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitForceEnableZoom,
-                             pref_defaults.force_enable_zoom,
-                             PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterDoublePref(prefs::kWebKitFontScaleFactor,
+                               pref_defaults.font_scale_factor,
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterBooleanPref(prefs::kWebKitForceEnableZoom,
+                                pref_defaults.force_enable_zoom,
+                                PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
 
 #if !defined(OS_MACOSX)
-  prefs->RegisterLocalizedStringPref(prefs::kAcceptLanguages,
-                                     IDS_ACCEPT_LANGUAGES,
-                                     PrefServiceSyncable::SYNCABLE_PREF);
+  registry->RegisterLocalizedStringPref(prefs::kAcceptLanguages,
+                                        IDS_ACCEPT_LANGUAGES,
+                                        PrefRegistrySyncable::SYNCABLE_PREF);
 #else
   // Not used in OSX.
-  prefs->RegisterLocalizedStringPref(prefs::kAcceptLanguages,
-                                     IDS_ACCEPT_LANGUAGES,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
+  registry->RegisterLocalizedStringPref(prefs::kAcceptLanguages,
+                                        IDS_ACCEPT_LANGUAGES,
+                                        PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
-  prefs->RegisterLocalizedStringPref(prefs::kDefaultCharset,
-                                     IDS_DEFAULT_ENCODING,
-                                     PrefServiceSyncable::SYNCABLE_PREF);
+  registry->RegisterLocalizedStringPref(prefs::kDefaultCharset,
+                                        IDS_DEFAULT_ENCODING,
+                                        PrefRegistrySyncable::SYNCABLE_PREF);
 
   // Register font prefs that have defaults.
   std::set<std::string> fonts_with_defaults;
   UScriptCode browser_script = GetScriptOfBrowserLocale();
   for (size_t i = 0; i < kFontDefaultsLength; ++i) {
     const FontDefault& pref = kFontDefaults[i];
     UScriptCode pref_script = GetScriptOfFontPref(pref.pref_name);
 
     // Suppress this default font pref value if it is for the primary script of
     // the browser's UI locale.  For example, if the pref is for the sans-serif
     // font for the Cyrillic script, and the browser locale is "ru" (Russian),
     // the default is suppressed.  Otherwise, the default would override the
     // user's font preferences when viewing pages in their native language.
     // This is because users have no way yet of customizing their per-script
     // font preferences.  The font prefs accessible in the options UI are for
     // the default, unknown script; these prefs have less priority than the
     // per-script font prefs when the script of the content is known.  This code
     // can possibly be removed later if users can easily access per-script font
     // prefs (e.g., via the extensions workflow), or the problem turns out to
     // not be really critical after all.
     if (browser_script != pref_script) {
-      prefs->RegisterLocalizedStringPref(pref.pref_name,
-                                         pref.resource_id,
-                                         PrefServiceSyncable::UNSYNCABLE_PREF);
+      registry->RegisterLocalizedStringPref(
+          pref.pref_name,
+          pref.resource_id,
+          PrefRegistrySyncable::UNSYNCABLE_PREF);
       fonts_with_defaults.insert(pref.pref_name);
     }
   }
 
   // Register font prefs that don't have defaults.
-  RegisterFontFamilyMap(prefs, prefs::kWebKitStandardFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitStandardFontFamilyMap,
                         fonts_with_defaults);
-  RegisterFontFamilyMap(prefs, prefs::kWebKitFixedFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitFixedFontFamilyMap,
                         fonts_with_defaults);
-  RegisterFontFamilyMap(prefs, prefs::kWebKitSerifFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitSerifFontFamilyMap,
                         fonts_with_defaults);
-  RegisterFontFamilyMap(prefs, prefs::kWebKitSansSerifFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitSansSerifFontFamilyMap,
                         fonts_with_defaults);
-  RegisterFontFamilyMap(prefs, prefs::kWebKitCursiveFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitCursiveFontFamilyMap,
                         fonts_with_defaults);
-  RegisterFontFamilyMap(prefs, prefs::kWebKitFantasyFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitFantasyFontFamilyMap,
                         fonts_with_defaults);
-  RegisterFontFamilyMap(prefs, prefs::kWebKitPictographFontFamilyMap,
+  RegisterFontFamilyMap(registry, prefs::kWebKitPictographFontFamilyMap,
                         fonts_with_defaults);
 
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
-                                      IDS_DEFAULT_FONT_SIZE,
-                                      PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize,
-                                      IDS_DEFAULT_FIXED_FONT_SIZE,
-                                      PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize,
-                                      IDS_MINIMUM_FONT_SIZE,
-                                      PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedIntegerPref(
+  registry->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
+                                         IDS_DEFAULT_FONT_SIZE,
+                                         PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize,
+                                         IDS_DEFAULT_FIXED_FONT_SIZE,
+                                         PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize,
+                                         IDS_MINIMUM_FONT_SIZE,
+                                         PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterLocalizedIntegerPref(
       prefs::kWebKitMinimumLogicalFontSize,
       IDS_MINIMUM_LOGICAL_FONT_SIZE,
-      PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedBooleanPref(prefs::kWebKitUsesUniversalDetector,
-                                      IDS_USES_UNIVERSAL_DETECTOR,
-                                      PrefServiceSyncable::SYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kStaticEncodings,
-                                     IDS_STATIC_ENCODING_LIST,
-                                     PrefServiceSyncable::UNSYNCABLE_PREF);
-  prefs->RegisterStringPref(prefs::kRecentlySelectedEncoding,
-                            "",
-                            PrefServiceSyncable::UNSYNCABLE_PREF);
-  MigratePreferences(prefs);
+      PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterLocalizedBooleanPref(prefs::kWebKitUsesUniversalDetector,
+                                         IDS_USES_UNIVERSAL_DETECTOR,
+                                         PrefRegistrySyncable::SYNCABLE_PREF);
+  registry->RegisterLocalizedStringPref(prefs::kStaticEncodings,
+                                        IDS_STATIC_ENCODING_LIST,
+                                        PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterStringPref(prefs::kRecentlySelectedEncoding,
+                               "",
+                               PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+void PrefsTabHelper::MigrateUserPrefs(PrefService* prefs,
+                                      PrefRegistrySyncable* registry) {
+  RegisterPrefsToMigrate(registry);
+  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);
+    registry->DeprecatedUnregisterPreference(kPrefNamesToMigrate[i].from);
+  }
 }
 
 void PrefsTabHelper::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_USER_STYLE_SHEET_UPDATED:
       UpdateWebPreferences();
       break;
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && defined(ENABLE_THEMES)
@@ skipping 52 matching lines @@
       WebPreferences web_prefs =
           web_contents_->GetRenderViewHost()->GetWebkitPreferences();
       OverrideFontFamily(&web_prefs, generic_family, script, "");
       web_contents_->GetRenderViewHost()->UpdateWebkitPreferences(web_prefs);
       return;
     }
   }
 
   UpdateWebPreferences();
 }