Get rid of the rest of CreateStringValue

components/policy/core/common/configuration_policy_provider_test.cc

 // Copyright 2013 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 "components/policy/core/common/configuration_policy_provider_test.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/values.h"
@@ skipping 254 matching lines @@
   CheckValue(test_keys::kKeyInteger,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallIntegerPolicy,
                         base::Unretained(test_harness_.get()),
                         test_keys::kKeyInteger,
                         42));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, StringListValue) {
   base::ListValue expected_value;
-  expected_value.Set(0U, base::Value::CreateStringValue("first"));
-  expected_value.Set(1U, base::Value::CreateStringValue("second"));
+  expected_value.Set(0U, new base::StringValue("first"));
+  expected_value.Set(1U, new base::StringValue("second"));
   CheckValue(test_keys::kKeyStringList,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringListPolicy,
                         base::Unretained(test_harness_.get()),
                         test_keys::kKeyStringList,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, DictionaryValue) {
   base::DictionaryValue expected_value;
   expected_value.SetBoolean("bool", true);
   expected_value.SetDouble("double", 123.456);
   expected_value.SetInteger("int", 123);
   expected_value.SetString("string", "omg");
 
   base::ListValue* list = new base::ListValue();
-  list->Set(0U, base::Value::CreateStringValue("first"));
-  list->Set(1U, base::Value::CreateStringValue("second"));
+  list->Set(0U, new base::StringValue("first"));
+  list->Set(1U, new base::StringValue("second"));
   expected_value.Set("array", list);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("sub", "value");
   list = new base::ListValue();
   base::DictionaryValue* sub = new base::DictionaryValue();
   sub->SetInteger("aaa", 111);
   sub->SetInteger("bbb", 222);
   list->Append(sub);
   sub = new base::DictionaryValue();
@@ skipping 29 matching lines @@
   test_harness_->InstallStringPolicy(test_keys::kKeyString, "value");
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(test_keys::kKeyString,
            test_harness_->policy_level(),
            test_harness_->policy_scope(),
-           base::Value::CreateStringValue("value"),
+           new base::StringValue("value"),
            NULL);
   EXPECT_TRUE(provider_->policies().Equals(bundle));
   provider_->RemoveObserver(&observer);
 }
 
 Configuration3rdPartyPolicyProviderTest::
     Configuration3rdPartyPolicyProviderTest() {}
 
 Configuration3rdPartyPolicyProviderTest::
     ~Configuration3rdPartyPolicyProviderTest() {}
@@ skipping 21 matching lines @@
   // Install them as 3rd party policies too.
   base::DictionaryValue policy_3rdparty;
   policy_3rdparty.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                       policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
                       policy_dict.DeepCopy());
   // Install invalid 3rd party policies that shouldn't be loaded. These also
   // help detecting memory leaks in the code paths that detect invalid input.
   policy_3rdparty.Set("invalid-domain.component", policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.cccccccccccccccccccccccccccccccc",
-                      base::Value::CreateStringValue("invalid-value"));
+                      new base::StringValue("invalid-value"));
   test_harness_->Install3rdPartyPolicy(&policy_3rdparty);
 
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
 
   PolicyMap expected_policy;
   expected_policy.Set(test_keys::kKeyDictionary,
                       test_harness_->policy_level(),
                       test_harness_->policy_scope(),
                       policy_dict.DeepCopy(),
                       NULL);
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(expected_policy);
   expected_policy.Clear();
   expected_policy.LoadFrom(&policy_dict,
                            test_harness_->policy_level(),
                            test_harness_->policy_scope());
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .CopyFrom(expected_policy);
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .CopyFrom(expected_policy);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy