Convert //base to use std::unique_ptr

base/json/json_value_serializer_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 <memory>
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/json/json_writer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
@@ skipping 45 matching lines @@
   str_serializer.set_pretty_print(true);
   ASSERT_TRUE(str_serializer.Serialize(value));
   // Unify line endings between platforms.
   ReplaceSubstringsAfterOffset(&serialized_json, 0,
                                kWinLineEnds, kLinuxLineEnds);
   // Now compare the input with the output.
   ASSERT_EQ(kProperJSON, serialized_json);
 }
 
 void ValidateJsonList(const std::string& json) {
-  scoped_ptr<Value> root = JSONReader::Read(json);
+  std::unique_ptr<Value> root = JSONReader::Read(json);
   ASSERT_TRUE(root.get() && root->IsType(Value::TYPE_LIST));
   ListValue* list = static_cast<ListValue*>(root.get());
   ASSERT_EQ(1U, list->GetSize());
   Value* elt = NULL;
   ASSERT_TRUE(list->Get(0, &elt));
   int value = 0;
   ASSERT_TRUE(elt && elt->GetAsInteger(&value));
   ASSERT_EQ(1, value);
 }
 
 // Test proper JSON deserialization from string is working.
 TEST(JSONValueDeserializerTest, ReadProperJSONFromString) {
   // Try to deserialize it through the serializer.
   JSONStringValueDeserializer str_deserializer(kProperJSON);
 
   int error_code = 0;
   std::string error_message;
-  scoped_ptr<Value> value =
+  std::unique_ptr<Value> value =
       str_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_TRUE(value.get());
   ASSERT_EQ(0, error_code);
   ASSERT_TRUE(error_message.empty());
   // Verify if the same JSON is still there.
   CheckJSONIsStillTheSame(*value);
 }
 
 // Test proper JSON deserialization from a StringPiece substring.
 TEST(JSONValueDeserializerTest, ReadProperJSONFromStringPiece) {
   // Create a StringPiece for the substring of kProperJSONPadded that matches
   // kProperJSON.
   base::StringPiece proper_json(kProperJSONPadded);
   proper_json = proper_json.substr(5, proper_json.length() - 10);
   JSONStringValueDeserializer str_deserializer(proper_json);
 
   int error_code = 0;
   std::string error_message;
-  scoped_ptr<Value> value =
+  std::unique_ptr<Value> value =
       str_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_TRUE(value.get());
   ASSERT_EQ(0, error_code);
   ASSERT_TRUE(error_message.empty());
   // Verify if the same JSON is still there.
   CheckJSONIsStillTheSame(*value);
 }
 
 // Test that trialing commas are only properly deserialized from string when
 // the proper flag for that is set.
 TEST(JSONValueDeserializerTest, ReadJSONWithTrailingCommasFromString) {
   // Try to deserialize it through the serializer.
   JSONStringValueDeserializer str_deserializer(kProperJSONWithCommas);
 
   int error_code = 0;
   std::string error_message;
-  scoped_ptr<Value> value =
+  std::unique_ptr<Value> value =
       str_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_FALSE(value.get());
   ASSERT_NE(0, error_code);
   ASSERT_FALSE(error_message.empty());
   // Now the flag is set and it must pass.
   str_deserializer.set_allow_trailing_comma(true);
   value = str_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_TRUE(value.get());
   ASSERT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
   // Verify if the same JSON is still there.
   CheckJSONIsStillTheSame(*value);
 }
 
 // Test proper JSON deserialization from file is working.
 TEST(JSONValueDeserializerTest, ReadProperJSONFromFile) {
   ScopedTempDir tempdir;
   ASSERT_TRUE(tempdir.CreateUniqueTempDir());
   // Write it down in the file.
   FilePath temp_file(tempdir.path().AppendASCII("test.json"));
   ASSERT_EQ(static_cast<int>(strlen(kProperJSON)),
             WriteFile(temp_file, kProperJSON, strlen(kProperJSON)));
 
   // Try to deserialize it through the serializer.
   JSONFileValueDeserializer file_deserializer(temp_file);
 
   int error_code = 0;
   std::string error_message;
-  scoped_ptr<Value> value =
+  std::unique_ptr<Value> value =
       file_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_TRUE(value.get());
   ASSERT_EQ(0, error_code);
   ASSERT_TRUE(error_message.empty());
   // Verify if the same JSON is still there.
   CheckJSONIsStillTheSame(*value);
 }
 
 // Test that trialing commas are only properly deserialized from file when
 // the proper flag for that is set.
 TEST(JSONValueDeserializerTest, ReadJSONWithCommasFromFile) {
   ScopedTempDir tempdir;
   ASSERT_TRUE(tempdir.CreateUniqueTempDir());
   // Write it down in the file.
   FilePath temp_file(tempdir.path().AppendASCII("test.json"));
   ASSERT_EQ(static_cast<int>(strlen(kProperJSONWithCommas)),
             WriteFile(temp_file, kProperJSONWithCommas,
                       strlen(kProperJSONWithCommas)));
 
   // Try to deserialize it through the serializer.
   JSONFileValueDeserializer file_deserializer(temp_file);
   // This must fail without the proper flag.
   int error_code = 0;
   std::string error_message;
-  scoped_ptr<Value> value =
+  std::unique_ptr<Value> value =
       file_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_FALSE(value.get());
   ASSERT_NE(0, error_code);
   ASSERT_FALSE(error_message.empty());
   // Now the flag is set and it must pass.
   file_deserializer.set_allow_trailing_comma(true);
   value = file_deserializer.Deserialize(&error_code, &error_message);
   ASSERT_TRUE(value.get());
   ASSERT_EQ(JSONReader::JSON_TRAILING_COMMA, error_code);
   // Verify if the same JSON is still there.
   CheckJSONIsStillTheSame(*value);
 }
 
 TEST(JSONValueDeserializerTest, AllowTrailingComma) {
-  scoped_ptr<Value> root;
-  scoped_ptr<Value> root_expected;
+  std::unique_ptr<Value> root;
+  std::unique_ptr<Value> root_expected;
   static const char kTestWithCommas[] = "{\"key\": [true,],}";
   static const char kTestNoCommas[] = "{\"key\": [true]}";
 
   JSONStringValueDeserializer deserializer(kTestWithCommas);
   deserializer.set_allow_trailing_comma(true);
   JSONStringValueDeserializer deserializer_expected(kTestNoCommas);
   root = deserializer.Deserialize(NULL, NULL);
   ASSERT_TRUE(root.get());
   root_expected = deserializer_expected.Deserialize(NULL, NULL);
   ASSERT_TRUE(root_expected.get());
   ASSERT_TRUE(root->Equals(root_expected.get()));
 }
 
 TEST(JSONValueSerializerTest, Roundtrip) {
   static const char kOriginalSerialization[] =
     "{\"bool\":true,\"double\":3.14,\"int\":42,\"list\":[1,2],\"null\":null}";
   JSONStringValueDeserializer deserializer(kOriginalSerialization);
-  scoped_ptr<Value> root = deserializer.Deserialize(NULL, NULL);
+  std::unique_ptr<Value> root = deserializer.Deserialize(NULL, NULL);
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
 
   DictionaryValue* root_dict = static_cast<DictionaryValue*>(root.get());
 
   Value* null_value = NULL;
   ASSERT_TRUE(root_dict->Get("null", &null_value));
   ASSERT_TRUE(null_value);
   ASSERT_TRUE(null_value->IsType(Value::TYPE_NULL));
 
@@ skipping 89 matching lines @@
 
   static const char kExpected[] = "{\"web\":\"\xE7\xBD\x91\xE9\xA1\xB5\"}";
 
   std::string actual;
   JSONStringValueSerializer serializer(&actual);
   ASSERT_TRUE(serializer.Serialize(root));
   ASSERT_EQ(kExpected, actual);
 
   // escaped ascii text -> json
   JSONStringValueDeserializer deserializer(kExpected);
-  scoped_ptr<Value> deserial_root = deserializer.Deserialize(NULL, NULL);
+  std::unique_ptr<Value> deserial_root = deserializer.Deserialize(NULL, NULL);
   ASSERT_TRUE(deserial_root.get());
   DictionaryValue* dict_root =
       static_cast<DictionaryValue*>(deserial_root.get());
   string16 web_value;
   ASSERT_TRUE(dict_root->GetString("web", &web_value));
   ASSERT_EQ(test, web_value);
 }
 
 TEST(JSONValueSerializerTest, HexStrings) {
   // hex string json -> escaped ascii text
   DictionaryValue root;
   string16 test(WideToUTF16(L"\x01\x02"));
   root.SetString("test", test);
 
   static const char kExpected[] = "{\"test\":\"\\u0001\\u0002\"}";
 
   std::string actual;
   JSONStringValueSerializer serializer(&actual);
   ASSERT_TRUE(serializer.Serialize(root));
   ASSERT_EQ(kExpected, actual);
 
   // escaped ascii text -> json
   JSONStringValueDeserializer deserializer(kExpected);
-  scoped_ptr<Value> deserial_root = deserializer.Deserialize(NULL, NULL);
+  std::unique_ptr<Value> deserial_root = deserializer.Deserialize(NULL, NULL);
   ASSERT_TRUE(deserial_root.get());
   DictionaryValue* dict_root =
       static_cast<DictionaryValue*>(deserial_root.get());
   string16 test_value;
   ASSERT_TRUE(dict_root->GetString("test", &test_value));
   ASSERT_EQ(test, test_value);
 
   // Test converting escaped regular chars
   static const char kEscapedChars[] = "{\"test\":\"\\u0067\\u006f\"}";
   JSONStringValueDeserializer deserializer2(kEscapedChars);
   deserial_root = deserializer2.Deserialize(NULL, NULL);
   ASSERT_TRUE(deserial_root.get());
   dict_root = static_cast<DictionaryValue*>(deserial_root.get());
   ASSERT_TRUE(dict_root->GetString("test", &test_value));
   ASSERT_EQ(ASCIIToUTF16("go"), test_value);
 }
 
 TEST(JSONValueSerializerTest, JSONReaderComments) {
   ValidateJsonList("[ // 2, 3, ignore me ] \n1 ]");
   ValidateJsonList("[ /* 2, \n3, ignore me ]*/ \n1 ]");
   ValidateJsonList("//header\n[ // 2, \n// 3, \n1 ]// footer");
   ValidateJsonList("/*\n[ // 2, \n// 3, \n1 ]*/[1]");
   ValidateJsonList("[ 1 /* one */ ] /* end */");
   ValidateJsonList("[ 1 //// ,2\r\n ]");
 
   // It's ok to have a comment in a string.
-  scoped_ptr<Value> root = JSONReader::Read("[\"// ok\\n /* foo */ \"]");
+  std::unique_ptr<Value> root = JSONReader::Read("[\"// ok\\n /* foo */ \"]");
   ASSERT_TRUE(root.get() && root->IsType(Value::TYPE_LIST));
   ListValue* list = static_cast<ListValue*>(root.get());
   ASSERT_EQ(1U, list->GetSize());
   Value* elt = NULL;
   ASSERT_TRUE(list->Get(0, &elt));
   std::string value;
   ASSERT_TRUE(elt && elt->GetAsString(&value));
   ASSERT_EQ("// ok\n /* foo */ ", value);
 
   // You can't nest comments.
@@ skipping 14 matching lines @@
 
 TEST_F(JSONFileValueSerializerTest, Roundtrip) {
   base::FilePath original_file_path;
   ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &original_file_path));
   original_file_path =
       original_file_path.Append(FILE_PATH_LITERAL("serializer_test.json"));
 
   ASSERT_TRUE(PathExists(original_file_path));
 
   JSONFileValueDeserializer deserializer(original_file_path);
