src/chrome/browser/prefs/chrome_pref_service_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/command_line.h"
   6 #include "base/file_util.h"
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/path_service.h"
  10 #include "base/prefs/pref_registry_simple.h"
  11 #include "base/prefs/scoped_user_pref_update.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/policy/configuration_policy_pref_store.h"
  15 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
  16 #include "chrome/browser/prefs/browser_prefs.h"
  17 #include "chrome/browser/prefs/command_line_pref_store.h"
  18 #include "chrome/browser/prefs/pref_service_mock_builder.h"
  19 #include "chrome/common/chrome_paths.h"
  20 #include "chrome/common/chrome_switches.h"
  21 #include "chrome/common/pref_names.h"
  22 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  23 #include "chrome/test/base/testing_pref_service_syncable.h"
  24 #include "chrome/test/base/testing_profile.h"
  25 #include "components/user_prefs/pref_registry_syncable.h"
  26 #include "content/public/test/web_contents_tester.h"
  27 #include "ui/base/test/data/resource.h"
  28 #include "webkit/common/webpreferences.h"
  29
  30 using content::WebContentsTester;
  31
  32 TEST(ChromePrefServiceTest, UpdateCommandLinePrefStore) {
  33   TestingPrefServiceSimple prefs;
  34   prefs.registry()->RegisterBooleanPref(prefs::kCloudPrintProxyEnabled, false);
  35
  36   // Check to make sure the value is as expected.
  37   const PrefService::Preference* pref =
  38       prefs.FindPreference(prefs::kCloudPrintProxyEnabled);
  39   ASSERT_TRUE(pref);
  40   const Value* value = pref->GetValue();
  41   ASSERT_TRUE(value);
  42   EXPECT_EQ(Value::TYPE_BOOLEAN, value->GetType());
  43   bool actual_bool_value = true;
  44   EXPECT_TRUE(value->GetAsBoolean(&actual_bool_value));
  45   EXPECT_FALSE(actual_bool_value);
  46
  47   // Change the command line.
  48   CommandLine cmd_line(CommandLine::NO_PROGRAM);
  49   cmd_line.AppendSwitch(switches::kEnableCloudPrintProxy);
  50
  51   // Call UpdateCommandLinePrefStore and check to see if the value has changed.
  52   prefs.UpdateCommandLinePrefStore(new CommandLinePrefStore(&cmd_line));
  53   pref = prefs.FindPreference(prefs::kCloudPrintProxyEnabled);
  54   ASSERT_TRUE(pref);
  55   value = pref->GetValue();
  56   ASSERT_TRUE(value);
  57   EXPECT_EQ(Value::TYPE_BOOLEAN, value->GetType());
  58   actual_bool_value = false;
  59   EXPECT_TRUE(value->GetAsBoolean(&actual_bool_value));
  60   EXPECT_TRUE(actual_bool_value);
  61 }
  62
  63 class ChromePrefServiceUserFilePrefsTest : public testing::Test {
  64  protected:
  65   virtual void SetUp() {
  66     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  67
  68     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &data_dir_));
  69     data_dir_ = data_dir_.AppendASCII("pref_service");
  70     ASSERT_TRUE(base::PathExists(data_dir_));
  71   }
  72
  73   void ClearListValue(PrefService* prefs, const char* key) {
  74     ListPrefUpdate updater(prefs, key);
  75     updater->Clear();
  76   }
  77
  78   void ClearDictionaryValue(PrefService* prefs, const char* key) {
  79     DictionaryPrefUpdate updater(prefs, key);
  80     updater->Clear();
  81   }
  82
  83   // The path to temporary directory used to contain the test operations.
  84   base::ScopedTempDir temp_dir_;
  85   // The path to the directory where the test data is stored.
  86   base::FilePath data_dir_;
  87   // A message loop that we can use as the file thread message loop.
  88   base::MessageLoop message_loop_;
  89 };
  90
  91 // Verifies that ListValue and DictionaryValue pref with non emtpy default
  92 // preserves its empty value.
  93 TEST_F(ChromePrefServiceUserFilePrefsTest, PreserveEmptyValue) {
  94   base::FilePath pref_file = temp_dir_.path().AppendASCII("write.json");
  95
  96   ASSERT_TRUE(base::CopyFile(
  97       data_dir_.AppendASCII("read.need_empty_value.json"),
  98       pref_file));
  99
 100   PrefServiceMockBuilder builder;
 101   builder.WithUserFilePrefs(pref_file,
 102                             message_loop_.message_loop_proxy().get());
 103   scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
 104       new user_prefs::PrefRegistrySyncable);
 105   scoped_ptr<PrefServiceSyncable> prefs(builder.CreateSyncable(registry.get()));
 106
 107   // Register testing prefs.
 108   registry->RegisterListPref("list",
 109                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 110   registry->RegisterDictionaryPref(
 111       "dict",
 112       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 113
 114   base::ListValue* non_empty_list = new base::ListValue;
 115   non_empty_list->Append(base::Value::CreateStringValue("test"));
 116   registry->RegisterListPref("list_needs_empty_value",
 117                              non_empty_list,
 118                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 119
 120   base::DictionaryValue* non_empty_dict = new base::DictionaryValue;
 121   non_empty_dict->SetString("dummy", "whatever");
 122   registry->RegisterDictionaryPref(
 123       "dict_needs_empty_value",
 124       non_empty_dict,
 125       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 126
 127   // Set all testing prefs to empty.
 128   ClearListValue(prefs.get(), "list");
 129   ClearListValue(prefs.get(), "list_needs_empty_value");
 130   ClearDictionaryValue(prefs.get(), "dict");
 131   ClearDictionaryValue(prefs.get(), "dict_needs_empty_value");
 132
 133   // Write to file.
 134   prefs->CommitPendingWrite();
 135   message_loop_.RunUntilIdle();
 136
 137   // Compare to expected output.
 138   base::FilePath golden_output_file =
 139       data_dir_.AppendASCII("write.golden.need_empty_value.json");
 140   ASSERT_TRUE(base::PathExists(golden_output_file));
 141   EXPECT_TRUE(base::TextContentsEqual(golden_output_file, pref_file));
 142 }
 143
 144 class ChromePrefServiceWebKitPrefs : public ChromeRenderViewHostTestHarness {
 145  protected:
 146   virtual void SetUp() {
 147     ChromeRenderViewHostTestHarness::SetUp();
 148
 149     // Supply our own profile so we use the correct profile data. The test
 150     // harness is not supposed to overwrite a profile if it's already created.
 151
 152     // Set some (WebKit) user preferences.
 153     TestingPrefServiceSyncable* pref_services =
 154         profile()->GetTestingPrefService();
 155 #if defined(TOOLKIT_GTK)
 156     pref_services->SetUserPref(prefs::kUsesSystemTheme,
 157                                Value::CreateBooleanValue(false));
 158 #endif
 159     pref_services->SetUserPref(prefs::kDefaultCharset,
 160                                Value::CreateStringValue("utf8"));
 161     pref_services->SetUserPref(prefs::kWebKitDefaultFontSize,
 162                                Value::CreateIntegerValue(20));
 163     pref_services->SetUserPref(prefs::kWebKitTextAreasAreResizable,
 164                                Value::CreateBooleanValue(false));
 165     pref_services->SetUserPref(prefs::kWebKitUsesUniversalDetector,
 166                                Value::CreateBooleanValue(true));
 167     pref_services->SetUserPref("webkit.webprefs.foo",
 168                                Value::CreateStringValue("bar"));
 169   }
 170 };
 171
 172 // Tests to see that webkit preferences are properly loaded and copied over
 173 // to a WebPreferences object.
 174 TEST_F(ChromePrefServiceWebKitPrefs, PrefsCopied) {
 175   WebPreferences webkit_prefs =
 176       WebContentsTester::For(web_contents())->TestGetWebkitPrefs();
 177
 178   // These values have been overridden by the profile preferences.
 179   EXPECT_EQ("UTF-8", webkit_prefs.default_encoding);
 180   EXPECT_EQ(20, webkit_prefs.default_font_size);
 181   EXPECT_FALSE(webkit_prefs.text_areas_are_resizable);
 182   EXPECT_TRUE(webkit_prefs.uses_universal_detector);
 183
 184   // These should still be the default values.
 185 #if defined(OS_MACOSX)
 186   const char kDefaultFont[] = "Times";
 187 #elif defined(OS_CHROMEOS)
 188   const char kDefaultFont[] = "Tinos";
 189 #else
 190   const char kDefaultFont[] = "Times New Roman";
 191 #endif
 192   EXPECT_EQ(ASCIIToUTF16(kDefaultFont),
 193             webkit_prefs.standard_font_family_map[prefs::kWebKitCommonScript]);
 194   EXPECT_TRUE(webkit_prefs.javascript_enabled);
 195 }