Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

base/prefs/json_pref_store_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 "base/prefs/json_pref_store.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
@@ skipping 174 matching lines @@
   EXPECT_EQ(cnn, string_value);
 
   const char kSomeDirectory[] = "some_directory";
 
   EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual));
   base::FilePath::StringType path;
   EXPECT_TRUE(actual->GetAsString(&path));
   EXPECT_EQ(base::FilePath::StringType(FILE_PATH_LITERAL("/usr/local/")), path);
   base::FilePath some_path(FILE_PATH_LITERAL("/usr/sbin/"));
 
-  pref_store->SetValue(kSomeDirectory, new StringValue(some_path.value()),
+  pref_store->SetValue(kSomeDirectory,
+                       make_scoped_ptr(new StringValue(some_path.value())),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kSomeDirectory, &actual));
   EXPECT_TRUE(actual->GetAsString(&path));
   EXPECT_EQ(some_path.value(), path);
 
   // Test reading some other data types from sub-dictionaries.
   EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual));
   bool boolean = false;
   EXPECT_TRUE(actual->GetAsBoolean(&boolean));
   EXPECT_TRUE(boolean);
 
-  pref_store->SetValue(kNewWindowsInTabs, new FundamentalValue(false),
+  pref_store->SetValue(kNewWindowsInTabs,
+                       make_scoped_ptr(new FundamentalValue(false)),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kNewWindowsInTabs, &actual));
   EXPECT_TRUE(actual->GetAsBoolean(&boolean));
   EXPECT_FALSE(boolean);
 
   EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual));
   int integer = 0;
   EXPECT_TRUE(actual->GetAsInteger(&integer));
   EXPECT_EQ(20, integer);
-  pref_store->SetValue(kMaxTabs, new FundamentalValue(10),
+  pref_store->SetValue(kMaxTabs, make_scoped_ptr(new FundamentalValue(10)),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kMaxTabs, &actual));
   EXPECT_TRUE(actual->GetAsInteger(&integer));
   EXPECT_EQ(10, integer);
 
