Remove base::StringValue

chrome/browser/extensions/api/storage/settings_sync_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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 282 matching lines @@
   GetSyncableService(model_type)->StopSyncing(model_type);
 
   EXPECT_EQ(0u, sync_processor_->changes().size());
   EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, InSyncDataDoesNotInvokeSync) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
-  base::StringValue value1("fooValue");
+  base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
   storage2->Set(DEFAULTS, "bar", value2);
 
   SettingSyncDataMultimap all_sync_data = GetAllSyncData(model_type);
@@ skipping 28 matching lines @@
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
   EXPECT_TRUE(value2.Equals(&change->value()));
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, LocalDataWithNoSyncDataIsPushedToSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  base::StringValue value1("fooValue");
+  base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   storage1->Set(DEFAULTS, "foo", value1);
   storage2->Set(DEFAULTS, "bar", value2);
 
   GetSyncableService(model_type)
@@ skipping 11 matching lines @@
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
   EXPECT_TRUE(value2.Equals(&change->value()));
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, AnySyncDataOverwritesLocalData) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
-  base::StringValue value1("fooValue");
+  base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   base::DictionaryValue expected1, expected2;
 
   // Pre-populate one of the storage areas.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   storage1->Set(DEFAULTS, "overwriteMe", value1);
@@ skipping 19 matching lines @@
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, ProcessSyncChanges) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  base::StringValue value1("fooValue");
+  base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   base::DictionaryValue expected1, expected2;
 
   // Make storage1 initialised from local data, storage2 initialised from sync.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
@@ skipping 52 matching lines @@
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, PushToSync) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
-  base::StringValue value1("fooValue");
+  base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // Make storage1/2 initialised from local data, storage3/4 initialised from
   // sync.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
   ValueStore* storage3 = AddExtensionAndGetStorage("s3", type);
   ValueStore* storage4 = AddExtensionAndGetStorage("s4", type);
 
