Convert //base to use std::unique_ptr

base/json/json_parser_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/json/json_parser.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/json/json_reader.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 
 class JSONParserTest : public testing::Test {
  public:
   JSONParser* NewTestParser(const std::string& input) {
     JSONParser* parser = new JSONParser(JSON_PARSE_RFC);
     parser->start_pos_ = input.data();
     parser->pos_ = parser->start_pos_;
     parser->end_pos_ = parser->start_pos_ + input.length();
     return parser;
   }
 
   void TestLastThree(JSONParser* parser) {
     EXPECT_EQ(',', *parser->NextChar());
     EXPECT_EQ('|', *parser->NextChar());
     EXPECT_EQ('\0', *parser->NextChar());
     EXPECT_EQ(parser->end_pos_, parser->pos_);
   }
 };
 
 TEST_F(JSONParserTest, NextChar) {
   std::string input("Hello world");
-  scoped_ptr<JSONParser> parser(NewTestParser(input));
+  std::unique_ptr<JSONParser> parser(NewTestParser(input));
 
   EXPECT_EQ('H', *parser->pos_);
   for (size_t i = 1; i < input.length(); ++i) {
     EXPECT_EQ(input[i], *parser->NextChar());
   }
   EXPECT_EQ(parser->end_pos_, parser->NextChar());
 }
 
 TEST_F(JSONParserTest, ConsumeString) {
   std::string input("\"test\",|");
-  scoped_ptr<JSONParser> parser(NewTestParser(input));
-  scoped_ptr<Value> value(parser->ConsumeString());
+  std::unique_ptr<JSONParser> parser(NewTestParser(input));
+  std::unique_ptr<Value> value(parser->ConsumeString());
   EXPECT_EQ('"', *parser->pos_);
 
   TestLastThree(parser.get());
 
   ASSERT_TRUE(value.get());
   std::string str;
   EXPECT_TRUE(value->GetAsString(&str));
   EXPECT_EQ("test", str);
 }
 
 TEST_F(JSONParserTest, ConsumeList) {
   std::string input("[true, false],|");
-  scoped_ptr<JSONParser> parser(NewTestParser(input));
-  scoped_ptr<Value> value(parser->ConsumeList());
+  std::unique_ptr<JSONParser> parser(NewTestParser(input));
+  std::unique_ptr<Value> value(parser->ConsumeList());
   EXPECT_EQ(']', *parser->pos_);
 
   TestLastThree(parser.get());
 
   ASSERT_TRUE(value.get());
   base::ListValue* list;
   EXPECT_TRUE(value->GetAsList(&list));
   EXPECT_EQ(2u, list->GetSize());
 }
 
 TEST_F(JSONParserTest, ConsumeDictionary) {
   std::string input("{\"abc\":\"def\"},|");
-  scoped_ptr<JSONParser> parser(NewTestParser(input));
-  scoped_ptr<Value> value(parser->ConsumeDictionary());
+  std::unique_ptr<JSONParser> parser(NewTestParser(input));
+  std::unique_ptr<Value> value(parser->ConsumeDictionary());
   EXPECT_EQ('}', *parser->pos_);
 
   TestLastThree(parser.get());
 
   ASSERT_TRUE(value.get());
   base::DictionaryValue* dict;
   EXPECT_TRUE(value->GetAsDictionary(&dict));
   std::string str;
   EXPECT_TRUE(dict->GetString("abc", &str));
   EXPECT_EQ("def", str);
 }
 
 TEST_F(JSONParserTest, ConsumeLiterals) {
   // Literal |true|.
   std::string input("true,|");
-  scoped_ptr<JSONParser> parser(NewTestParser(input));
-  scoped_ptr<Value> value(parser->ConsumeLiteral());
+  std::unique_ptr<JSONParser> parser(NewTestParser(input));
+  std::unique_ptr<Value> value(parser->ConsumeLiteral());
   EXPECT_EQ('e', *parser->pos_);
 
   TestLastThree(parser.get());
 
   ASSERT_TRUE(value.get());
   bool bool_value = false;
   EXPECT_TRUE(value->GetAsBoolean(&bool_value));
   EXPECT_TRUE(bool_value);
 
   // Literal |false|.
@@ skipping 16 matching lines @@
 
   TestLastThree(parser.get());
 
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(value->IsType(Value::TYPE_NULL));
 }
 
 TEST_F(JSONParserTest, ConsumeNumbers) {
   // Integer.
   std::string input("1234,|");
-  scoped_ptr<JSONParser> parser(NewTestParser(input));
-  scoped_ptr<Value> value(parser->ConsumeNumber());
+  std::unique_ptr<JSONParser> parser(NewTestParser(input));
+  std::unique_ptr<Value> value(parser->ConsumeNumber());
   EXPECT_EQ('4', *parser->pos_);
 
   TestLastThree(parser.get());
 
   ASSERT_TRUE(value.get());
   int number_i;
   EXPECT_TRUE(value->GetAsInteger(&number_i));
   EXPECT_EQ(1234, number_i);
 
   // Negative integer.
@@ skipping 55 matching lines @@
 
   ASSERT_TRUE(value.get());
   EXPECT_TRUE(value->GetAsDouble(&number_d));
   EXPECT_EQ(420, number_d);
 }
 
 TEST_F(JSONParserTest, ErrorMessages) {
   // Error strings should not be modified in case of success.
   std::string error_message;
   int error_code = 0;
-  scoped_ptr<Value> root = JSONReader::ReadAndReturnError(
+  std::unique_ptr<Value> root = JSONReader::ReadAndReturnError(
       "[42]", JSON_PARSE_RFC, &error_code, &error_message);
   EXPECT_TRUE(error_message.empty());
   EXPECT_EQ(0, error_code);
 
   // Test line and column counting
   const char big_json[] = "[\n0,\n1,\n2,\n3,4,5,6 7,\n8,\n9\n]";
   // error here ----------------------------------^
   root = JSONReader::ReadAndReturnError(big_json, JSON_PARSE_RFC, &error_code,
                                         &error_message);
   EXPECT_FALSE(root.get());
@@ skipping 83 matching lines @@
   EXPECT_EQ(JSONReader::JSON_INVALID_ESCAPE, error_code);
 }
 
 TEST_F(JSONParserTest, Decode4ByteUtf8Char) {
   // This test strings contains a 4 byte unicode character (a smiley!) that the
   // reader should be able to handle (the character is \xf0\x9f\x98\x87).
   const char kUtf8Data[] =
       "[\"😇\",[],[],[],{\"google:suggesttype\":[]}]";
   std::string error_message;
   int error_code = 0;
-  scoped_ptr<Value> root = JSONReader::ReadAndReturnError(
+  std::unique_ptr<Value> root = JSONReader::ReadAndReturnError(
       kUtf8Data, JSON_PARSE_RFC, &error_code, &error_message);
   EXPECT_TRUE(root.get()) << error_message;
 }
 
 TEST_F(JSONParserTest, DecodeUnicodeNonCharacter) {
   // Tests Unicode code points (encoded as escaped UTF-16) that are not valid
   // characters.
   EXPECT_FALSE(JSONReader::Read("[\"\\ufdd0\"]"));
   EXPECT_FALSE(JSONReader::Read("[\"\\ufffe\"]"));
   EXPECT_FALSE(JSONReader::Read("[\"\\ud83f\\udffe\"]"));
 }
 
 }  // namespace internal
 }  // namespace base