more changes

chrome/browser/policy/configuration_policy_pref_store_unittest.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/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
@@ skipping 40 matching lines @@
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
   ListValue* in_value = new ListValue();
-  in_value->Append(Value::CreateStringValue("test1"));
-  in_value->Append(Value::CreateStringValue("test2,"));
+  in_value->Append(base::StringValue::New("test1"));
+  in_value->Append(base::StringValue::New("test2,"));
   provider_.AddPolicy(GetParam().type(), in_value);
   store_->OnUpdatePolicy();
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(in_value->Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ skipping 21 matching lines @@
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
   provider_.AddPolicy(GetParam().type(),
-                      Value::CreateStringValue("http://chromium.org"));
+                      base::StringValue::New("http://chromium.org"));
   store_->OnUpdatePolicy();
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   EXPECT_TRUE(StringValue("http://chromium.org").Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
@@ skipping 29 matching lines @@
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
-  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(false));
+  provider_.AddPolicy(GetParam().type(), base::FalseValue());
   store_->OnUpdatePolicy();
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   ASSERT_TRUE(value);
   bool boolean_value = true;
   bool result = value->GetAsBoolean(&boolean_value);
   ASSERT_TRUE(result);
   EXPECT_FALSE(boolean_value);
 
-  provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(true));
+  provider_.AddPolicy(GetParam().type(), base::TrueValue());
   store_->OnUpdatePolicy();
   value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
   boolean_value = false;
   result = value->GetAsBoolean(&boolean_value);
   ASSERT_TRUE(result);
   EXPECT_TRUE(boolean_value);
 }
 
@@ skipping 78 matching lines @@
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
-  provider_.AddPolicy(GetParam().type(), Value::CreateIntegerValue(2));
+  provider_.AddPolicy(GetParam().type(), base::NumberValue::New(2));
   store_->OnUpdatePolicy();
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
-  EXPECT_TRUE(base::FundamentalValue(2).Equals(value));
+  EXPECT_TRUE(base::NumberValue(2).Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTestInstance,
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
         TypeAndName(kPolicyRestoreOnStartup,
                     prefs::kRestoreOnStartup),
         TypeAndName(kPolicyPolicyRefreshRate,
                     prefs::kUserPolicyRefreshRate),
@@ skipping 36 matching lines @@
     }
     ProxyPrefs::ProxyMode mode;
     ASSERT_TRUE(dict.GetMode(&mode));
     EXPECT_EQ(expected_proxy_mode, mode);
   }
 };
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyBypassList,
-                     Value::CreateStringValue("http://chromium.org/override"));
+                     base::StringValue::New("http://chromium.org/override"));
   provider.AddPolicy(kPolicyProxyServer,
-                     Value::CreateStringValue("chromium.org"));
+                     base::StringValue::New("chromium.org"));
   provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(
+                     base::NumberValue::New(
                          kPolicyManuallyConfiguredProxyServerMode));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(
       *store, "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(
+                     base::NumberValue::New(
                          kPolicyManuallyConfiguredProxyServerMode));
   provider.AddPolicy(kPolicyProxyBypassList,
-                     Value::CreateStringValue("http://chromium.org/override"));
+                     base::StringValue::New("http://chromium.org/override"));
   provider.AddPolicy(kPolicyProxyServer,
-                     Value::CreateStringValue("chromium.org"));
+                     base::StringValue::New("chromium.org"));
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(
       *store, "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsInvalid) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(
+                     base::NumberValue::New(
                          kPolicyManuallyConfiguredProxyServerMode));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store->GetValue(prefs::kProxy, &value));
 }
 
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyServerMode) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
+                     base::NumberValue::New(kPolicyNoProxyServerMode));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxyModeName) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kDirectProxyModeName));
+      base::StringValue::New(ProxyPrefs::kDirectProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyServerMode) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(
       kPolicyProxyServerMode,
-      Value::CreateIntegerValue(kPolicyAutoDetectProxyServerMode));
+      base::NumberValue::New(kPolicyAutoDetectProxyServerMode));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectProxyModeName) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
+      base::StringValue::New(ProxyPrefs::kAutoDetectProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyMode) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyPacUrl,
-                     Value::CreateStringValue("http://short.org/proxy.pac"));
+                     base::StringValue::New("http://short.org/proxy.pac"));
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
+      base::StringValue::New(ProxyPrefs::kPacScriptProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeInvalid) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
+      base::StringValue::New(ProxyPrefs::kPacScriptProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store->GetValue(prefs::kProxy, &value));
 }
 
 // Regression test for http://crbug.com/78016, CPanel returns empty strings
 // for unset properties.
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, PacScriptProxyModeBug78016) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyServer,
-                     Value::CreateStringValue(""));
+                     base::StringValue::New(""));
   provider.AddPolicy(kPolicyProxyPacUrl,
-                     Value::CreateStringValue("http://short.org/proxy.pac"));
+                     base::StringValue::New("http://short.org/proxy.pac"));
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kPacScriptProxyModeName));
+      base::StringValue::New(ProxyPrefs::kPacScriptProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "http://short.org/proxy.pac", "",
                    ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyServerMode) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(
       kPolicyProxyServerMode,
-      Value::CreateIntegerValue(kPolicyUseSystemProxyServerMode));
+      base::NumberValue::New(kPolicyUseSystemProxyServerMode));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystemProxyMode) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kSystemProxyModeName));
+      base::StringValue::New(ProxyPrefs::kSystemProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest,
        ProxyModeOverridesProxyServerMode) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyServerMode,