-  pref_store->SetValue(kLongIntPref,
-                       new StringValue(base::Int64ToString(214748364842LL)),
-                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  pref_store->SetValue(
+      kLongIntPref,
+      make_scoped_ptr(new StringValue(base::Int64ToString(214748364842LL))),
+      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(pref_store->GetValue(kLongIntPref, &actual));
   EXPECT_TRUE(actual->GetAsString(&string_value));
   int64 value;
   base::StringToInt64(string_value, &value);
   EXPECT_EQ(214748364842LL, value);
 
   // Serialize and compare to expected output.
   ASSERT_TRUE(PathExists(golden_output_file));
   pref_store->CommitPendingWrite();
   RunLoop().RunUntilIdle();
@@ skipping 69 matching lines @@
       pref_store.get(), input_file, data_dir_.AppendASCII("write.golden.json"));
 }
 
 TEST_F(JsonPrefStoreTest, PreserveEmptyValues) {
   FilePath pref_file = temp_dir_.path().AppendASCII("empty_values.json");
 
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       pref_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
   // Set some keys with empty values.
-  pref_store->SetValue("list", new base::ListValue,
+  pref_store->SetValue("list", make_scoped_ptr(new base::ListValue),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  pref_store->SetValue("dict", new base::DictionaryValue,
+  pref_store->SetValue("dict", make_scoped_ptr(new base::DictionaryValue),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   // Write to file.
   pref_store->CommitPendingWrite();
   RunLoop().RunUntilIdle();
 
   // Reload.
   pref_store = new JsonPrefStore(pref_file, message_loop_.task_runner(),
                                  scoped_ptr<PrefFilter>());
   ASSERT_EQ(PersistentPrefStore::PREF_READ_ERROR_NONE, pref_store->ReadPrefs());
   ASSERT_FALSE(pref_store->ReadOnly());
 
   // Check values.
   const Value* result = NULL;
   EXPECT_TRUE(pref_store->GetValue("list", &result));
   EXPECT_TRUE(ListValue().Equals(result));
   EXPECT_TRUE(pref_store->GetValue("dict", &result));
   EXPECT_TRUE(DictionaryValue().Equals(result));
 }
 
 // This test is just documenting some potentially non-obvious behavior. It
 // shouldn't be taken as normative.
 TEST_F(JsonPrefStoreTest, RemoveClearsEmptyParent) {
   FilePath pref_file = temp_dir_.path().AppendASCII("empty_values.json");
 
   scoped_refptr<JsonPrefStore> pref_store = new JsonPrefStore(
       pref_file, message_loop_.task_runner(), scoped_ptr<PrefFilter>());
 
-  base::DictionaryValue* dict = new base::DictionaryValue;
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   dict->SetString("key", "value");
-  pref_store->SetValue("dict", dict,
+  pref_store->SetValue("dict", dict.Pass(),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   pref_store->RemoveValue("dict.key",
                           WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   const base::Value* retrieved_dict = NULL;
   bool has_dict = pref_store->GetValue("dict", &retrieved_dict);
   EXPECT_FALSE(has_dict);
 }
 
@@ skipping 479 matching lines @@
  private:
   base::FilePath test_file_;
 };
 
 TEST_F(JsonPrefStoreLossyWriteTest, LossyWriteBasic) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store);
 
   // Set a normal pref and check that it gets scheduled to be written.
   ASSERT_FALSE(file_writer->HasPendingWrite());
-  pref_store->SetValue("normal", new base::StringValue("normal"),
+  pref_store->SetValue("normal",
+                       make_scoped_ptr(new base::StringValue("normal")),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   ASSERT_TRUE(file_writer->HasPendingWrite());
   file_writer->DoScheduledWrite();
   ASSERT_EQ("{\"normal\":\"normal\"}", GetTestFileContents());
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Set a lossy pref and check that it is not scheduled to be written.
   // SetValue/RemoveValue.
-  pref_store->SetValue("lossy", new base::StringValue("lossy"),
+  pref_store->SetValue("lossy", make_scoped_ptr(new base::StringValue("lossy")),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
   pref_store->RemoveValue("lossy", WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // SetValueSilently/RemoveValueSilently.
-  pref_store->SetValueSilently("lossy", new base::StringValue("lossy"),
+  pref_store->SetValueSilently("lossy",
+                               make_scoped_ptr(new base::StringValue("lossy")),
                                WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
   pref_store->RemoveValueSilently("lossy",
                                   WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // ReportValueChanged.
-  pref_store->SetValue("lossy", new base::StringValue("lossy"),
+  pref_store->SetValue("lossy", make_scoped_ptr(new base::StringValue("lossy")),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
   pref_store->ReportValueChanged("lossy",
                                  WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Call CommitPendingWrite and check that the lossy pref and the normal pref
   // are there with the last values set above.
   pref_store->CommitPendingWrite();
   ASSERT_FALSE(file_writer->HasPendingWrite());
   ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}",
             GetTestFileContents());
 }
 
 TEST_F(JsonPrefStoreLossyWriteTest, LossyWriteMixedLossyFirst) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store);
 
   // Set a lossy pref and check that it is not scheduled to be written.
   ASSERT_FALSE(file_writer->HasPendingWrite());
-  pref_store->SetValue("lossy", new base::StringValue("lossy"),
+  pref_store->SetValue("lossy", make_scoped_ptr(new base::StringValue("lossy")),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Set a normal pref and check that it is scheduled to be written.
-  pref_store->SetValue("normal", new base::StringValue("normal"),
+  pref_store->SetValue("normal",
+                       make_scoped_ptr(new base::StringValue("normal")),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call DoScheduledWrite and check both prefs get written.
   file_writer->DoScheduledWrite();
   ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}",
             GetTestFileContents());
   ASSERT_FALSE(file_writer->HasPendingWrite());
 }
 
 TEST_F(JsonPrefStoreLossyWriteTest, LossyWriteMixedLossySecond) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store);
 
   // Set a normal pref and check that it is scheduled to be written.
   ASSERT_FALSE(file_writer->HasPendingWrite());
-  pref_store->SetValue("normal", new base::StringValue("normal"),
+  pref_store->SetValue("normal",
+                       make_scoped_ptr(new base::StringValue("normal")),
                        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Set a lossy pref and check that the write is still scheduled.
-  pref_store->SetValue("lossy", new base::StringValue("lossy"),
+  pref_store->SetValue("lossy", make_scoped_ptr(new base::StringValue("lossy")),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call DoScheduledWrite and check both prefs get written.
   file_writer->DoScheduledWrite();
   ASSERT_EQ("{\"lossy\":\"lossy\",\"normal\":\"normal\"}",
             GetTestFileContents());
   ASSERT_FALSE(file_writer->HasPendingWrite());
 }
 
 TEST_F(JsonPrefStoreLossyWriteTest, ScheduleLossyWrite) {
   scoped_refptr<JsonPrefStore> pref_store = CreatePrefStore();
   ImportantFileWriter* file_writer = GetImportantFileWriter(pref_store);
 
   // Set a lossy pref and check that it is not scheduled to be written.
-  pref_store->SetValue("lossy", new base::StringValue("lossy"),
+  pref_store->SetValue("lossy", make_scoped_ptr(new base::StringValue("lossy")),
                        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG);
   ASSERT_FALSE(file_writer->HasPendingWrite());
 
   // Schedule pending lossy writes and check that it is scheduled.
   pref_store->SchedulePendingLossyWrites();
   ASSERT_TRUE(file_writer->HasPendingWrite());
 
   // Call CommitPendingWrite and check that the lossy pref is there with the
   // last value set above.
   pref_store->CommitPendingWrite();
   ASSERT_FALSE(file_writer->HasPendingWrite());
   ASSERT_EQ("{\"lossy\":\"lossy\"}", GetTestFileContents());
 }
 
 }  // namespace base