Add more per-tab preferences.

chrome/browser/ui/prefs/prefs_tab_helper_uitest.cc

+// 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/command_line.h"
+#include "base/file_util.h"
+#include "base/json/json_value_serializer.h"
+#include "base/scoped_temp_dir.h"
+#include "base/test/test_file_util.h"
+#include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/test/ui/ui_test.h"
+
+class PrefsTabHelperUITest : public UITest {

[Bernhard Bauer, 2011/12/21 16:41:32]

If you make this a browser test instead of a UI test, you can directly ask the
PrefService instead of having to go through the prefs file.

[mnaganov (inactive), 2011/12/21 18:43:33]

What I'm doing here is:

1. Copying a hand-crafted Preferences file from test data into temp profile dir.

2. Launching Chrome to migrate preferences. I need to terminate it to make sure
that the profile file is saved to disk.

3. Verifying that in the saved file preferences have been migrated.

I suppose this approach gives me more guarantees than just querying them from
PrefService. What do you think?

[Bernhard Bauer, 2011/12/22 15:09:01]

Does it? Assuming that serialization/deserialization works correctly (which we
have separate unit tests for), doesn't this test basically just verify that a
PrefService correctly migrates preferences (which you could also check
in-browser)?

I guess what I want to say is that in general I'm not a fan of UI tests ;-) That
being said, if you want to do a UI test in this case, I'm fine with it.

+ protected:
+  virtual void SetUp() {
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    FilePath tmp_profile = temp_dir_.path().AppendASCII("tmp_profile");
+
+    ASSERT_TRUE(file_util::CreateDirectory(tmp_profile));
+
+    FilePath non_global_pref_file;
+    non_global_pref_file = test_data_directory_
+        .AppendASCII("profiles")
+        .AppendASCII("webkit_global_migration")
+        .AppendASCII("Default")
+        .Append(chrome::kPreferencesFilename);
+    tmp_pref_file_ = tmp_profile.AppendASCII("Default");
+    ASSERT_TRUE(file_util::CreateDirectory(tmp_pref_file_));
+    tmp_pref_file_ = tmp_pref_file_.Append(chrome::kPreferencesFilename);
+
+    ASSERT_TRUE(file_util::PathExists(non_global_pref_file));
+    ASSERT_TRUE(file_util::CopyFile(non_global_pref_file, tmp_pref_file_));
+
+#if defined(OS_WIN)
+    // Make the copy writable.  On POSIX we assume the umask allows files
+    // we create to be writable.
+    ASSERT_TRUE(::SetFileAttributesW(tmp_pref_file_.value().c_str(),
+        FILE_ATTRIBUTE_NORMAL));
+#endif
+
+    launch_arguments_.AppendSwitchPath(switches::kUserDataDir, tmp_profile);
+    UITest::SetUp();
+  }
+
+  FilePath tmp_pref_file_;
+
+ private:
+  ScopedTempDir temp_dir_;
+};
+
+static int GetInteger(DictionaryValue* dict, const char* pref) {
+  int value = 0;
+  EXPECT_TRUE(dict->GetInteger(pref, &value));
+  return value;
+}
+
+static std::string GetString(DictionaryValue* dict, const char* pref) {
+  std::string value;
+  EXPECT_TRUE(dict->GetStringASCII(pref, &value));
+  return value;
+}
+
+TEST_F(PrefsTabHelperUITest, NonGlobalPrefsAreMigrated) {
+  QuitBrowser();
+
+  ASSERT_TRUE(file_util::PathExists(tmp_pref_file_));
+
+  JSONFileValueSerializer deserializer(tmp_pref_file_);
+  scoped_ptr<Value> root(deserializer.Deserialize(NULL, NULL));
+  ASSERT_TRUE(root.get());
+  ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
+  DictionaryValue* root_dict = static_cast<DictionaryValue*>(root.get());
+
+  EXPECT_FALSE(root_dict->HasKey(prefs::kDefaultCharset));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitDefaultFontSize));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitDefaultFixedFontSize));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitMinimumFontSize));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitMinimumLogicalFontSize));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitCursiveFontFamily));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitFantasyFontFamily));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitFixedFontFamily));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitSansSerifFontFamily));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitSerifFontFamily));
+  EXPECT_FALSE(root_dict->HasKey(prefs::kWebKitStandardFontFamily));
+
+  EXPECT_EQ("ISO-8859-1", GetString(root_dict, prefs::kGlobalDefaultCharset));
+  EXPECT_EQ(42, GetInteger(root_dict, prefs::kWebKitGlobalDefaultFontSize));
+  EXPECT_EQ(42,
+            GetInteger(root_dict, prefs::kWebKitGlobalDefaultFixedFontSize));
+  EXPECT_EQ(42, GetInteger(root_dict, prefs::kWebKitGlobalMinimumFontSize));
+  EXPECT_EQ(42,
+            GetInteger(root_dict, prefs::kWebKitGlobalMinimumLogicalFontSize));
+  EXPECT_EQ("CursiveFontFamily",
+            GetString(root_dict, prefs::kWebKitGlobalCursiveFontFamily));
+  EXPECT_EQ("FantasyFontFamily",
+            GetString(root_dict, prefs::kWebKitGlobalFantasyFontFamily));
+  EXPECT_EQ("FixedFontFamily",
+            GetString(root_dict, prefs::kWebKitGlobalFixedFontFamily));
+  EXPECT_EQ("SansSerifFontFamily",
+            GetString(root_dict, prefs::kWebKitGlobalSansSerifFontFamily));
+  EXPECT_EQ("SerifFontFamily",
+            GetString(root_dict, prefs::kWebKitGlobalSerifFontFamily));
+  EXPECT_EQ("StandardFontFamily",
+            GetString(root_dict, prefs::kWebKitGlobalStandardFontFamily));
+}