-                     Value::CreateIntegerValue(kPolicyNoProxyServerMode));
+                     base::NumberValue::New(kPolicyNoProxyServerMode));
   provider.AddPolicy(
       kPolicyProxyMode,
-      Value::CreateStringValue(ProxyPrefs::kAutoDetectProxyModeName));
+      base::StringValue::New(ProxyPrefs::kAutoDetectProxyModeName));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
   VerifyProxyPrefs(*store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
   for (int i = 0; i < MODE_COUNT; ++i) {
     MockConfigurationPolicyProvider provider;
-    provider.AddPolicy(kPolicyProxyServerMode, Value::CreateIntegerValue(i));
+    provider.AddPolicy(kPolicyProxyServerMode, base::NumberValue::New(i));
     // No mode expects all three parameters being set.
     provider.AddPolicy(kPolicyProxyPacUrl,
-                       Value::CreateStringValue("http://short.org/proxy.pac"));
+                       base::StringValue::New("http://short.org/proxy.pac"));
     provider.AddPolicy(kPolicyProxyBypassList,
-                       Value::CreateStringValue(
+                       base::StringValue::New(
                            "http://chromium.org/override"));
     provider.AddPolicy(kPolicyProxyServer,
-                       Value::CreateStringValue("chromium.org"));
+                       base::StringValue::New("chromium.org"));
 
     scoped_refptr<ConfigurationPolicyPrefStore> store(
         new ConfigurationPolicyPrefStore(&provider));
     const Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_NO_VALUE,
               store->GetValue(prefs::kProxy, &value));
   }
 }
 
 class ConfigurationPolicyPrefStoreDefaultSearchTest : public testing::Test {
 };
 
 // Checks that if the policy for default search is valid, i.e. there's a
 // search URL, that all the elements have been given proper defaults.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MinimallyDefined) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled, base::TrueValue());
   provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
-                     Value::CreateStringValue(search_url));
+                     base::StringValue::New(search_url));
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(StringValue(search_url).Equals(value));
 
   EXPECT_EQ(PrefStore::READ_OK,
@@ skipping 23 matching lines @@
 
 // Checks that for a fully defined search policy, all elements have been
 // read properly.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, FullyDefined) {
   const char* const search_url = "http://test.com/search?t={searchTerms}";
   const char* const suggest_url = "http://test.com/sugg?={searchTerms}";
   const char* const icon_url = "http://test.com/icon.jpg";
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   ListValue* encodings = new ListValue();
-  encodings->Append(Value::CreateStringValue("UTF-16"));
-  encodings->Append(Value::CreateStringValue("UTF-8"));
+  encodings->Append(base::StringValue::New("UTF-16"));
+  encodings->Append(base::StringValue::New("UTF-8"));
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled, base::TrueValue());
   provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
-                     Value::CreateStringValue(search_url));
+                     base::StringValue::New(search_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderName,
-                     Value::CreateStringValue(name));
+                     base::StringValue::New(name));
   provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
-                     Value::CreateStringValue(keyword));
+                     base::StringValue::New(keyword));
   provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
-                     Value::CreateStringValue(suggest_url));
+                     base::StringValue::New(suggest_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
-                     Value::CreateStringValue(icon_url));
+                     base::StringValue::New(icon_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderEncodings, encodings);
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, &value));
   EXPECT_TRUE(StringValue(search_url).Equals(value));
 
