Add more per-tab preferences.

intl.global.charset_default
webkit.webprefs.global.standard_font_family
webkit.webprefs.global.fixed_font_family
webkit.webprefs.global.serif_font_family
webkit.webprefs.global.sansserif_font_family
webkit.webprefs.global.cursive_font_family
webkit.webprefs.global.fantasy_font_family
webkit.webprefs.global.default_font_size
webkit.webprefs.global.default_fixed_font_size
webkit.webprefs.global.minimum_font_size
webkit.webprefs.global.minimum_logical_font_size
webkit.webprefs.global.javascript_can_open_windows_automatically
webkit.webprefs.global.loads_images_automatically
webkit.webprefs.global.plugins_enabled

BUG=105537
TEST=PrefsTabHelperTest*,PrefsTabHelperBrowserTest*

For files that has only prefs names changes and require OWNERS approval:

TBR=erikwright@chromium.org,gene@chromium.org,csilv@chromium.org,atwilson@chromium.org,mirandac@chromium.org

Review URL: http://codereview.chromium.org/8879016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@115955 0039d316-1c4b-4281-b951-d872f2087c98

25 files changed, 565 insertions, 117 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index 8340316..cb0e2dd 100644
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -730,7 +730,8 @@ void AutomationProvider::OnSetPageFontSize(int tab_handle,
       DCHECK(tab->tab_contents()->GetBrowserContext() != NULL);
       Profile* profile =
           Profile::FromBrowserContext(tab->tab_contents()->GetBrowserContext());
-      profile->GetPrefs()->SetInteger(prefs::kWebKitDefaultFontSize, font_size);
+      profile->GetPrefs()->SetInteger(
+          prefs::kWebKitGlobalDefaultFontSize, font_size);
     }
   }
 }
