Remove more usage of the base::ListValue::Append(Value*) overload.

base/json/json_parser.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 <cmath>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 449 matching lines @@
       }
       previous_char = next_char;
     }
 
     // If the comment is unterminated, GetNextToken will report T_END_OF_INPUT.
   }
 
   return false;
 }
 
-Value* JSONParser::ParseNextToken() {
+std::unique_ptr<Value> JSONParser::ParseNextToken() {
   return ParseToken(GetNextToken());
 }
 
-Value* JSONParser::ParseToken(Token token) {
+std::unique_ptr<Value> JSONParser::ParseToken(Token token) {
   switch (token) {
     case T_OBJECT_BEGIN:
       return ConsumeDictionary();
     case T_ARRAY_BEGIN:
       return ConsumeList();
     case T_STRING:
       return ConsumeString();
     case T_NUMBER:
       return ConsumeNumber();
     case T_BOOL_TRUE:
     case T_BOOL_FALSE:
     case T_NULL:
       return ConsumeLiteral();
     default:
       ReportError(JSONReader::JSON_UNEXPECTED_TOKEN, 1);
       return nullptr;
   }
 }
 
-Value* JSONParser::ConsumeDictionary() {
+std::unique_ptr<Value> JSONParser::ConsumeDictionary() {
   if (*pos_ != '{') {
     ReportError(JSONReader::JSON_UNEXPECTED_TOKEN, 1);
     return nullptr;
   }
 
   StackMarker depth_check(&stack_depth_);
   if (depth_check.IsTooDeep()) {
     ReportError(JSONReader::JSON_TOO_MUCH_NESTING, 1);
     return nullptr;
   }
@@ skipping 17 matching lines @@
     // Read the separator.
     NextChar();
     token = GetNextToken();
     if (token != T_OBJECT_PAIR_SEPARATOR) {
       ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
       return nullptr;
     }
 
     // The next token is the value. Ownership transfers to |dict|.
     NextChar();
-    Value* value = ParseNextToken();
+    std::unique_ptr<Value> value = ParseNextToken();
     if (!value) {
       // ReportError from deeper level.
       return nullptr;
     }
 
-    dict->SetWithoutPathExpansion(key.AsString(), value);
+    dict->SetWithoutPathExpansion(key.AsString(), std::move(value));
 
     NextChar();
     token = GetNextToken();
     if (token == T_LIST_SEPARATOR) {
       NextChar();
       token = GetNextToken();
       if (token == T_OBJECT_END && !(options_ & JSON_ALLOW_TRAILING_COMMAS)) {
         ReportError(JSONReader::JSON_TRAILING_COMMA, 1);
         return nullptr;
       }
     } else if (token != T_OBJECT_END) {
       ReportError(JSONReader::JSON_SYNTAX_ERROR, 0);
       return nullptr;
     }
   }
 
-  return dict.release();
+  return std::move(dict);
 }
 
-Value* JSONParser::ConsumeList() {
+std::unique_ptr<Value> JSONParser::ConsumeList() {
   if (*pos_ != '[') {
     ReportError(JSONReader::JSON_UNEXPECTED_TOKEN, 1);
     return nullptr;
   }
 
   StackMarker depth_check(&stack_depth_);
   if (depth_check.IsTooDeep()) {
     ReportError(JSONReader::JSON_TOO_MUCH_NESTING, 1);
     return nullptr;
   }
 
   std::unique_ptr<ListValue> list(new ListValue);
 
   NextChar();
   Token token = GetNextToken();
   while (token != T_ARRAY_END) {
-    Value* item = ParseToken(token);
+    std::unique_ptr<Value> item = ParseToken(token);
     if (!item) {
       // ReportError from deeper level.
       return nullptr;
     }
 
-    list->Append(item);
+    list->Append(std::move(item));
 
     NextChar();
     token = GetNextToken();
     if (token == T_LIST_SEPARATOR) {
       NextChar();
       token = GetNextToken();
       if (token == T_ARRAY_END && !(options_ & JSON_ALLOW_TRAILING_COMMAS)) {
         ReportError(JSONReader::JSON_TRAILING_COMMA, 1);
         return nullptr;
       }
     } else if (token != T_ARRAY_END) {
       ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
       return nullptr;
     }
   }
 
-  return list.release();
+  return std::move(list);
 }
 
-Value* JSONParser::ConsumeString() {
+std::unique_ptr<Value> JSONParser::ConsumeString() {
   StringBuilder string;
   if (!ConsumeStringRaw(&string))
     return nullptr;
 
   // Create the Value representation, using a hidden root, if configured
   // to do so, and if the string can be represented by StringPiece.
   if (string.CanBeStringPiece() && !(options_ & JSON_DETACHABLE_CHILDREN))
-    return new JSONStringValue(string.AsStringPiece());
+    return base::MakeUnique<JSONStringValue>(string.AsStringPiece());
 
   if (string.CanBeStringPiece())
     string.Convert();
-  return new StringValue(string.AsString());
+  return base::MakeUnique<StringValue>(string.AsString());
 }
 
 bool JSONParser::ConsumeStringRaw(StringBuilder* out) {
   if (*pos_ != '"') {
     ReportError(JSONReader::JSON_UNEXPECTED_TOKEN, 1);
     return false;
   }
 
   // StringBuilder will internally build a StringPiece unless a UTF-16
   // conversion occurs, at which point it will perform a copy into a
@@ skipping 196 matching lines @@
     char utf8_units[4] = { 0 };
     int offset = 0;
     CBU8_APPEND_UNSAFE(utf8_units, offset, point);
     dest->Convert();
     // CBU8_APPEND_UNSAFE can overwrite up to 4 bytes, so utf8_units may not be
     // zero terminated at this point.  |offset| contains the correct length.
     dest->AppendString(std::string(utf8_units, offset));
   }
 }
 
-Value* JSONParser::ConsumeNumber() {
+std::unique_ptr<Value> JSONParser::ConsumeNumber() {
   const char* num_start = pos_;
   const int start_index = index_;
   int end_index = start_index;
 
   if (*pos_ == '-')
     NextChar();
 
   if (!ReadInt(false)) {
     ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
     return nullptr;
@@ skipping 44 matching lines @@
       return nullptr;
   }
 
   pos_ = exit_pos;
   index_ = exit_index;
 
   StringPiece num_string(num_start, end_index - start_index);
 
   int num_int;
   if (StringToInt(num_string, &num_int))
-    return new FundamentalValue(num_int);
+    return base::MakeUnique<FundamentalValue>(num_int);
 
   double num_double;
   if (StringToDouble(num_string.as_string(), &num_double) &&
       std::isfinite(num_double)) {
-    return new FundamentalValue(num_double);
+    return base::MakeUnique<FundamentalValue>(num_double);
   }
 
   return nullptr;
 }
 
 bool JSONParser::ReadInt(bool allow_leading_zeros) {
   char first = *pos_;
   int len = 0;
 
   char c = first;
   while (CanConsume(1) && IsAsciiDigit(c)) {
     c = *NextChar();
     ++len;
   }
 
   if (len == 0)
     return false;
 
   if (!allow_leading_zeros && len > 1 && first == '0')
     return false;
 
   return true;
 }
 
-Value* JSONParser::ConsumeLiteral() {
+std::unique_ptr<Value> JSONParser::ConsumeLiteral() {
   switch (*pos_) {
     case 't': {
       const char kTrueLiteral[] = "true";
       const int kTrueLen = static_cast<int>(strlen(kTrueLiteral));
       if (!CanConsume(kTrueLen - 1) ||
           !StringsAreEqual(pos_, kTrueLiteral, kTrueLen)) {
         ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
         return nullptr;
       }
       NextNChars(kTrueLen - 1);
-      return new FundamentalValue(true);
+      return base::MakeUnique<FundamentalValue>(true);
     }
     case 'f': {
       const char kFalseLiteral[] = "false";
       const int kFalseLen = static_cast<int>(strlen(kFalseLiteral));
       if (!CanConsume(kFalseLen - 1) ||
           !StringsAreEqual(pos_, kFalseLiteral, kFalseLen)) {
         ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
         return nullptr;
       }
       NextNChars(kFalseLen - 1);
-      return new FundamentalValue(false);
+      return base::MakeUnique<FundamentalValue>(false);
     }
     case 'n': {
       const char kNullLiteral[] = "null";
       const int kNullLen = static_cast<int>(strlen(kNullLiteral));
       if (!CanConsume(kNullLen - 1) ||
           !StringsAreEqual(pos_, kNullLiteral, kNullLen)) {
         ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
         return nullptr;
       }
       NextNChars(kNullLen - 1);
-      return Value::CreateNullValue().release();
+      return Value::CreateNullValue();
     }
     default:
       ReportError(JSONReader::JSON_UNEXPECTED_TOKEN, 1);
       return nullptr;
   }
 }
 
 // static
 bool JSONParser::StringsAreEqual(const char* one, const char* two, size_t len) {
   return strncmp(one, two, len) == 0;
@@ skipping 11 matching lines @@
                                            const std::string& description) {
   if (line || column) {
     return StringPrintf("Line: %i, column: %i, %s",
         line, column, description.c_str());
   }
   return description;
 }
 
 }  // namespace internal
 }  // namespace base