Remove base::StringValue

chrome/browser/chromeos/settings/device_settings_provider_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/settings/device_settings_provider.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 173 matching lines @@
         device_policy_.payload().mutable_login_screen_domain_auto_complete();
     proto->set_login_screen_domain_auto_complete(domain);
     device_policy_.Build();
     device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
     ReloadDeviceSettings();
     Mock::VerifyAndClearExpectations(this);
   }
 
   // Helper routine to check value of the LoginScreenDomainAutoComplete policy.
   void VerifyDomainAutoComplete(
-      const base::StringValue* const ptr_to_expected_value) {
+      const base::Value* const ptr_to_expected_value) {
     EXPECT_TRUE(base::Value::Equals(
         provider_->Get(kAccountsPrefLoginScreenDomainAutoComplete),
         ptr_to_expected_value));
   }
 
   ScopedTestingLocalState local_state_;
 
   std::unique_ptr<DeviceSettingsProvider> provider_;
 
   base::ScopedPathOverride user_data_dir_override_;
@@ skipping 29 matching lines @@
             provider_->PrepareTrustedValues(base::Closure()));
   const base::Value* value = provider_->Get(kReleaseChannel);
   ASSERT_TRUE(value);
   std::string string_value;
   EXPECT_TRUE(value->GetAsString(&string_value));
   EXPECT_TRUE(string_value.empty());
 
   // Sets should succeed though and be readable from the cache.
   EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*this, SettingChanged(kReleaseChannel)).Times(1);
-  base::StringValue new_value("stable-channel");
+  base::Value new_value("stable-channel");
   provider_->Set(kReleaseChannel, new_value);
   Mock::VerifyAndClearExpectations(this);
 
   // This shouldn't trigger a write.
   device_settings_test_helper_.set_policy_blob(std::string());
   FlushDeviceSettings();
   EXPECT_EQ(std::string(), device_settings_test_helper_.policy_blob());
 
   // Verify the change has been applied.
   const base::Value* saved_value = provider_->Get(kReleaseChannel);
@@ skipping 54 matching lines @@
 }
 
 TEST_F(DeviceSettingsProviderTest, SetPrefTwice) {
   owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
   InitOwner(AccountId::FromUserEmail(device_policy_.policy_data().username()),
             true);
   FlushDeviceSettings();
 
   EXPECT_CALL(*this, SettingChanged(_)).Times(AnyNumber());
 
-  base::StringValue value1("beta");
+  base::Value value1("beta");
   provider_->Set(kReleaseChannel, value1);
-  base::StringValue value2("dev");
+  base::Value value2("dev");
   provider_->Set(kReleaseChannel, value2);
 
   // Let the changes propagate through the system.
   device_settings_test_helper_.set_policy_blob(std::string());
   FlushDeviceSettings();
 
   // Verify the second change has been applied.
   const base::Value* saved_value = provider_->Get(kReleaseChannel);
   EXPECT_TRUE(value2.Equals(saved_value));
 
@@ skipping 86 matching lines @@
       mutable_disabled_state()->set_message(kDisabledMessage);
   device_policy_.Build();
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
   Mock::VerifyAndClearExpectations(this);
 
   // Verify that the device state has been decoded correctly.
   const base::Value expected_disabled_value(true);
   EXPECT_TRUE(base::Value::Equals(provider_->Get(kDeviceDisabled),
                                   &expected_disabled_value));
-  const base::StringValue expected_disabled_message_value(kDisabledMessage);
+  const base::Value expected_disabled_message_value(kDisabledMessage);
   EXPECT_TRUE(base::Value::Equals(provider_->Get(kDeviceDisabledMessage),
                                   &expected_disabled_message_value));
 
   // Verify that a change to the device state triggers a notification.
   EXPECT_CALL(*this, SettingChanged(_)).Times(AtLeast(1));
   device_policy_.policy_data().mutable_device_state()->clear_device_mode();
   device_policy_.Build();
   device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
   ReloadDeviceSettings();
   Mock::VerifyAndClearExpectations(this);
@@ skipping 31 matching lines @@
 TEST_F(DeviceSettingsProviderTest, DecodeDomainAutoComplete) {
   // By default LoginScreenDomainAutoComplete policy should not be set.
   VerifyDomainAutoComplete(nullptr);
 
   // Empty string means that the policy is not set.
   SetDomainAutoComplete("");
   VerifyDomainAutoComplete(nullptr);
 
   // Check some meaningful value. Policy should be set.
   const std::string domain = "domain.test";
-  const base::StringValue domain_value(domain);
+  const base::Value domain_value(domain);
   SetDomainAutoComplete(domain);
   VerifyDomainAutoComplete(&domain_value);
 }
 
 TEST_F(DeviceSettingsProviderTest, DecodeLogUploadSettings) {
   SetLogUploadSettings(true);
   VerifyLogUploadSettings(true);
 
   SetLogUploadSettings(false);
   VerifyLogUploadSettings(false);
 }
 } // namespace chromeos