@@ skipping 19 matching lines @@
 }
 
 // Checks that if the default search policy is missing, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, MissingUrl) {
   const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
   const char* const icon_url = "http://test.com/icon.jpg";
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   ListValue* encodings = new ListValue();
-  encodings->Append(Value::CreateStringValue("UTF-16"));
-  encodings->Append(Value::CreateStringValue("UTF-8"));
+  encodings->Append(base::StringValue::New("UTF-16"));
+  encodings->Append(base::StringValue::New("UTF-8"));
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled, base::TrueValue());
   provider.AddPolicy(kPolicyDefaultSearchProviderName,
-                     Value::CreateStringValue(name));
+                     base::StringValue::New(name));
   provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
-                     Value::CreateStringValue(keyword));
+                     base::StringValue::New(keyword));
   provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
-                     Value::CreateStringValue(suggest_url));
+                     base::StringValue::New(suggest_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
-                     Value::CreateStringValue(icon_url));
+                     base::StringValue::New(icon_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderEncodings, encodings);
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderKeyword, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderSuggestURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderIconURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderEncodings, NULL));
 }
 
 // Checks that if the default search policy is invalid, that no elements of the
 // default search policy will be present.
 TEST_F(ConfigurationPolicyPrefStoreDefaultSearchTest, Invalid) {
   const char* const bad_search_url = "http://test.com/noSearchTerms";
   const char* const suggest_url = "http://test.com/sugg?t={searchTerms}";
   const char* const icon_url = "http://test.com/icon.jpg";
   const char* const name = "MyName";
   const char* const keyword = "MyKeyword";
   ListValue* encodings = new ListValue();
-  encodings->Append(Value::CreateStringValue("UTF-16"));
-  encodings->Append(Value::CreateStringValue("UTF-8"));
+  encodings->Append(base::StringValue::New("UTF-16"));
+  encodings->Append(base::StringValue::New("UTF-8"));
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled,
-                     Value::CreateBooleanValue(true));
+  provider.AddPolicy(kPolicyDefaultSearchProviderEnabled, base::TrueValue());
   provider.AddPolicy(kPolicyDefaultSearchProviderSearchURL,
-                     Value::CreateStringValue(bad_search_url));
+                     base::StringValue::New(bad_search_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderName,
-                     Value::CreateStringValue(name));
+                     base::StringValue::New(name));
   provider.AddPolicy(kPolicyDefaultSearchProviderKeyword,
-                     Value::CreateStringValue(keyword));
+                     base::StringValue::New(keyword));
   provider.AddPolicy(kPolicyDefaultSearchProviderSuggestURL,
-                     Value::CreateStringValue(suggest_url));
+                     base::StringValue::New(suggest_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderIconURL,
-                     Value::CreateStringValue(icon_url));
+                     base::StringValue::New(icon_url));
   provider.AddPolicy(kPolicyDefaultSearchProviderEncodings, encodings);
 
   scoped_refptr<ConfigurationPolicyPrefStore> store(
       new ConfigurationPolicyPrefStore(&provider));
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderSearchURL, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store->GetValue(prefs::kDefaultSearchProviderName, NULL));
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
@@ skipping 14 matching lines @@
   enum ObsoleteIncognitoEnabledValue {
     INCOGNITO_ENABLED_UNKNOWN,
     INCOGNITO_ENABLED_TRUE,
     INCOGNITO_ENABLED_FALSE
   };
 
   void SetPolicies(ObsoleteIncognitoEnabledValue incognito_enabled,
                    int availability) {
     if (incognito_enabled != INCOGNITO_ENABLED_UNKNOWN) {
       provider_.AddPolicy(kPolicyIncognitoEnabled,
-                          Value::CreateBooleanValue(
+                          base::BooleanValue::New(
                               incognito_enabled == INCOGNITO_ENABLED_TRUE));
     }
     if (availability >= 0) {
       provider_.AddPolicy(kPolicyIncognitoModeAvailability,
-                          Value::CreateIntegerValue(availability));
+                          base::NumberValue::New(availability));
     }
     store_ = new ConfigurationPolicyPrefStore(&provider_);
   }
 
   void VerifyValues(IncognitoModePrefs::Availability availability) {
     const Value* value = NULL;
     EXPECT_EQ(PrefStore::READ_OK,
               store_->GetValue(prefs::kIncognitoModeAvailability, &value));
-    EXPECT_TRUE(base::FundamentalValue(availability).Equals(value));
+    EXPECT_TRUE(base::NumberValue(availability).Equals(value));
   }
 
   MockConfigurationPolicyProvider provider_;
   scoped_refptr<ConfigurationPolicyPrefStore> store_;
 };
 
 // The following testcases verify that if the obsolete IncognitoEnabled
 // policy is not set, the IncognitoModeAvailability values should be copied
 // from IncognitoModeAvailability policy to pref "as is".
 TEST_F(ConfigurationPolicyPrefStoreIncognitoModeTest,
@@ skipping 53 matching lines @@
 class ConfigurationPolicyPrefStoreSyncTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
-  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(false));
+  provider_.AddPolicy(kPolicySyncDisabled, base::FalseValue());
   store_->OnUpdatePolicy();
   // Enabling Sync should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