-  scoped_ptr<Value> root;
+  std::unique_ptr<Value> root;
   root = deserializer.Deserialize(NULL, NULL);
 
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
 
   DictionaryValue* root_dict = static_cast<DictionaryValue*>(root.get());
 
   Value* null_value = NULL;
   ASSERT_TRUE(root_dict->Get("null", &null_value));
   ASSERT_TRUE(null_value);
@@ skipping 27 matching lines @@
 
 TEST_F(JSONFileValueSerializerTest, RoundtripNested) {
   base::FilePath original_file_path;
   ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &original_file_path));
   original_file_path = original_file_path.Append(
       FILE_PATH_LITERAL("serializer_nested_test.json"));
 
   ASSERT_TRUE(PathExists(original_file_path));
 
   JSONFileValueDeserializer deserializer(original_file_path);
-  scoped_ptr<Value> root;
+  std::unique_ptr<Value> root;
   root = deserializer.Deserialize(NULL, NULL);
   ASSERT_TRUE(root.get());
 
   // Now try writing.
   base::FilePath written_file_path = temp_dir_.path().Append(
       FILE_PATH_LITERAL("test_output.json"));
 
   ASSERT_FALSE(PathExists(written_file_path));
   JSONFileValueSerializer serializer(written_file_path);
   ASSERT_TRUE(serializer.Serialize(*root));
   ASSERT_TRUE(PathExists(written_file_path));
 
   // Now compare file contents.
   EXPECT_TRUE(TextContentsEqual(original_file_path, written_file_path));
   EXPECT_TRUE(base::DeleteFile(written_file_path, false));
 }
 
 TEST_F(JSONFileValueSerializerTest, NoWhitespace) {
   base::FilePath source_file_path;
   ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &source_file_path));
   source_file_path = source_file_path.Append(
       FILE_PATH_LITERAL("serializer_test_nowhitespace.json"));
   ASSERT_TRUE(PathExists(source_file_path));
   JSONFileValueDeserializer deserializer(source_file_path);
-  scoped_ptr<Value> root;
+  std::unique_ptr<Value> root;
   root = deserializer.Deserialize(NULL, NULL);
   ASSERT_TRUE(root.get());
 }
 
 }  // namespace
 
 }  // namespace base