Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

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"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"

[jdoerrie, 2017/04/06 14:25:50]

#include "base/values.h"

[vabr (Chromium), 2017/04/07 20:40:40]

Done.

 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/storage/sync_value_store_cache.h"
 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync/model/sync_change_processor.h"
 #include "components/sync/model/sync_change_processor_wrapper_for_test.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/sync_error_factory_mock.h"
 #include "content/public/test/test_browser_thread.h"
@@ skipping 367 matching lines @@
 
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s1", "foo", value1, model_type));
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, model_type));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, sync_data, std::move(sync_processor_wrapper_),
           base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  expected1.Set("foo", value1.DeepCopy());
-  expected2.Set("bar", value2.DeepCopy());
+  expected1.Set("foo", value1.CreateDeepCopy());
+  expected2.Set("bar", value2.CreateDeepCopy());
 
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
   // All changes should be local, so no sync changes.
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   // Sync settings should have been pushed to local settings.
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
@@ skipping 10 matching lines @@
 
   // 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);
 
   storage1->Set(DEFAULTS, "foo", value1);
-  expected1.Set("foo", value1.DeepCopy());
+  expected1.Set("foo", value1.CreateDeepCopy());
 
   syncer::SyncDataList sync_data;
   sync_data.push_back(settings_sync_util::CreateData(
       "s2", "bar", value2, model_type));
 
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
           model_type, sync_data, std::move(sync_processor_wrapper_),
           base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  expected2.Set("bar", value2.DeepCopy());
+  expected2.Set("bar", value2.CreateDeepCopy());
 
   // Make sync add some settings.
   syncer::SyncChangeList change_list;
   change_list.push_back(settings_sync_util::CreateAdd(
       "s1", "bar", value2, model_type));
   change_list.push_back(settings_sync_util::CreateAdd(
       "s2", "foo", value1, model_type));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  expected1.Set("bar", value2.DeepCopy());
-  expected2.Set("foo", value1.DeepCopy());
+  expected1.Set("bar", value2.CreateDeepCopy());
+  expected2.Set("foo", value1.CreateDeepCopy());
 
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   // Make sync update some settings, storage1 the new setting, storage2 the
   // initial setting.
   change_list.clear();
   change_list.push_back(settings_sync_util::CreateUpdate(
       "s1", "bar", value2, model_type));
   change_list.push_back(settings_sync_util::CreateUpdate(
       "s2", "bar", value1, model_type));
   GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  expected1.Set("bar", value2.DeepCopy());