@@ skipping 106 matching lines @@
             sync_processor_->GetOnlyChange("s3", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
             sync_processor_->GetOnlyChange("s4", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
             sync_processor_->GetOnlyChange("s4", "bar")->change_type());
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, ExtensionAndAppSettingsSyncSeparately) {
-  base::StringValue value1("fooValue");
+  base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // storage1 is an extension, storage2 is an app.
   ValueStore* storage1 = AddExtensionAndGetStorage(
       "s1", Manifest::TYPE_EXTENSION);
   ValueStore* storage2 = AddExtensionAndGetStorage(
       "s2", Manifest::TYPE_LEGACY_PACKAGED_APP);
 
   storage1->Set(DEFAULTS, "foo", value1);
@@ skipping 38 matching lines @@
           base::MakeUnique<syncer::SyncErrorFactoryMock>());
   GetSyncableService(syncer::APP_SETTINGS)->
       StopSyncing(syncer::APP_SETTINGS);
   EXPECT_EQ(0u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  base::StringValue fooValue("fooValue");
-  base::StringValue barValue("barValue");
+  base::Value fooValue("fooValue");
+  base::Value barValue("barValue");
 
   // There is a bit of a convoluted method to get storage areas that can fail;
   // hand out TestingValueStore object then toggle them failing/succeeding
   // as necessary.
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   // Make bad fail for incoming sync changes.
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
@@ skipping 167 matching lines @@
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingProcessChangesDisablesSync) {
   // The test above tests a failing ProcessSyncChanges too, but here test with
   // an initially passing MergeDataAndStartSyncing.
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
-  base::StringValue fooValue("fooValue");
-  base::StringValue barValue("barValue");
+  base::Value fooValue("fooValue");
+  base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   // Unlike before, initially succeeding MergeDataAndStartSyncing.
   {
     syncer::SyncDataList sync_data;
     sync_data.push_back(settings_sync_util::CreateData(
           "good", "foo", fooValue, model_type));
     sync_data.push_back(settings_sync_util::CreateData(
@@ skipping 70 matching lines @@
     base::DictionaryValue dict;
     dict.Set("foo", barValue.DeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingGetAllSyncDataDoesntStopSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  base::StringValue fooValue("fooValue");
-  base::StringValue barValue("barValue");
+  base::Value fooValue("fooValue");
+  base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   good->Set(DEFAULTS, "foo", fooValue);
   bad->Set(DEFAULTS, "foo", fooValue);
 
   // Even though bad will fail to get all sync data, sync data should still
   // include that from good.
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
@@ skipping 26 matching lines @@
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("bad", "bar")->change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToReadChangesToPushDisablesSync) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
-  base::StringValue fooValue("fooValue");
-  base::StringValue barValue("barValue");
+  base::Value fooValue("fooValue");
+  base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   good->Set(DEFAULTS, "foo", fooValue);
   bad->Set(DEFAULTS, "foo", fooValue);
 
   // good will successfully push foo:fooValue to sync, but bad will fail to
   // get them so won't.
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
@@ skipping 71 matching lines @@
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalStateDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  base::StringValue fooValue("fooValue");
-  base::StringValue barValue("barValue");
+  base::Value fooValue("fooValue");
+  base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   // Only set bad; setting good will cause it to fail below.
   bad->Set(DEFAULTS, "foo", fooValue);
 
   sync_processor_->set_fail_all_requests(true);
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
@@ skipping 60 matching lines @@
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(2u, sync_processor_->changes().size());
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalChangeDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  base::StringValue fooValue("fooValue");
-  base::StringValue barValue("barValue");
+  base::Value fooValue("fooValue");
+  base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
           base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
@@ skipping 71 matching lines @@
 TEST_F(ExtensionSettingsSyncTest,
        LargeOutgoingChangeRejectedButIncomingAccepted) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   // This value should be larger than the limit in sync_storage_backend.cc.
   std::string string_10k;
   for (size_t i = 0; i < 10000; ++i) {
     string_10k.append("a");
   }
-  base::StringValue large_value(string_10k);
+  base::Value large_value(string_10k);
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, syncer::SyncDataList(),
           std::move(sync_processor_wrapper_),
           base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
   // Large local change rejected and doesn't get sent out.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   EXPECT_FALSE(
@@ skipping 21 matching lines @@
 }
 
 TEST_F(ExtensionSettingsSyncTest, Dots) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   ValueStore* storage = AddExtensionAndGetStorage("ext", type);
 
   {
     syncer::SyncDataList sync_data_list;
-    std::unique_ptr<base::Value> string_value(new base::StringValue("value"));
+    std::unique_ptr<base::Value> string_value(new base::Value("value"));
     sync_data_list.push_back(settings_sync_util::CreateData(
         "ext", "key.with.dot", *string_value, model_type));
 
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data_list, std::move(sync_processor_wrapper_),
             base::MakeUnique<syncer::SyncErrorFactoryMock>());
   }
 
   // Test dots in keys that come from sync.
   {
     ValueStore::ReadResult data = storage->Get();
     ASSERT_TRUE(data->status().ok());
 
     base::DictionaryValue expected_data;
-    expected_data.SetWithoutPathExpansion(
-        "key.with.dot",
-        new base::StringValue("value"));
+    expected_data.SetWithoutPathExpansion("key.with.dot",
+                                          new base::Value("value"));
     EXPECT_TRUE(base::Value::Equals(&expected_data, &data->settings()));
   }
 
   // Test dots in keys going to sync.
   {
-    std::unique_ptr<base::Value> string_value(new base::StringValue("spot"));
+    std::unique_ptr<base::Value> string_value(new base::Value("spot"));
     storage->Set(DEFAULTS, "key.with.spot", *string_value);
 
     ASSERT_EQ(1u, sync_processor_->changes().size());
     SettingSyncData* sync_data = sync_processor_->changes()[0].get();
     EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data->change_type());
     EXPECT_EQ("ext", sync_data->extension_id());
     EXPECT_EQ("key.with.spot", sync_data->key());
     EXPECT_TRUE(sync_data->value().Equals(string_value.get()));
   }
 }
@@ skipping 51 matching lines @@
                             settings_namespace::SYNC,
                             base::Bind(&UnlimitedSyncStorageTestCallback));
   frontend_->RunWithStorage(extension,
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace extensions