diff --git a/chrome/browser/browser_encoding_uitest.cc b/chrome/browser/browser_encoding_uitest.cc
index 42267ac..93bb37e 100644
--- a/chrome/browser/browser_encoding_uitest.cc
+++ b/chrome/browser/browser_encoding_uitest.cc
@@ -249,7 +249,7 @@ TEST_F(BrowserEncodingTest, MAYBE_TestEncodingAutoDetect) {
   // Set the default charset to one of encodings not supported by the current
   // auto-detector (Please refer to the above comments) to make sure we
   // incorrectly decode the page. Now we use ISO-8859-4.
-  ASSERT_TRUE(browser->SetStringPreference(prefs::kDefaultCharset,
+  ASSERT_TRUE(browser->SetStringPreference(prefs::kGlobalDefaultCharset,
                                            "ISO-8859-4"));
   scoped_refptr<TabProxy> tab(GetActiveTab());
   ASSERT_TRUE(tab.get());
diff --git a/chrome/browser/net/chrome_url_request_context.cc b/chrome/browser/net/chrome_url_request_context.cc
index 5a71d38..b303d13 100644
--- a/chrome/browser/net/chrome_url_request_context.cc
+++ b/chrome/browser/net/chrome_url_request_context.cc
@@ -279,9 +279,9 @@ void ChromeURLRequestContextGetter::Observe(
               &ChromeURLRequestContextGetter::OnAcceptLanguageChange,
               this,
               accept_language));
-    } else if (*pref_name_in == prefs::kDefaultCharset) {
+    } else if (*pref_name_in == prefs::kGlobalDefaultCharset) {
       std::string default_charset =
-          prefs->GetString(prefs::kDefaultCharset);
+          prefs->GetString(prefs::kGlobalDefaultCharset);
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(
@@ -308,7 +308,7 @@ void ChromeURLRequestContextGetter::RegisterPrefsObserver(Profile* profile) {
 
   registrar_.Init(profile->GetPrefs());
   registrar_.Add(prefs::kAcceptLanguages, this);
-  registrar_.Add(prefs::kDefaultCharset, this);
+  registrar_.Add(prefs::kGlobalDefaultCharset, this);
   registrar_.Add(prefs::kClearSiteDataOnExit, this);
 }
 
diff --git a/chrome/browser/prefs/default_pref_store.cc b/chrome/browser/prefs/default_pref_store.cc
index c8b9b8a..06168bc 100644
--- a/chrome/browser/prefs/default_pref_store.cc
+++ b/chrome/browser/prefs/default_pref_store.cc
@@ -15,6 +15,11 @@ void DefaultPrefStore::SetDefaultValue(const std::string& key, Value* value) {
   SetValue(key, value);
 }
 
+void DefaultPrefStore::RemoveDefaultValue(const std::string& key) {
+  CHECK(GetValue(key, NULL) == READ_OK);
+  RemoveValue(key);
+}
+
 base::Value::Type DefaultPrefStore::GetType(const std::string& key) const {
   const Value* value;
   return GetValue(key, &value) == READ_OK ? value->GetType() : Value::TYPE_NULL;
diff --git a/chrome/browser/prefs/default_pref_store.h b/chrome/browser/prefs/default_pref_store.h
index 4f818a5..96de6d3 100644
--- a/chrome/browser/prefs/default_pref_store.h
+++ b/chrome/browser/prefs/default_pref_store.h
@@ -21,6 +21,9 @@ class DefaultPrefStore : public ValueMapPrefStore {
   // Stores a new |value| for |key|. Assumes ownership of |value|.
   void SetDefaultValue(const std::string& key, Value* value);
 
+  // Removes the value for |key|.
+  void RemoveDefaultValue(const std::string& key);
+
   // Returns the registered type for |key| or Value::TYPE_NULL if the |key|
   // has not been registered.
   base::Value::Type GetType(const std::string& key) const;
diff --git a/chrome/browser/prefs/per_tab_user_pref_store.cc b/chrome/browser/prefs/per_tab_user_pref_store.cc
index d521ea1..41f0c8f 100644
--- a/chrome/browser/prefs/per_tab_user_pref_store.cc
+++ b/chrome/browser/prefs/per_tab_user_pref_store.cc
@@ -8,5 +8,48 @@
 PerTabUserPrefStore::PerTabUserPrefStore(PersistentPrefStore* underlay)
     : OverlayUserPrefStore(underlay) {
   RegisterOverlayProperty(
-      prefs::kWebKitJavascriptEnabled, prefs::kWebKitGlobalJavascriptEnabled);
+      prefs::kWebKitJavascriptEnabled,
+      prefs::kWebKitGlobalJavascriptEnabled);
+  RegisterOverlayProperty(
+      prefs::kWebKitJavascriptCanOpenWindowsAutomatically,
+      prefs::kWebKitGlobalJavascriptCanOpenWindowsAutomatically);
+  RegisterOverlayProperty(
+      prefs::kWebKitLoadsImagesAutomatically,
+      prefs::kWebKitGlobalLoadsImagesAutomatically);
+  RegisterOverlayProperty(
+      prefs::kWebKitPluginsEnabled,
+      prefs::kWebKitGlobalPluginsEnabled);
+  RegisterOverlayProperty(
+      prefs::kDefaultCharset,
+      prefs::kGlobalDefaultCharset);
+  RegisterOverlayProperty(
+      prefs::kWebKitStandardFontFamily,
+      prefs::kWebKitGlobalStandardFontFamily);
+  RegisterOverlayProperty(
+      prefs::kWebKitFixedFontFamily,
+      prefs::kWebKitGlobalFixedFontFamily);
+  RegisterOverlayProperty(
+      prefs::kWebKitSerifFontFamily,
+      prefs::kWebKitGlobalSerifFontFamily);
+  RegisterOverlayProperty(
+      prefs::kWebKitSansSerifFontFamily,
+      prefs::kWebKitGlobalSansSerifFontFamily);
+  RegisterOverlayProperty(
+      prefs::kWebKitCursiveFontFamily,
+      prefs::kWebKitGlobalCursiveFontFamily);
+  RegisterOverlayProperty(
+      prefs::kWebKitFantasyFontFamily,
+      prefs::kWebKitGlobalFantasyFontFamily);
+  RegisterOverlayProperty(
+      prefs::kWebKitDefaultFontSize,
+      prefs::kWebKitGlobalDefaultFontSize);
+  RegisterOverlayProperty(
+      prefs::kWebKitDefaultFixedFontSize,
+      prefs::kWebKitGlobalDefaultFixedFontSize);
+  RegisterOverlayProperty(
+      prefs::kWebKitMinimumFontSize,
+      prefs::kWebKitGlobalMinimumFontSize);
+  RegisterOverlayProperty(
+      prefs::kWebKitMinimumLogicalFontSize,
+      prefs::kWebKitGlobalMinimumLogicalFontSize);
 }
diff --git a/chrome/browser/prefs/pref_model_associator.cc b/chrome/browser/prefs/pref_model_associator.cc
index 4f06c19..45d4332 100644
--- a/chrome/browser/prefs/pref_model_associator.cc
+++ b/chrome/browser/prefs/pref_model_associator.cc
@@ -376,6 +376,11 @@ bool PrefModelAssociator::IsPrefRegistered(const char* name) {
   return registered_preferences_.count(name) > 0;
 }
 
+void PrefModelAssociator::UnregisterPref(const char* name) {
+  DCHECK(synced_preferences_.count(name) == 0);
+  registered_preferences_.erase(name);
+}
+
 void PrefModelAssociator::ProcessPrefChange(const std::string& name) {
   if (processing_syncer_changes_)
     return;  // These are changes originating from us, ignore.
diff --git a/chrome/browser/prefs/pref_model_associator.h b/chrome/browser/prefs/pref_model_associator.h
index cf1dd77..3d2fd1f 100644
--- a/chrome/browser/prefs/pref_model_associator.h
+++ b/chrome/browser/prefs/pref_model_associator.h
@@ -60,6 +60,10 @@ class PrefModelAssociator
   // Returns true if the specified preference is registered for syncing.
   virtual bool IsPrefRegistered(const char* name);
 
+  // Unregisters a previously registered preference. This must be called
+  // prior to making the first sync.
+  virtual void UnregisterPref(const char* name);
+
   // Process a local preference change. This can trigger new SyncChanges being
   // sent to the syncer.
   virtual void ProcessPrefChange(const std::string& name);
diff --git a/chrome/browser/prefs/pref_service.cc b/chrome/browser/prefs/pref_service.cc
index 6ec0802..5022bdd 100644
--- a/chrome/browser/prefs/pref_service.cc
+++ b/chrome/browser/prefs/pref_service.cc
@@ -745,6 +745,24 @@ void PrefService::RegisterPreference(const char* path,
     pref_sync_associator_->RegisterPref(path);
 }
 
+void PrefService::UnregisterPreference(const char* path) {
+  DCHECK(CalledOnValidThread());
+
+  Preference p(this, path, Value::TYPE_NULL);
+  PreferenceSet::const_iterator it = prefs_.find(&p);
+  if (it == prefs_.end()) {
+    NOTREACHED() << "Trying to unregister an unregistered pref: " << path;
+    return;
+  }
+
+  prefs_.erase(it);
+  default_store_->RemoveDefaultValue(path);
+  if (pref_sync_associator_.get() &&
+      pref_sync_associator_->IsPrefRegistered(path)) {
+    pref_sync_associator_->UnregisterPref(path);
+  }
+}
+
 void PrefService::ClearPref(const char* path) {
   DCHECK(CalledOnValidThread());
 
diff --git a/chrome/browser/prefs/pref_service.h b/chrome/browser/prefs/pref_service.h
index a035de86..f0ed120 100644
--- a/chrome/browser/prefs/pref_service.h
+++ b/chrome/browser/prefs/pref_service.h
@@ -238,6 +238,8 @@ class PrefService : public base::NonThreadSafe {
   void RegisterInt64Pref(const char* path,
                          int64 default_value,
                          PrefSyncStatus sync_status);
+  // Unregisters a preference.
+  void UnregisterPreference(const char* path);
 
   // If the path is valid and the value at the end of the path matches the type
   // specified, it will return the specified value.  Otherwise, the default
diff --git a/chrome/browser/prefs/pref_service_unittest.cc b/chrome/browser/prefs/pref_service_unittest.cc
index 9a490a4..de2060d 100644
--- a/chrome/browser/prefs/pref_service_unittest.cc
+++ b/chrome/browser/prefs/pref_service_unittest.cc
@@ -255,9 +255,9 @@ class PrefServiceWebKitPrefs : public ChromeRenderViewHostTestHarness {
     pref_services->SetUserPref(prefs::kUsesSystemTheme,
                                Value::CreateBooleanValue(false));
 #endif
-    pref_services->SetUserPref(prefs::kDefaultCharset,
+    pref_services->SetUserPref(prefs::kGlobalDefaultCharset,
                                Value::CreateStringValue("utf8"));
-    pref_services->SetUserPref(prefs::kWebKitDefaultFontSize,
+    pref_services->SetUserPref(prefs::kWebKitGlobalDefaultFontSize,
                                Value::CreateIntegerValue(20));
     pref_services->SetUserPref(prefs::kWebKitTextAreasAreResizable,
                                Value::CreateBooleanValue(false));
diff --git a/chrome/browser/printing/cloud_print/cloud_print_setup_flow.cc b/chrome/browser/printing/cloud_print/cloud_print_setup_flow.cc
index e368150..88e5ad8 100644
--- a/chrome/browser/printing/cloud_print/cloud_print_setup_flow.cc
+++ b/chrome/browser/printing/cloud_print/cloud_print_setup_flow.cc
@@ -134,8 +134,8 @@ void CloudPrintSetupFlow::GetWebUIMessageHandlers(
 void CloudPrintSetupFlow::GetDialogSize(gfx::Size* size) const {
   PrefService* prefs = profile_->GetPrefs();
   gfx::Font approximate_web_font(
-      prefs->GetString(prefs::kWebKitSansSerifFontFamily),
-      prefs->GetInteger(prefs::kWebKitDefaultFontSize));
+      prefs->GetString(prefs::kWebKitGlobalSansSerifFontFamily),
+      prefs->GetInteger(prefs::kWebKitGlobalDefaultFontSize));
 
   if (setup_done_) {
     *size = ui::GetLocalizedContentsSizeForFont(
@@ -316,8 +316,8 @@ void CloudPrintSetupFlow::ShowSetupDone() {
   if (web_ui_) {
     PrefService* prefs = profile_->GetPrefs();
     gfx::Font approximate_web_font(
-        prefs->GetString(prefs::kWebKitSansSerifFontFamily),
-        prefs->GetInteger(prefs::kWebKitDefaultFontSize));
+        prefs->GetString(prefs::kWebKitGlobalSansSerifFontFamily),
+        prefs->GetInteger(prefs::kWebKitGlobalDefaultFontSize));
     gfx::Size done_size = ui::GetLocalizedContentsSizeForFont(
         IDS_CLOUD_PRINT_SETUP_WIZARD_DONE_WIDTH_CHARS,
         IDS_CLOUD_PRINT_SETUP_WIZARD_DONE_HEIGHT_LINES,
diff --git a/chrome/browser/profiles/profile_io_data.cc b/chrome/browser/profiles/profile_io_data.cc
index 0675f7d..e017df4 100644
--- a/chrome/browser/profiles/profile_io_data.cc
+++ b/chrome/browser/profiles/profile_io_data.cc
@@ -204,7 +204,8 @@ void ProfileIOData::InitializeOnUIThread(Profile* profile) {
   // Set up Accept-Language and Accept-Charset header values
   params->accept_language = net::HttpUtil::GenerateAcceptLanguageHeader(
       pref_service->GetString(prefs::kAcceptLanguages));
-  std::string default_charset = pref_service->GetString(prefs::kDefaultCharset);
+  std::string default_charset =
+      pref_service->GetString(prefs::kGlobalDefaultCharset);
   params->accept_charset =
       net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
 
diff --git a/chrome/browser/resources/options/font_settings.html b/chrome/browser/resources/options/font_settings.html
index c025230..8286cb0 100644
--- a/chrome/browser/resources/options/font_settings.html
+++ b/chrome/browser/resources/options/font_settings.html
@@ -5,7 +5,7 @@
     <div class="font-input-div">
       <div>
         <select id="standard-font-family" class="font-input" data-type="string"
-            pref="webkit.webprefs.standard_font_family"
+            pref="webkit.webprefs.global.standard_font_family"
             metric="Options_ChangeStandardFont"></select>
       </div>
       <div>
@@ -25,7 +25,7 @@
     <div class="font-input-div">
       <div>
         <select id="serif-font-family" class="font-input" data-type="string"
-            pref="webkit.webprefs.serif_font_family"
+            pref="webkit.webprefs.global.serif_font_family"
             metric="Options_ChangeSerifFont"></select>
       </div>
     </div>
@@ -37,7 +37,7 @@
       <div>
         <select id="sans-serif-font-family" class="font-input"
             data-type="string"
-            pref="webkit.webprefs.sansserif_font_family"
+            pref="webkit.webprefs.global.sansserif_font_family"
             metric="Options_ChangeSansSerifFont"></select>
       </div>
     </div>
@@ -48,7 +48,7 @@
     <div class="font-input-div">
       <div>
         <select id="fixed-font-family" class="font-input" data-type="string"
-            pref="webkit.webprefs.fixed_font_family"
+            pref="webkit.webprefs.global.fixed_font_family"
             metric="Options_ChangeFixedFont"></select>
       </div>
     </div>
@@ -59,7 +59,7 @@
     <div class="font-input-div">
       <div>
         <input id="minimum-font-size" type="range" min="0" max="15"
-            pref="webkit.webprefs.minimum_font_size">
+            pref="webkit.webprefs.global.minimum_font_size">
         <div>
           <span i18n-content="fontSettingsSizeTiny"></span>
           <span i18n-content="fontSettingsSizeHuge" class="font-settings-huge">
@@ -74,7 +74,7 @@
     <div class="font-input-div">
       <div>
         <select id="font-encoding" data-type="string"
-            pref="intl.charset_default"
+            pref="intl.global.charset_default"
             metric="Options_ChangeFontEncoding"></select>
       </div>
     </div>
diff --git a/chrome/browser/sync/profile_sync_service_preference_unittest.cc b/chrome/browser/sync/profile_sync_service_preference_unittest.cc
index 17fc166f..26dc5e3 100644
--- a/chrome/browser/sync/profile_sync_service_preference_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_preference_unittest.cc
@@ -316,7 +316,7 @@ TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationCloudHasData) {
   urls_to_restore->Append(Value::CreateStringValue(example_url1_));
   urls_to_restore->Append(Value::CreateStringValue(example_url2_));
   cloud_data[prefs::kURLsToRestoreOnStartup] = urls_to_restore;
-  cloud_data[prefs::kDefaultCharset] =
+  cloud_data[prefs::kGlobalDefaultCharset] =
       Value::CreateStringValue(non_default_charset_value_);
 
   AddPreferenceEntriesHelper helper(this, cloud_data);
@@ -341,13 +341,13 @@ TEST_F(ProfileSyncServicePreferenceTest, ModelAssociationCloudHasData) {
   EXPECT_TRUE(GetPreferenceValue(prefs::kURLsToRestoreOnStartup).
               Equals(expected_urls.get()));
 
-  value.reset(GetSyncedValue(prefs::kDefaultCharset));
+  value.reset(GetSyncedValue(prefs::kGlobalDefaultCharset));
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(static_cast<const StringValue*>(value.get())->
               GetAsString(&string_value));
   EXPECT_EQ(non_default_charset_value_, string_value);
   EXPECT_EQ(non_default_charset_value_,
-            prefs_->GetString(prefs::kDefaultCharset));
+            prefs_->GetString(prefs::kGlobalDefaultCharset));
   STLDeleteValues(&cloud_data);
 }
 
diff --git a/chrome/browser/sync/test/integration/two_client_preferences_sync_test.cc b/chrome/browser/sync/test/integration/two_client_preferences_sync_test.cc
index 81438b5..a850373 100644
--- a/chrome/browser/sync/test/integration/two_client_preferences_sync_test.cc
+++ b/chrome/browser/sync/test/integration/two_client_preferences_sync_test.cc
@@ -360,13 +360,13 @@ IN_PROC_BROWSER_TEST_F(TwoClientPreferencesSyncTest,
 }
 
 // TCM ID - 3673298.
-IN_PROC_BROWSER_TEST_F(TwoClientPreferencesSyncTest, kDefaultCharset) {
+IN_PROC_BROWSER_TEST_F(TwoClientPreferencesSyncTest, kGlobalDefaultCharset) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
-  ASSERT_TRUE(StringPrefMatches(prefs::kDefaultCharset));
+  ASSERT_TRUE(StringPrefMatches(prefs::kGlobalDefaultCharset));
 
-  ChangeStringPref(0, prefs::kDefaultCharset, "Thai");
+  ChangeStringPref(0, prefs::kGlobalDefaultCharset, "Thai");
   ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
-  ASSERT_TRUE(StringPrefMatches(prefs::kDefaultCharset));
+  ASSERT_TRUE(StringPrefMatches(prefs::kGlobalDefaultCharset));
 }
 
 // TCM ID - 3653296.
diff --git a/chrome/browser/tab_contents/render_view_host_delegate_helper.cc b/chrome/browser/tab_contents/render_view_host_delegate_helper.cc
index 0842575..59f3ab3 100644
--- a/chrome/browser/tab_contents/render_view_host_delegate_helper.cc
+++ b/chrome/browser/tab_contents/render_view_host_delegate_helper.cc
@@ -340,17 +340,17 @@ WebPreferences RenderViewHostDelegateHelper::GetWebkitPrefs(
   WebPreferences web_prefs;
 
   web_prefs.standard_font_family =
-      UTF8ToUTF16(prefs->GetString(prefs::kWebKitStandardFontFamily));
+      UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalStandardFontFamily));
   web_prefs.fixed_font_family =
-      UTF8ToUTF16(prefs->GetString(prefs::kWebKitFixedFontFamily));
+      UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalFixedFontFamily));
   web_prefs.serif_font_family =
-      UTF8ToUTF16(prefs->GetString(prefs::kWebKitSerifFontFamily));
+      UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalSerifFontFamily));
   web_prefs.sans_serif_font_family =
-      UTF8ToUTF16(prefs->GetString(prefs::kWebKitSansSerifFontFamily));
+      UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalSansSerifFontFamily));
   web_prefs.cursive_font_family =
-      UTF8ToUTF16(prefs->GetString(prefs::kWebKitCursiveFontFamily));
+      UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalCursiveFontFamily));
   web_prefs.fantasy_font_family =
-      UTF8ToUTF16(prefs->GetString(prefs::kWebKitFantasyFontFamily));
+      UTF8ToUTF16(prefs->GetString(prefs::kWebKitGlobalFantasyFontFamily));
 
   FillFontFamilyMap(prefs, prefs::kWebKitStandardFontFamilyMap,
                     &web_prefs.standard_font_family_map);
@@ -366,18 +366,19 @@ WebPreferences RenderViewHostDelegateHelper::GetWebkitPrefs(
                     &web_prefs.fantasy_font_family_map);
 
   web_prefs.default_font_size =
-      prefs->GetInteger(prefs::kWebKitDefaultFontSize);
+      prefs->GetInteger(prefs::kWebKitGlobalDefaultFontSize);
   web_prefs.default_fixed_font_size =
-      prefs->GetInteger(prefs::kWebKitDefaultFixedFontSize);
+      prefs->GetInteger(prefs::kWebKitGlobalDefaultFixedFontSize);
   web_prefs.minimum_font_size =
-      prefs->GetInteger(prefs::kWebKitMinimumFontSize);
+      prefs->GetInteger(prefs::kWebKitGlobalMinimumFontSize);
   web_prefs.minimum_logical_font_size =
-      prefs->GetInteger(prefs::kWebKitMinimumLogicalFontSize);
+      prefs->GetInteger(prefs::kWebKitGlobalMinimumLogicalFontSize);
 
-  web_prefs.default_encoding = prefs->GetString(prefs::kDefaultCharset);
+  web_prefs.default_encoding = prefs->GetString(prefs::kGlobalDefaultCharset);
 
   web_prefs.javascript_can_open_windows_automatically =
-      prefs->GetBoolean(prefs::kWebKitJavascriptCanOpenWindowsAutomatically);
+      prefs->GetBoolean(
+          prefs::kWebKitGlobalJavascriptCanOpenWindowsAutomatically);
   web_prefs.dom_paste_enabled =
       prefs->GetBoolean(prefs::kWebKitDomPasteEnabled);
   web_prefs.shrinks_standalone_images_to_fit =
@@ -407,12 +408,12 @@ WebPreferences RenderViewHostDelegateHelper::GetWebkitPrefs(
         prefs->GetBoolean(prefs::kWebKitWebSecurityEnabled);
     web_prefs.plugins_enabled =
         !command_line.HasSwitch(switches::kDisablePlugins) &&
-        prefs->GetBoolean(prefs::kWebKitPluginsEnabled);
+        prefs->GetBoolean(prefs::kWebKitGlobalPluginsEnabled);
     web_prefs.java_enabled =
         !command_line.HasSwitch(switches::kDisableJava) &&
         prefs->GetBoolean(prefs::kWebKitJavaEnabled);
     web_prefs.loads_images_automatically =
-        prefs->GetBoolean(prefs::kWebKitLoadsImagesAutomatically);
+        prefs->GetBoolean(prefs::kWebKitGlobalLoadsImagesAutomatically);
     web_prefs.uses_page_cache =
         command_line.HasSwitch(switches::kEnableFastback);
     web_prefs.remote_fonts_enabled =
@@ -543,8 +544,8 @@ WebPreferences RenderViewHostDelegateHelper::GetWebkitPrefs(
       CharacterEncoding::GetCanonicalEncodingNameByAliasName(
           web_prefs.default_encoding);
   if (web_prefs.default_encoding.empty()) {
-    prefs->ClearPref(prefs::kDefaultCharset);
-    web_prefs.default_encoding = prefs->GetString(prefs::kDefaultCharset);
+    prefs->ClearPref(prefs::kGlobalDefaultCharset);
+    web_prefs.default_encoding = prefs->GetString(prefs::kGlobalDefaultCharset);
   }
   DCHECK(!web_prefs.default_encoding.empty());
 
diff --git a/chrome/browser/ui/prefs/prefs_tab_helper.cc b/chrome/browser/ui/prefs/prefs_tab_helper.cc
index bcf0600..47ea5d8 100644
--- a/chrome/browser/ui/prefs/prefs_tab_helper.cc
+++ b/chrome/browser/ui/prefs/prefs_tab_helper.cc
@@ -6,6 +6,7 @@
 
 #include "base/stringprintf.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ -29,40 +30,103 @@ using content::WebContents;
 namespace {
 
 const char* kPerTabPrefsToObserve[] = {
-    prefs::kWebKitJavascriptEnabled
+  prefs::kDefaultCharset,
+  prefs::kWebKitJavascriptEnabled,
+  prefs::kWebKitJavascriptCanOpenWindowsAutomatically,
+  prefs::kWebKitLoadsImagesAutomatically,
+  prefs::kWebKitPluginsEnabled,
+  prefs::kWebKitCursiveFontFamily,
+  prefs::kWebKitFantasyFontFamily,
+  prefs::kWebKitFixedFontFamily,
+  prefs::kWebKitSansSerifFontFamily,
+  prefs::kWebKitSerifFontFamily,
+  prefs::kWebKitStandardFontFamily,
+  prefs::kWebKitDefaultFontSize,
+  prefs::kWebKitDefaultFixedFontSize,
+  prefs::kWebKitMinimumFontSize,
+  prefs::kWebKitMinimumLogicalFontSize
 };
 
 const int kPerTabPrefsToObserveLength = arraysize(kPerTabPrefsToObserve);
 
-void RegisterPerTabUserPrefs(PrefService* prefs) {
+static void RegisterFontsAndCharsetPrefs(PrefService* prefs) {
+  WebPreferences pref_defaults;
+
+  prefs->RegisterLocalizedStringPref(prefs::kDefaultCharset,
+                                     IDS_DEFAULT_ENCODING,
+                                     PrefService::SYNCABLE_PREF);
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitStandardFontFamily,
+                                     IDS_STANDARD_FONT_FAMILY,
+                                     PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitFixedFontFamily,
+                                     IDS_FIXED_FONT_FAMILY,
+                                     PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitSerifFontFamily,
+                                     IDS_SERIF_FONT_FAMILY,
+                                     PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitSansSerifFontFamily,
+                                     IDS_SANS_SERIF_FONT_FAMILY,
+                                     PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitCursiveFontFamily,
+                                     IDS_CURSIVE_FONT_FAMILY,
+                                     PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitFantasyFontFamily,
+                                     IDS_FANTASY_FONT_FAMILY,
+                                     PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
+                                      IDS_DEFAULT_FONT_SIZE,
+                                      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize,
+                                      IDS_DEFAULT_FIXED_FONT_SIZE,
+                                      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize,
+                                      IDS_MINIMUM_FONT_SIZE,
+                                      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumLogicalFontSize,
+                                      IDS_MINIMUM_LOGICAL_FONT_SIZE,
+                                      PrefService::UNSYNCABLE_PREF);
+}
+
+static void RegisterPerTabUserPrefs(PrefService* prefs) {
   WebPreferences pref_defaults;
 
   prefs->RegisterBooleanPref(prefs::kWebKitJavascriptEnabled,
                              pref_defaults.javascript_enabled,
                              PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterBooleanPref(
+      prefs::kWebKitJavascriptCanOpenWindowsAutomatically,
+      true,
+      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically,
+                             pref_defaults.loads_images_automatically,
+                             PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterBooleanPref(prefs::kWebKitPluginsEnabled,
+                             pref_defaults.plugins_enabled,
+                             PrefService::UNSYNCABLE_PREF);
+  RegisterFontsAndCharsetPrefs(prefs);
 }
 
 // The list of prefs we want to observe.
 const char* kPrefsToObserve[] = {
-  prefs::kDefaultCharset,
   prefs::kDefaultZoomLevel,
+  prefs::kGlobalDefaultCharset,
   prefs::kEnableReferrers,
   prefs::kWebKitAllowDisplayingInsecureContent,
   prefs::kWebKitAllowRunningInsecureContent,
-  prefs::kWebKitCursiveFontFamily,
-  prefs::kWebKitDefaultFixedFontSize,
-  prefs::kWebKitDefaultFontSize,
-  prefs::kWebKitFantasyFontFamily,
-  prefs::kWebKitFixedFontFamily,
+  prefs::kWebKitGlobalCursiveFontFamily,
+  prefs::kWebKitGlobalDefaultFixedFontSize,
+  prefs::kWebKitGlobalDefaultFontSize,
+  prefs::kWebKitGlobalFantasyFontFamily,
+  prefs::kWebKitGlobalFixedFontFamily,
   prefs::kWebKitGlobalJavascriptEnabled,
   prefs::kWebKitJavaEnabled,
-  prefs::kWebKitLoadsImagesAutomatically,
-  prefs::kWebKitMinimumFontSize,
-  prefs::kWebKitMinimumLogicalFontSize,
-  prefs::kWebKitPluginsEnabled,
-  prefs::kWebKitSansSerifFontFamily,
-  prefs::kWebKitSerifFontFamily,
-  prefs::kWebKitStandardFontFamily,
+  prefs::kWebKitGlobalLoadsImagesAutomatically,
+  prefs::kWebKitGlobalMinimumFontSize,
+  prefs::kWebKitGlobalMinimumLogicalFontSize,
+  prefs::kWebKitGlobalPluginsEnabled,
+  prefs::kWebKitGlobalSansSerifFontFamily,
+  prefs::kWebKitGlobalSerifFontFamily,
+  prefs::kWebKitGlobalStandardFontFamily,
   prefs::kWebkitTabsToLinks,
   prefs::kWebKitUsesUniversalDetector
 };
@@ -211,6 +275,49 @@ const PerScriptFontDefault kPerScriptFontDefaults[] = {
 const size_t kPerScriptFontDefaultsLength = arraysize(kPerScriptFontDefaults);
 #endif
 
+const struct {
+  const char* from;
+  const char* to;
+} kPrefNamesToMigrate[] = {
+  { prefs::kDefaultCharset,
+    prefs::kGlobalDefaultCharset },
+  { prefs::kWebKitCursiveFontFamily,
+    prefs::kWebKitGlobalCursiveFontFamily },
+  { prefs::kWebKitDefaultFixedFontSize,
+    prefs::kWebKitGlobalDefaultFixedFontSize },
+  { prefs::kWebKitDefaultFontSize,
+    prefs::kWebKitGlobalDefaultFontSize },
+  { prefs::kWebKitFantasyFontFamily,
+    prefs::kWebKitGlobalFantasyFontFamily },
+  { prefs::kWebKitFixedFontFamily,
+    prefs::kWebKitGlobalFixedFontFamily },
+  { prefs::kWebKitMinimumFontSize,
+    prefs::kWebKitGlobalMinimumFontSize },
+  { prefs::kWebKitMinimumLogicalFontSize,
+    prefs::kWebKitGlobalMinimumLogicalFontSize },
+  { prefs::kWebKitSansSerifFontFamily,
+    prefs::kWebKitGlobalSansSerifFontFamily },
+  { prefs::kWebKitSerifFontFamily,
+    prefs::kWebKitGlobalSerifFontFamily },
+  { prefs::kWebKitStandardFontFamily,
+    prefs::kWebKitGlobalStandardFontFamily },
+};
+
+const int kPrefsToMigrateLength = ARRAYSIZE_UNSAFE(kPrefNamesToMigrate);
+
+static void MigratePreferences(PrefService* prefs) {
+  RegisterFontsAndCharsetPrefs(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()->DeepCopy());
+    }
+    prefs->UnregisterPreference(kPrefNamesToMigrate[i].from);
+  }
+}
+
 }  // namespace
 
 PrefsTabHelper::PrefsTabHelper(WebContents* contents)
@@ -268,13 +375,13 @@ void PrefsTabHelper::RegisterUserPrefs(PrefService* prefs) {
                              pref_defaults.web_security_enabled,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(
-      prefs::kWebKitJavascriptCanOpenWindowsAutomatically,
+      prefs::kWebKitGlobalJavascriptCanOpenWindowsAutomatically,
       true,
       PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitLoadsImagesAutomatically,
+  prefs->RegisterBooleanPref(prefs::kWebKitGlobalLoadsImagesAutomatically,
                              pref_defaults.loads_images_automatically,
                              PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterBooleanPref(prefs::kWebKitPluginsEnabled,
+  prefs->RegisterBooleanPref(prefs::kWebKitGlobalPluginsEnabled,
                              pref_defaults.plugins_enabled,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kWebKitDomPasteEnabled,
@@ -311,25 +418,25 @@ void PrefsTabHelper::RegisterUserPrefs(PrefService* prefs) {
                                      IDS_ACCEPT_LANGUAGES,
                                      PrefService::UNSYNCABLE_PREF);
 #endif
-  prefs->RegisterLocalizedStringPref(prefs::kDefaultCharset,
+  prefs->RegisterLocalizedStringPref(prefs::kGlobalDefaultCharset,
                                      IDS_DEFAULT_ENCODING,
                                      PrefService::SYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitStandardFontFamily,
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalStandardFontFamily,
                                      IDS_STANDARD_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitFixedFontFamily,
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalFixedFontFamily,
                                      IDS_FIXED_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitSerifFontFamily,
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalSerifFontFamily,
                                      IDS_SERIF_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitSansSerifFontFamily,
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalSansSerifFontFamily,
                                      IDS_SANS_SERIF_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitCursiveFontFamily,
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalCursiveFontFamily,
                                      IDS_CURSIVE_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedStringPref(prefs::kWebKitFantasyFontFamily,
+  prefs->RegisterLocalizedStringPref(prefs::kWebKitGlobalFantasyFontFamily,
                                      IDS_FANTASY_FONT_FAMILY,
                                      PrefService::UNSYNCABLE_PREF);
 
@@ -360,18 +467,19 @@ void PrefsTabHelper::RegisterUserPrefs(PrefService* prefs) {
   RegisterFontFamilyMap(prefs, prefs::kWebKitCursiveFontFamilyMap);
   RegisterFontFamilyMap(prefs, prefs::kWebKitFantasyFontFamilyMap);
 
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFontSize,
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitGlobalDefaultFontSize,
                                       IDS_DEFAULT_FONT_SIZE,
                                       PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitDefaultFixedFontSize,
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitGlobalDefaultFixedFontSize,
                                       IDS_DEFAULT_FIXED_FONT_SIZE,
                                       PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumFontSize,
+  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitGlobalMinimumFontSize,
                                       IDS_MINIMUM_FONT_SIZE,
                                       PrefService::UNSYNCABLE_PREF);
-  prefs->RegisterLocalizedIntegerPref(prefs::kWebKitMinimumLogicalFontSize,
-                                      IDS_MINIMUM_LOGICAL_FONT_SIZE,
-                                      PrefService::UNSYNCABLE_PREF);
+  prefs->RegisterLocalizedIntegerPref(
+      prefs::kWebKitGlobalMinimumLogicalFontSize,
+      IDS_MINIMUM_LOGICAL_FONT_SIZE,
+      PrefService::UNSYNCABLE_PREF);
   prefs->RegisterLocalizedBooleanPref(prefs::kWebKitUsesUniversalDetector,
                                       IDS_USES_UNIVERSAL_DETECTOR,
                                       PrefService::SYNCABLE_PREF);
@@ -381,6 +489,7 @@ void PrefsTabHelper::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterStringPref(prefs::kRecentlySelectedEncoding,
                             "",
                             PrefService::UNSYNCABLE_PREF);
+  MigratePreferences(prefs);
 }
 
 void PrefsTabHelper::RenderViewCreated(RenderViewHost* render_view_host) {
@@ -409,7 +518,8 @@ void PrefsTabHelper::Observe(int type,
       DCHECK(content::Source<PrefService>(source).ptr() ==
                  GetProfile()->GetPrefs() ||
              content::Source<PrefService>(source).ptr() == per_tab_prefs_);
-      if ((*pref_name_in == prefs::kDefaultCharset) ||
+      if ((*pref_name_in == prefs::kDefaultCharset ||
+           *pref_name_in == prefs::kGlobalDefaultCharset) ||
           StartsWithASCII(*pref_name_in, "webkit.webprefs.", true)) {
         UpdateWebPreferences();
       } else if (*pref_name_in == prefs::kDefaultZoomLevel ||
@@ -431,6 +541,36 @@ void PrefsTabHelper::UpdateWebPreferences() {
   WebPreferences prefs = rvhd->GetWebkitPrefs();
   prefs.javascript_enabled =
       per_tab_prefs_->GetBoolean(prefs::kWebKitJavascriptEnabled);
+  prefs.javascript_can_open_windows_automatically =
+      per_tab_prefs_->GetBoolean(
+          prefs::kWebKitJavascriptCanOpenWindowsAutomatically);
+  prefs.loads_images_automatically =
+      per_tab_prefs_->GetBoolean(prefs::kWebKitLoadsImagesAutomatically);
+  prefs.plugins_enabled =
+      per_tab_prefs_->GetBoolean(prefs::kWebKitPluginsEnabled);
+  prefs.standard_font_family =
+      UTF8ToUTF16(per_tab_prefs_->GetString(prefs::kWebKitStandardFontFamily));
+  prefs.fixed_font_family =
+      UTF8ToUTF16(per_tab_prefs_->GetString(prefs::kWebKitFixedFontFamily));
+  prefs.serif_font_family =
+      UTF8ToUTF16(per_tab_prefs_->GetString(prefs::kWebKitSerifFontFamily));
+  prefs.sans_serif_font_family =
+      UTF8ToUTF16(per_tab_prefs_->GetString(prefs::kWebKitSansSerifFontFamily));
+  prefs.cursive_font_family =
+      UTF8ToUTF16(per_tab_prefs_->GetString(prefs::kWebKitCursiveFontFamily));
+  prefs.fantasy_font_family =
+      UTF8ToUTF16(per_tab_prefs_->GetString(prefs::kWebKitFantasyFontFamily));
+  prefs.default_font_size =
+      per_tab_prefs_->GetInteger(prefs::kWebKitDefaultFontSize);
+  prefs.default_fixed_font_size =
+      per_tab_prefs_->GetInteger(prefs::kWebKitDefaultFixedFontSize);
+  prefs.minimum_font_size =
+      per_tab_prefs_->GetInteger(prefs::kWebKitMinimumFontSize);
+  prefs.minimum_logical_font_size =
+      per_tab_prefs_->GetInteger(prefs::kWebKitMinimumLogicalFontSize);
+  prefs.default_encoding =
+      per_tab_prefs_->GetString(prefs::kDefaultCharset);
+
   web_contents()->GetRenderViewHost()->UpdateWebkitPreferences(prefs);
 }
 
diff --git a/chrome/browser/ui/prefs/prefs_tab_helper_browsertest.cc b/chrome/browser/ui/prefs/prefs_tab_helper_browsertest.cc
new file mode 100644
index 0000000..890a33a
--- /dev/null
+++ b/chrome/browser/ui/prefs/prefs_tab_helper_browsertest.cc
@@ -0,0 +1,89 @@
+// Copyright (c) 2011 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 "base/file_util.h"
+#include "base/path_service.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/in_process_browser_test.h"
+
+class PrefsTabHelperBrowserTest : public InProcessBrowserTest {
+ protected:
+  virtual bool SetUpUserDataDirectory() OVERRIDE {
+    FilePath test_data_directory;
+    PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory);
+    FilePath user_data_directory;
+    PathService::Get(chrome::DIR_USER_DATA, &user_data_directory);
+    FilePath default_profile = user_data_directory.AppendASCII("Default");
+    if (!file_util::CreateDirectory(default_profile)) {
+      LOG(ERROR) << "Can't create " << default_profile.MaybeAsASCII();
+      return false;
+    }
+    FilePath non_global_pref_file;
+    non_global_pref_file = test_data_directory
+        .AppendASCII("profiles")
+        .AppendASCII("webkit_global_migration")
+        .AppendASCII("Default")
+        .Append(chrome::kPreferencesFilename);
+    if (!file_util::PathExists(non_global_pref_file)) {
+      LOG(ERROR) << "Doesn't exist " << non_global_pref_file.MaybeAsASCII();
+      return false;
+    }
+    FilePath default_pref_file =
+        default_profile.Append(chrome::kPreferencesFilename);
+    if (!file_util::CopyFile(non_global_pref_file, default_pref_file)) {
+      LOG(ERROR) << "Copy error from " << non_global_pref_file.MaybeAsASCII()
+                 << " to " << default_pref_file.MaybeAsASCII();
+      return false;
+    }
+
+#if defined(OS_WIN)
+    // Make the copy writable.  On POSIX we assume the umask allows files
+    // we create to be writable.
+    if (!::SetFileAttributesW(default_pref_file.value().c_str(),
+                              FILE_ATTRIBUTE_NORMAL)) return false;
+#endif
+    return true;
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(PrefsTabHelperBrowserTest, NonGlobalPrefsAreMigrated) {
+  PrefService* prefs = browser()->profile()->GetPrefs();
+
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kDefaultCharset));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitDefaultFontSize));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitDefaultFixedFontSize));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitMinimumFontSize));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitMinimumLogicalFontSize));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitCursiveFontFamily));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitFantasyFontFamily));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitFixedFontFamily));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitSansSerifFontFamily));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitSerifFontFamily));
+  EXPECT_EQ(NULL, prefs->FindPreference(prefs::kWebKitStandardFontFamily));
+
+  EXPECT_EQ("ISO-8859-1", prefs->GetString(prefs::kGlobalDefaultCharset));
+  EXPECT_EQ(42, prefs->GetInteger(prefs::kWebKitGlobalDefaultFontSize));
+  EXPECT_EQ(42,
+            prefs->GetInteger(prefs::kWebKitGlobalDefaultFixedFontSize));
+  EXPECT_EQ(42, prefs->GetInteger(prefs::kWebKitGlobalMinimumFontSize));
+  EXPECT_EQ(42,
+            prefs->GetInteger(prefs::kWebKitGlobalMinimumLogicalFontSize));
+  EXPECT_EQ("CursiveFontFamily",
+            prefs->GetString(prefs::kWebKitGlobalCursiveFontFamily));
+  EXPECT_EQ("FantasyFontFamily",
+            prefs->GetString(prefs::kWebKitGlobalFantasyFontFamily));
+  EXPECT_EQ("FixedFontFamily",
+            prefs->GetString(prefs::kWebKitGlobalFixedFontFamily));
+  EXPECT_EQ("SansSerifFontFamily",
+            prefs->GetString(prefs::kWebKitGlobalSansSerifFontFamily));
+  EXPECT_EQ("SerifFontFamily",
+            prefs->GetString(prefs::kWebKitGlobalSerifFontFamily));
+  EXPECT_EQ("StandardFontFamily",
+            prefs->GetString(prefs::kWebKitGlobalStandardFontFamily));
+}
diff --git a/chrome/browser/ui/prefs/prefs_tab_helper_unittest.cc b/chrome/browser/ui/prefs/prefs_tab_helper_unittest.cc
index 168bbb0..cc443bb 100644
--- a/chrome/browser/ui/prefs/prefs_tab_helper_unittest.cc
+++ b/chrome/browser/ui/prefs/prefs_tab_helper_unittest.cc
@@ -49,11 +49,95 @@ class PrefsTabHelperTest : public TabContentsWrapperTestHarness {
     return contents_wrapper2_.get();
   }
 
+  TestPrefsTabHelper* CreateTestPrefsTabHelper() {
+    TestPrefsTabHelper* test_prefs_helper =
+        new TestPrefsTabHelper(contents_wrapper()->tab_contents());
+    contents_wrapper()->prefs_tab_helper_.reset(test_prefs_helper);
+    return test_prefs_helper;
+  }
+
   void SetContents2(TestTabContents* contents) {
     contents_wrapper2_.reset(
         contents ? new TabContentsWrapper(contents) : NULL);
   }
 
+  void TestBooleanPreference(const char* key) {
+    PrefService* prefs1 =
+        contents_wrapper()->prefs_tab_helper()->per_tab_prefs();
+    PrefService* prefs2 =
+        contents_wrapper2()->prefs_tab_helper()->per_tab_prefs();
+    const bool initial_value = prefs1->GetBoolean(key);
+    EXPECT_EQ(initial_value, prefs2->GetBoolean(key));
+
+    prefs1->SetBoolean(key, !initial_value);
+    EXPECT_EQ(!initial_value, prefs1->GetBoolean(key));
+    EXPECT_EQ(initial_value, prefs2->GetBoolean(key));
+
+    prefs1->SetBoolean(key, initial_value);
+    EXPECT_EQ(initial_value, prefs1->GetBoolean(key));
+    EXPECT_EQ(initial_value, prefs2->GetBoolean(key));
+
+    prefs2->SetBoolean(key, !initial_value);
+    EXPECT_EQ(initial_value, prefs1->GetBoolean(key));
+    EXPECT_EQ(!initial_value, prefs2->GetBoolean(key));
+
+    prefs1->SetBoolean(key, !initial_value);
+    EXPECT_EQ(!initial_value, prefs1->GetBoolean(key));
+    EXPECT_EQ(!initial_value, prefs2->GetBoolean(key));
+  }
+
+  void TestIntegerPreference(const char* key) {
+    PrefService* prefs1 =
+        contents_wrapper()->prefs_tab_helper()->per_tab_prefs();
+    PrefService* prefs2 =
+        contents_wrapper2()->prefs_tab_helper()->per_tab_prefs();
+    const int initial_value = prefs1->GetInteger(key);
+    EXPECT_EQ(initial_value, prefs2->GetInteger(key));
+
+    const int modified_value = initial_value + 1;
+    prefs1->SetInteger(key, modified_value);
+    EXPECT_EQ(modified_value, prefs1->GetInteger(key));
+    EXPECT_EQ(initial_value, prefs2->GetInteger(key));
+
+    prefs1->SetInteger(key, initial_value);
+    EXPECT_EQ(initial_value, prefs1->GetInteger(key));
+    EXPECT_EQ(initial_value, prefs2->GetInteger(key));
+
+    prefs2->SetInteger(key, modified_value);
+    EXPECT_EQ(initial_value, prefs1->GetInteger(key));
+    EXPECT_EQ(modified_value, prefs2->GetInteger(key));
+
+    prefs1->SetInteger(key, modified_value);
+    EXPECT_EQ(modified_value, prefs1->GetInteger(key));
+    EXPECT_EQ(modified_value, prefs2->GetInteger(key));
+  }
+
+  void TestStringPreference(const char* key) {
+    PrefService* prefs1 =
+        contents_wrapper()->prefs_tab_helper()->per_tab_prefs();
+    PrefService* prefs2 =
+        contents_wrapper2()->prefs_tab_helper()->per_tab_prefs();
+    const std::string initial_value = prefs1->GetString(key);
+    EXPECT_EQ(initial_value, prefs2->GetString(key));
+
+    const std::string modified_value = initial_value + "_";
+    prefs1->SetString(key, modified_value);
+    EXPECT_EQ(modified_value, prefs1->GetString(key));
+    EXPECT_EQ(initial_value, prefs2->GetString(key));
+
+    prefs1->SetString(key, initial_value);
+    EXPECT_EQ(initial_value, prefs1->GetString(key));
+    EXPECT_EQ(initial_value, prefs2->GetString(key));
+
+    prefs2->SetString(key, modified_value);
+    EXPECT_EQ(initial_value, prefs1->GetString(key));
+    EXPECT_EQ(modified_value, prefs2->GetString(key));
+
+    prefs1->SetString(key, modified_value);
+    EXPECT_EQ(modified_value, prefs1->GetString(key));
+    EXPECT_EQ(modified_value, prefs2->GetString(key));
+  }
+
  protected:
   virtual void SetUp() OVERRIDE {
     TabContentsWrapperTestHarness::SetUp();
@@ -73,30 +157,77 @@ class PrefsTabHelperTest : public TabContentsWrapperTestHarness {
 };
 
 TEST_F(PrefsTabHelperTest, PerTabJavaScriptEnabled) {
-  const char* key = prefs::kWebKitJavascriptEnabled;
-  PrefService* prefs1 = contents_wrapper()->prefs_tab_helper()->per_tab_prefs();
-  PrefService* prefs2 =
-      contents_wrapper2()->prefs_tab_helper()->per_tab_prefs();
-  const bool initial_value = prefs1->GetBoolean(key);
-  EXPECT_EQ(initial_value, prefs2->GetBoolean(key));
+  TestBooleanPreference(prefs::kWebKitJavascriptEnabled);
+}
 
-  prefs1->SetBoolean(key, !initial_value);
-  EXPECT_EQ(!initial_value, prefs1->GetBoolean(key));
-  EXPECT_EQ(initial_value, prefs2->GetBoolean(key));
+TEST_F(PrefsTabHelperTest, PerTabJavascriptCanOpenWindowsAutomatically) {
+  TestBooleanPreference(prefs::kWebKitJavascriptCanOpenWindowsAutomatically);
+}
 
-  prefs1->SetBoolean(key, initial_value);
-  EXPECT_EQ(initial_value, prefs1->GetBoolean(key));
-  EXPECT_EQ(initial_value, prefs2->GetBoolean(key));
+TEST_F(PrefsTabHelperTest, PerTabLoadsImagesAutomatically) {
+  TestBooleanPreference(prefs::kWebKitLoadsImagesAutomatically);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabPluginsEnabled) {
+  TestBooleanPreference(prefs::kWebKitPluginsEnabled);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabDefaultFontSize) {
+  TestIntegerPreference(prefs::kWebKitDefaultFontSize);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabDefaultFixedFontSize) {
+  TestIntegerPreference(prefs::kWebKitDefaultFixedFontSize);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabMinimumFontSize) {
+  TestIntegerPreference(prefs::kWebKitMinimumFontSize);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabMinimumLogicalFontSize) {
+  TestIntegerPreference(prefs::kWebKitMinimumLogicalFontSize);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabDefaultCharset) {
+  TestStringPreference(prefs::kDefaultCharset);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabDefaultCharsetUpdate) {
+  TestPrefsTabHelper* test_prefs_helper = CreateTestPrefsTabHelper();
+  EXPECT_FALSE(test_prefs_helper->was_update_web_preferences_called());
+  const char* pref = prefs::kDefaultCharset;
+  PrefService* prefs =
+      contents_wrapper()->prefs_tab_helper()->per_tab_prefs();
+  prefs->SetString(pref, prefs->GetString(pref) + "_");
+  EXPECT_TRUE(test_prefs_helper->was_update_web_preferences_called());
+}
+
+TEST_F(PrefsTabHelperTest, PerTabStandardFontFamily) {
+  TestStringPreference(prefs::kWebKitStandardFontFamily);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabFixedFontFamily) {
+  TestStringPreference(prefs::kWebKitFixedFontFamily);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabSerifFontFamily) {
+  TestStringPreference(prefs::kWebKitSerifFontFamily);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabSansSerifFontFamily) {
+  TestStringPreference(prefs::kWebKitSansSerifFontFamily);
+}
+
+TEST_F(PrefsTabHelperTest, PerTabCursiveFontFamily) {
+  TestStringPreference(prefs::kWebKitCursiveFontFamily);
+}
 
-  prefs2->SetBoolean(key, !initial_value);
-  EXPECT_EQ(initial_value, prefs1->GetBoolean(key));
-  EXPECT_EQ(!initial_value, prefs2->GetBoolean(key));
+TEST_F(PrefsTabHelperTest, PerTabFantasyFontFamily) {
+  TestStringPreference(prefs::kWebKitFantasyFontFamily);
 }
 
 TEST_F(PrefsTabHelperTest, OverridePrefsOnViewCreation) {
-  TestPrefsTabHelper* test_prefs_helper =
-      new TestPrefsTabHelper(contents_wrapper()->tab_contents());
-  contents_wrapper()->prefs_tab_helper_.reset(test_prefs_helper);
+  TestPrefsTabHelper* test_prefs_helper = CreateTestPrefsTabHelper();
   EXPECT_FALSE(test_prefs_helper->was_update_web_preferences_called());
   test_prefs_helper->NotifyRenderViewCreated();
   EXPECT_TRUE(test_prefs_helper->was_update_web_preferences_called());
diff --git a/chrome/browser/ui/tab_contents/tab_contents_wrapper.h b/chrome/browser/ui/tab_contents/tab_contents_wrapper.h
index 4499647..a4b3a6c 100644
--- a/chrome/browser/ui/tab_contents/tab_contents_wrapper.h
+++ b/chrome/browser/ui/tab_contents/tab_contents_wrapper.h
@@ -191,8 +191,7 @@ class TabContentsWrapper : public content::WebContentsObserver {
   virtual void WebContentsDestroyed(content::WebContents* tab) OVERRIDE;
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(
-      PrefsTabHelperTest, OverridePrefsOnViewCreation);
+  friend class PrefsTabHelperTest;
 
   // Used to retrieve this object from |tab_contents_|, which is placed in
   // its property bag to avoid adding additional interfaces.
diff --git a/chrome/browser/ui/toolbar/encoding_menu_controller.cc b/chrome/browser/ui/toolbar/encoding_menu_controller.cc
index d28a437..9230618 100644
--- a/chrome/browser/ui/toolbar/encoding_menu_controller.cc
+++ b/chrome/browser/ui/toolbar/encoding_menu_controller.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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.
 
@@ -85,8 +85,10 @@ bool EncodingMenuController::IsItemChecked(
     return false;
 
   std::string encoding = current_tab_encoding;
-  if (encoding.empty())
-    encoding = browser_profile->GetPrefs()->GetString(prefs::kDefaultCharset);
+  if (encoding.empty()) {
+    encoding =
+        browser_profile->GetPrefs()->GetString(prefs::kGlobalDefaultCharset);
+  }
 
   if (item_id == IDC_ENCODING_AUTO_DETECT) {
     return browser_profile->GetPrefs()->GetBoolean(
diff --git a/chrome/browser/ui/webui/options/advanced_options_handler.cc b/chrome/browser/ui/webui/options/advanced_options_handler.cc
index 5e5f330..c443a18 100644
--- a/chrome/browser/ui/webui/options/advanced_options_handler.cc
+++ b/chrome/browser/ui/webui/options/advanced_options_handler.cc
@@ -270,7 +270,7 @@ WebUIMessageHandler* AdvancedOptionsHandler::Attach(WebUI* web_ui) {
 #endif
 
   auto_open_files_.Init(prefs::kDownloadExtensionsToOpen, prefs, this);
-  default_font_size_.Init(prefs::kWebKitDefaultFontSize, prefs, this);
+  default_font_size_.Init(prefs::kWebKitGlobalDefaultFontSize, prefs, this);
   default_zoom_level_.Init(prefs::kDefaultZoomLevel, prefs, this);
 #if !defined(OS_CHROMEOS)
   proxy_prefs_.reset(
@@ -350,7 +350,7 @@ void AdvancedOptionsHandler::Observe(
       if (cloud_print_connector_ui_enabled_)
         SetupCloudPrintConnectorSection();
 #endif
-    } else if (*pref_name == prefs::kWebKitDefaultFontSize) {
+    } else if (*pref_name == prefs::kWebKitGlobalDefaultFontSize) {
       SetupFontSizeSelector();
     } else if (*pref_name == prefs::kDefaultZoomLevel) {
       SetupPageZoomSelector();
diff --git a/chrome/browser/ui/webui/options/font_settings_handler.cc b/chrome/browser/ui/webui/options/font_settings_handler.cc
index f319244..ef2ae12 100644
--- a/chrome/browser/ui/webui/options/font_settings_handler.cc
+++ b/chrome/browser/ui/webui/options/font_settings_handler.cc
@@ -83,15 +83,19 @@ WebUIMessageHandler* FontSettingsHandler::Attach(WebUI* web_ui) {
   FontSettingsUtilities::ValidateSavedFonts(pref_service);
 
   // Register for preferences that we need to observe manually.
-  standard_font_.Init(prefs::kWebKitStandardFontFamily, pref_service, this);
-  serif_font_.Init(prefs::kWebKitSerifFontFamily, pref_service, this);
-  sans_serif_font_.Init(prefs::kWebKitSansSerifFontFamily, pref_service, this);
-  fixed_font_.Init(prefs::kWebKitFixedFontFamily, pref_service, this);
-  font_encoding_.Init(prefs::kDefaultCharset, pref_service, this);
-  default_font_size_.Init(prefs::kWebKitDefaultFontSize, pref_service, this);
-  default_fixed_font_size_.Init(prefs::kWebKitDefaultFixedFontSize,
+  standard_font_.Init(prefs::kWebKitGlobalStandardFontFamily,
+                      pref_service, this);
+  serif_font_.Init(prefs::kWebKitGlobalSerifFontFamily, pref_service, this);
+  sans_serif_font_.Init(prefs::kWebKitGlobalSansSerifFontFamily,
+                        pref_service, this);
+  fixed_font_.Init(prefs::kWebKitGlobalFixedFontFamily, pref_service, this);
+  font_encoding_.Init(prefs::kGlobalDefaultCharset, pref_service, this);
+  default_font_size_.Init(prefs::kWebKitGlobalDefaultFontSize,
+                          pref_service, this);
+  default_fixed_font_size_.Init(prefs::kWebKitGlobalDefaultFixedFontSize,
                                 pref_service, this);
-  minimum_font_size_.Init(prefs::kWebKitMinimumFontSize, pref_service, this);
+  minimum_font_size_.Init(prefs::kWebKitGlobalMinimumFontSize,
+                          pref_service, this);
 
   // Return result from the superclass.
   return handler;
@@ -157,20 +161,20 @@ void FontSettingsHandler::Observe(int type,
                                   const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_PREF_CHANGED) {
     std::string* pref_name = content::Details<std::string>(details).ptr();
-    if (*pref_name == prefs::kWebKitStandardFontFamily) {
+    if (*pref_name == prefs::kWebKitGlobalStandardFontFamily) {
       SetUpStandardFontSample();
-    } else if (*pref_name == prefs::kWebKitSerifFontFamily) {
+    } else if (*pref_name == prefs::kWebKitGlobalSerifFontFamily) {
       SetUpSerifFontSample();
-    } else if (*pref_name == prefs::kWebKitSansSerifFontFamily) {
+    } else if (*pref_name == prefs::kWebKitGlobalSansSerifFontFamily) {
       SetUpSansSerifFontSample();
-    } else if (*pref_name == prefs::kWebKitFixedFontFamily ||
-               *pref_name == prefs::kWebKitDefaultFixedFontSize) {
+    } else if (*pref_name == prefs::kWebKitGlobalFixedFontFamily ||
+               *pref_name == prefs::kWebKitGlobalDefaultFixedFontSize) {
       SetUpFixedFontSample();
-    } else if (*pref_name == prefs::kWebKitDefaultFontSize) {
+    } else if (*pref_name == prefs::kWebKitGlobalDefaultFontSize) {
       SetUpStandardFontSample();
       SetUpSerifFontSample();
       SetUpSansSerifFontSample();
-    } else if (*pref_name == prefs::kWebKitMinimumFontSize) {
+    } else if (*pref_name == prefs::kWebKitGlobalMinimumFontSize) {
       SetUpMinimumFontSample();
     }
   }
diff --git a/chrome/browser/ui/webui/options/font_settings_utils_mac.mm b/chrome/browser/ui/webui/options/font_settings_utils_mac.mm
index a7079bb..1e413df 100644
--- a/chrome/browser/ui/webui/options/font_settings_utils_mac.mm
+++ b/chrome/browser/ui/webui/options/font_settings_utils_mac.mm
@@ -32,7 +32,7 @@ static void ValidateFontFamily(PrefService* prefs,
 
 // static
 void FontSettingsUtilities::ValidateSavedFonts(PrefService* prefs) {
-  ValidateFontFamily(prefs, prefs::kWebKitSerifFontFamily);
-  ValidateFontFamily(prefs, prefs::kWebKitSansSerifFontFamily);
-  ValidateFontFamily(prefs, prefs::kWebKitFixedFontFamily);
+  ValidateFontFamily(prefs, prefs::kWebKitGlobalSerifFontFamily);
+  ValidateFontFamily(prefs, prefs::kWebKitGlobalSansSerifFontFamily);
+  ValidateFontFamily(prefs, prefs::kWebKitGlobalFixedFontFamily);
 }