-  provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(true));
+  provider_.AddPolicy(kPolicySyncDisabled, base::TrueValue());
   store_->OnUpdatePolicy();
   // Sync should be flagged as managed.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kSyncManaged, &value));
   ASSERT_TRUE(value);
   bool sync_managed = false;
   bool result = value->GetAsBoolean(&sync_managed);
   ASSERT_TRUE(result);
   EXPECT_TRUE(sync_managed);
 }
 
 // Test cases for how the DownloadDirectory and AllowFileSelectionDialogs policy
 // influence the PromptForDownload preference.
 class ConfigurationPolicyPrefStorePromptDownloadTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, SetDownloadDirectory) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddPolicy(kPolicyDownloadDirectory, Value::CreateStringValue(""));
+  provider_.AddPolicy(kPolicyDownloadDirectory, base::StringValue::New(""));
   store_->OnUpdatePolicy();
 
   // Setting a DownloadDirectory should disable the PromptForDownload pref.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kPromptForDownload,
                                                  &value));
   ASSERT_TRUE(value);
   bool prompt_for_download = true;
   bool result = value->GetAsBoolean(&prompt_for_download);
   ASSERT_TRUE(result);
   EXPECT_FALSE(prompt_for_download);
 }
 #endif  // !defined(OS_CHROMEOS)
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        EnableFileSelectionDialogs) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddPolicy(kPolicyAllowFileSelectionDialogs,
-                      Value::CreateBooleanValue(true));
+  provider_.AddPolicy(kPolicyAllowFileSelectionDialogs, base::TrueValue());
   store_->OnUpdatePolicy();
 
   // Allowing file-selection dialogs should not influence the PromptForDownload
   // pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
        DisableFileSelectionDialogs) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
-  provider_.AddPolicy(kPolicyAllowFileSelectionDialogs,
-                      Value::CreateBooleanValue(false));
+  provider_.AddPolicy(kPolicyAllowFileSelectionDialogs, base::FalseValue());
   store_->OnUpdatePolicy();
 
   // Disabling file-selection dialogs should disable the PromptForDownload pref.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kPromptForDownload,
                                                  &value));
   ASSERT_TRUE(value);
   bool prompt_for_download = true;
   bool result = value->GetAsBoolean(&prompt_for_download);
   ASSERT_TRUE(result);
   EXPECT_FALSE(prompt_for_download);
 }
 
 // Test cases for the Autofill policy setting.
 class ConfigurationPolicyPrefStoreAutofillTest
     : public ConfigurationPolicyPrefStoreTestBase<testing::Test> {
 };
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Default) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Enabled) {
-  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
+  provider_.AddPolicy(kPolicyAutoFillEnabled, base::TrueValue());
   store_->OnUpdatePolicy();
   // Enabling Autofill should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Disabled) {
-  provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
+  provider_.AddPolicy(kPolicyAutoFillEnabled, base::FalseValue());
   store_->OnUpdatePolicy();
   // Disabling Autofill should switch the pref to managed.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kAutofillEnabled, &value));
   ASSERT_TRUE(value);
   bool autofill_enabled = true;
   bool result = value->GetAsBoolean(&autofill_enabled);
   ASSERT_TRUE(result);
   EXPECT_FALSE(autofill_enabled);
@@ skipping 14 matching lines @@
   PrefStoreObserverMock observer_;
 };
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kHomePage, NULL));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
   provider_.AddPolicy(kPolicyHomepageLocation,
-                      Value::CreateStringValue("http://www.chromium.org"));
+                      base::StringValue::New("http://www.chromium.org"));
   store_->OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kHomePage, &value));
   EXPECT_TRUE(StringValue("http://www.chromium.org").Equals(value));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
   store_->OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
 
@@ skipping 12 matching lines @@
 
   provider_.SetInitializationComplete(true);
   EXPECT_FALSE(store_->IsInitializationComplete());
 
   store_->OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(store_->IsInitializationComplete());
 }
 
 }  // namespace policy