Remove base::StringValue

components/user_prefs/tracked/pref_hash_filter_unittest.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/user_prefs/tracked/pref_hash_filter.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 445 matching lines @@
   // of the copy, we make it forward calls to the mock it was created from.
   // Once set, |origin_mock_| must outlive this instance.
   MockHashStoreContents* origin_mock_;
 
   DISALLOW_COPY_AND_ASSIGN(MockHashStoreContents);
 };
 
 std::string MockHashStoreContents::GetStoredMac(const std::string& path) const {
   const base::Value* out_value;
   if (dictionary_.GetWithoutPathExpansion(path, &out_value)) {
-    const base::StringValue* value_as_string;
+    const base::Value* value_as_string;
     EXPECT_TRUE(out_value->GetAsString(&value_as_string));
 
     return value_as_string->GetString();
   }
 
   return std::string();
 }
 
 std::string MockHashStoreContents::GetStoredSplitMac(
     const std::string& path,
     const std::string& split_path) const {
   const base::Value* out_value;
   if (dictionary_.GetWithoutPathExpansion(path, &out_value)) {
     const base::DictionaryValue* value_as_dict;
     EXPECT_TRUE(out_value->GetAsDictionary(&value_as_dict));
 
     if (value_as_dict->GetWithoutPathExpansion(split_path, &out_value)) {
-      const base::StringValue* value_as_string;
+      const base::Value* value_as_string;
       EXPECT_TRUE(out_value->GetAsString(&value_as_string));
 
       return value_as_string->GetString();
     }
   }
 
   return std::string();
 }
 
 MockHashStoreContents::MockHashStoreContents(MockHashStoreContents* origin_mock)
@@ skipping 201 matching lines @@
   mock_pref_hash_store_->set_stamp_super_mac_result(true);
   DoFilterOnLoad(true);
   // No paths stored, since they all return |UNCHANGED|. The StampSuperMAC
   // result is the only reason the prefs were considered altered.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 }
 
 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
   base::DictionaryValue root_dict;
   // Ownership of |string_value| is transfered to |root_dict|.
-  base::Value* string_value = new base::StringValue("string value");
+  base::Value* string_value = new base::Value("string value");
   root_dict.Set(kAtomicPref, string_value);
 
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value =
@@ skipping 60 matching lines @@
       mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(dict_value, stored_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_value.second);
 
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
   VerifyRecordedReset(false);
 }
 
 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
   base::DictionaryValue root_dict;
-  root_dict.Set("untracked", new base::StringValue("some value"));
+  root_dict.Set("untracked", new base::Value("some value"));
   pref_hash_filter_->FilterUpdate("untracked");
 
   // No paths should be stored on FilterUpdate.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // Nor on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // No transaction should even be started on FilterSerializeData() if there are
@@ skipping 91 matching lines @@
   ASSERT_FALSE(validated_split_pref->is_personal);
   const MockValidationDelegate::ValidationEvent* validated_atomic_pref =
       mock_validation_delegate_.GetEventForPath(kAtomicPref);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_ATOMIC,
             validated_atomic_pref->strategy);
   ASSERT_TRUE(validated_atomic_pref->is_personal);
 }
 
 TEST_P(PrefHashFilterTest, InitialValueUnknown) {
   // Ownership of these values is transfered to |pref_store_contents_|.
-  base::StringValue* string_value = new base::StringValue("string value");
+  base::Value* string_value = new base::Value("string value");
   pref_store_contents_->Set(kAtomicPref, string_value);
 
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
@@ skipping 46 matching lines @@
     ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
     ASSERT_EQ(dict_value, split_value_in_store);
     ASSERT_EQ(dict_value, stored_split_value.first);
 
     VerifyRecordedReset(false);
   }
 }
 
 TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
   // Ownership of this value is transfered to |pref_store_contents_|.
-  base::Value* string_value = new base::StringValue("test");
+  base::Value* string_value = new base::Value("test");
   pref_store_contents_->Set(kAtomicPref, string_value);
 
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
@@ skipping 146 matching lines @@
 
   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
       mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(NULL, stored_split_value.first);
   ASSERT_EQ(PrefHashFilter::TRACKING_STRATEGY_SPLIT, stored_split_value.second);
 }
 
 TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
   // Ownership of these values is transfered to |pref_store_contents_|.
-  base::StringValue* string_value = new base::StringValue("string value");
+  base::Value* string_value = new base::Value("string value");
   pref_store_contents_->Set(kAtomicPref, string_value);
 
   base::DictionaryValue* dict_value = new base::DictionaryValue;
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
@@ skipping 240 matching lines @@
                     PrefHashStoreTransaction::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_.CountExternalValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 }
 
 INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,
                         PrefHashFilterTest,
                         testing::Values(PrefHashFilter::NO_ENFORCEMENT,
                                         PrefHashFilter::ENFORCE_ON_LOAD));