Remove base::StringValue

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 235 matching lines @@
 
 TEST_P(ConfigurationPolicyProviderTest, Empty) {
   provider_->RefreshPolicies();
   base::RunLoop().RunUntilIdle();
   const PolicyBundle kEmptyBundle;
   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, StringValue) {
   const char kTestString[] = "string_value";
-  base::StringValue expected_value(kTestString);
+  base::Value expected_value(kTestString);
   CheckValue(test_keys::kKeyString,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringPolicy,
                         base::Unretained(test_harness_.get()),
                         test_keys::kKeyString,
                         kTestString));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, BooleanValue) {
   base::Value expected_value(true);
@@ skipping 10 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, new base::StringValue("first"));
-  expected_value.Set(1U, new base::StringValue("second"));
+  expected_value.Set(0U, new base::Value("first"));
+  expected_value.Set(1U, new base::Value("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, new base::StringValue("first"));
-  list->Set(1U, new base::StringValue("second"));
+  list->Set(0U, new base::Value("first"));
+  list->Set(1U, new base::Value("second"));
   expected_value.Set("array", list);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("sub", "value");
   list = new base::ListValue();
   std::unique_ptr<base::DictionaryValue> sub(new base::DictionaryValue());
   sub->SetInteger("aaa", 111);
   sub->SetInteger("bbb", 222);
   list->Append(std::move(sub));
   sub.reset(new base::DictionaryValue());
@@ skipping 28 matching lines @@
   // OnUpdatePolicy is called when there are changes.
   test_harness_->InstallStringPolicy(test_keys::kKeyString, "value");
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(test_keys::kKeyString, test_harness_->policy_level(),
            test_harness_->policy_scope(), test_harness_->policy_source(),
-           base::MakeUnique<base::StringValue>("value"), nullptr);
+           base::MakeUnique<base::Value>("value"), nullptr);
   EXPECT_TRUE(provider_->policies().Equals(bundle));
   provider_->RemoveObserver(&observer);
 }
 
 Configuration3rdPartyPolicyProviderTest::
     Configuration3rdPartyPolicyProviderTest() {}
 
 Configuration3rdPartyPolicyProviderTest::
     ~Configuration3rdPartyPolicyProviderTest() {}
 
@@ skipping 20 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",
-                      new base::StringValue("invalid-value"));
+                      new base::Value("invalid-value"));
   test_harness_->Install3rdPartyPolicy(&policy_3rdparty);
 
   provider_->RefreshPolicies();
   base::RunLoop().RunUntilIdle();
 
   PolicyMap expected_policy;
   expected_policy.Set(test_keys::kKeyDictionary, test_harness_->policy_level(),
                       test_harness_->policy_scope(),
                       test_harness_->policy_source(),
                       policy_dict.CreateDeepCopy(), nullptr);
   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(),
                            test_harness_->policy_source());
   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