-  expected2.Set("bar", value1.DeepCopy());
+  expected1.Set("bar", value2.CreateDeepCopy());
+  expected2.Set("bar", value1.CreateDeepCopy());
 
   EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
   EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
   // Make sync remove some settings, storage1 the initial setting, storage2 the
   // new setting.
   change_list.clear();
   change_list.push_back(settings_sync_util::CreateDelete(
       "s1", "foo", model_type));
   change_list.push_back(settings_sync_util::CreateDelete(
@@ skipping 218 matching lines @@
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
             base::MakeUnique<syncer::SyncErrorFactoryMock>());
   }
   GetExisting("bad")->set_status_code(ValueStore::OK);
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Changes made to good should be sent to sync, changes from bad shouldn't.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "bar", barValue);
   bad->Set(DEFAULTS, "bar", barValue);
 
   EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Changes received from sync should go to good but not bad (even when it's
   // not failing).
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateUpdate(
           "good", "foo", barValue, model_type));
     // (Sending UPDATE here even though it's adding, since that's what the state
     // of sync is.  In any case, it won't work.)
     change_list.push_back(settings_sync_util::CreateUpdate(
           "bad", "foo", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Changes made to bad still shouldn't go to sync, even though it didn't fail
   // last time.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "bar", fooValue);
   bad->Set(DEFAULTS, "bar", fooValue);
 
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             sync_processor_->GetOnlyChange("good", "bar")->change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
-    dict.Set("bar", fooValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
+    dict.Set("bar", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("bar", fooValue.DeepCopy());
+    dict.Set("bar", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Failing ProcessSyncChanges shouldn't go to the storage.
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateUpdate(
           "good", "foo", fooValue, model_type));
     // (Ditto.)
     change_list.push_back(settings_sync_util::CreateUpdate(
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
   GetExisting("bad")->set_status_code(ValueStore::OK);
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
-    dict.Set("bar", fooValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
+    dict.Set("bar", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("bar", fooValue.DeepCopy());
+    dict.Set("bar", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Restarting sync should make bad start syncing again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
@@ skipping 27 matching lines @@
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateUpdate(
           "good", "bar", fooValue, model_type));
     change_list.push_back(settings_sync_util::CreateUpdate(
           "bad", "bar", fooValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
-    dict.Set("bar", fooValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
+    dict.Set("bar", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("bar", fooValue.DeepCopy());
+    dict.Set("bar", fooValue.CreateDeepCopy());
     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;
 
@@ skipping 13 matching lines @@
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
             model_type, sync_data, std::move(sync_processor_wrapper_),
             base::MakeUnique<syncer::SyncErrorFactoryMock>());
   }
 
   EXPECT_EQ(0u, sync_processor_->changes().size());
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Now fail ProcessSyncChanges for bad.
   GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateAdd(
           "good", "bar", barValue, model_type));
     change_list.push_back(settings_sync_util::CreateAdd(
           "bad", "bar", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
   GetExisting("bad")->set_status_code(ValueStore::OK);
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // No more changes sent to sync for bad.
   sync_processor_->ClearChanges();
   good->Set(DEFAULTS, "foo", barValue);
   bad->Set(DEFAULTS, "foo", barValue);
 
   EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
             sync_processor_->GetOnlyChange("good", "foo")->change_type());
   EXPECT_EQ(1u, sync_processor_->changes().size());
 
   // No more changes received from sync should go to bad.
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateAdd(
           "good", "foo", fooValue, model_type));
     change_list.push_back(settings_sync_util::CreateAdd(
           "bad", "foo", fooValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
     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::Value fooValue("fooValue");
   base::Value barValue("barValue");
@@ skipping 81 matching lines @@
           "good", "foo", barValue, model_type));
     // (Sending ADD here even though it's updating, since that's what the state
     // of sync is.  In any case, it won't work.)
     change_list.push_back(settings_sync_util::CreateAdd(
           "bad", "foo", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("foo", fooValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", fooValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Re-enabling sync without failing should cause the local changes from bad
   // to be pushed to sync successfully, as should future changes to bad.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
@@ skipping 58 matching lines @@
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateAdd(
           "good", "bar", barValue, model_type));
     change_list.push_back(settings_sync_util::CreateAdd(
           "bad", "bar", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Restarting sync makes everything work again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
@@ skipping 60 matching lines @@
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateAdd(
           "good", "bar", barValue, model_type));
     change_list.push_back(settings_sync_util::CreateAdd(
           "bad", "bar", barValue, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
 
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
-    dict.Set("bar", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
+    dict.Set("bar", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
   }
   {
     base::DictionaryValue dict;
-    dict.Set("foo", barValue.DeepCopy());
+    dict.Set("foo", barValue.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
   }
 
   // Restarting sync makes everything work again.
   sync_processor_->ClearChanges();
   GetSyncableService(model_type)->StopSyncing(model_type);
   sync_processor_wrapper_.reset(
       new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
   GetSyncableService(model_type)
       ->MergeDataAndStartSyncing(
@@ skipping 49 matching lines @@
   {
     syncer::SyncChangeList change_list;
     change_list.push_back(settings_sync_util::CreateAdd(
           "s1", "large_value", large_value, model_type));
     change_list.push_back(settings_sync_util::CreateAdd(
           "s2", "large_value", large_value, model_type));
     GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
   }
   {
     base::DictionaryValue expected;
-    expected.Set("large_value", large_value.DeepCopy());
+    expected.Set("large_value", large_value.CreateDeepCopy());
     EXPECT_PRED_FORMAT2(SettingsEq, expected, storage1->Get());
     EXPECT_PRED_FORMAT2(SettingsEq, expected, storage2->Get());
   }
 
   GetSyncableService(model_type)->StopSyncing(model_type);
 }
 
 TEST_F(ExtensionSettingsSyncTest, Dots) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
@@ skipping 11 matching lines @@
             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::Value("value"));
+    expected_data.SetWithoutPathExpansion(
+        "key.with.dot", base::MakeUnique<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::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();
@@ skipping 57 matching lines @@
                             settings_namespace::SYNC,
                             base::Bind(&UnlimitedSyncStorageTestCallback));
   frontend_->RunWithStorage(extension,
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace extensions