Change the signature of JSONReader::Read() and related methods to be more

base/json_reader.cc

 // Copyright (c) 2006-2008 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_reader.h"
 
 #include "base/float_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/values.h"
@@ skipping 71 matching lines @@
 const char* JSONReader::kTooMuchNesting =
     "Too much nesting.";
 const char* JSONReader::kUnexpectedDataAfterRoot =
     "Unexpected data after root element.";
 const char* JSONReader::kUnsupportedEncoding =
     "Unsupported encoding. JSON must be UTF-8.";
 const char* JSONReader::kUnquotedDictionaryKey =
     "Dictionary keys must be quoted.";
 
 /* static */
-bool JSONReader::Read(const std::string& json,
-                      Value** root,
-                      bool allow_trailing_comma) {
-  return ReadAndReturnError(json, root, allow_trailing_comma, NULL);
+Value* JSONReader::Read(const std::string& json,
+                        bool allow_trailing_comma) {
+  return ReadAndReturnError(json, allow_trailing_comma, NULL);
 }
 
 /* static */
-bool JSONReader::ReadAndReturnError(const std::string& json,
-                                    Value** root,
-                                    bool allow_trailing_comma,
-                                    std::string *error_message_out) {
+Value* JSONReader::ReadAndReturnError(const std::string& json,
+                                      bool allow_trailing_comma,
+                                      std::string *error_message_out) {
   JSONReader reader = JSONReader();
-  if (reader.JsonToValue(json, root, true, allow_trailing_comma)) {
-    return true;
-  } else {
-    if (error_message_out)
-      *error_message_out = reader.error_message();
-    return false;
-  }
+  Value* root = reader.JsonToValue(json, true, allow_trailing_comma);
+  if (root)
+    return root;
+
+  if (error_message_out)
+    *error_message_out = reader.error_message();
+
+  return NULL;
 }
 
 /* static */
 std::string JSONReader::FormatErrorMessage(int line, int column,
                                            const char* description) {
   return StringPrintf("Line: %i, column: %i, %s",
                       line, column, description);
 }
 
 JSONReader::JSONReader()
   : start_pos_(NULL), json_pos_(NULL), stack_depth_(0),
     allow_trailing_comma_(false) {}
 
-bool JSONReader::JsonToValue(const std::string& json, Value** root,
-                             bool check_root, bool allow_trailing_comma) {
+Value* JSONReader::JsonToValue(const std::string& json, bool check_root,
+                               bool allow_trailing_comma) {
   // The input must be in UTF-8.
   if (!IsStringUTF8(json.c_str())) {
     error_message_ = kUnsupportedEncoding;
-    return false;
+    return NULL;
   }
 
   // The conversion from UTF8 to wstring removes null bytes for us
   // (a good thing).
   std::wstring json_wide(UTF8ToWide(json));
   start_pos_ = json_wide.c_str();
 
   // When the input JSON string starts with a UTF-8 Byte-Order-Mark
   // (0xEF, 0xBB, 0xBF), the UTF8ToWide() function converts it to a Unicode
   // BOM (U+FEFF). To avoid the JSONReader::BuildValue() function from
   // mis-treating a Unicode BOM as an invalid character and returning false,
   // skip a converted Unicode BOM if it exists.
   if (!json_wide.empty() && start_pos_[0] == 0xFEFF) {
     ++start_pos_;
   }
 
   json_pos_ = start_pos_;
   allow_trailing_comma_ = allow_trailing_comma;
   stack_depth_ = 0;
   error_message_.clear();
 
-  Value* temp_root = NULL;
-
-  // Only modify root_ if we have valid JSON and nothing else.
-  if (BuildValue(&temp_root, check_root)) {
+  scoped_ptr<Value> root(BuildValue(check_root));
+  if (root.get()) {
     if (ParseToken().type == Token::END_OF_INPUT) {
-      *root = temp_root;
-      return true;
+      return root.release();
     } else {
       SetErrorMessage(kUnexpectedDataAfterRoot, json_pos_);
     }
   }
 
   // Default to calling errors "syntax errors".
   if (error_message_.empty())
     SetErrorMessage(kSyntaxError, json_pos_);
 
-  if (temp_root)
-    delete temp_root;
-  return false;
+  return NULL;
 }
 
-bool JSONReader::BuildValue(Value** node, bool is_root) {
+Value* JSONReader::BuildValue(bool is_root) {
   ++stack_depth_;
   if (stack_depth_ > kStackLimit) {
     SetErrorMessage(kTooMuchNesting, json_pos_);
-    return false;
+    return NULL;
   }
 
   Token token = ParseToken();
   // The root token must be an array or an object.
   if (is_root && token.type != Token::OBJECT_BEGIN &&
       token.type != Token::ARRAY_BEGIN) {
     SetErrorMessage(kBadRootElementType, json_pos_);
-    return false;
+    return NULL;
   }
 
+  scoped_ptr<Value> node;
+
   switch (token.type) {
     case Token::END_OF_INPUT:
     case Token::INVALID_TOKEN:
-      return false;
+      return NULL;
 
     case Token::NULL_TOKEN:
-      *node = Value::CreateNullValue();
+      node.reset(Value::CreateNullValue());
       break;
 
     case Token::BOOL_TRUE:
-      *node = Value::CreateBooleanValue(true);
+      node.reset(Value::CreateBooleanValue(true));
       break;
 
     case Token::BOOL_FALSE:
-      *node = Value::CreateBooleanValue(false);
+      node.reset(Value::CreateBooleanValue(false));
       break;
 
     case Token::NUMBER:
-      if (!DecodeNumber(token, node))
-        return false;
+      node.reset(DecodeNumber(token));
+      if (!node.get())
+        return NULL;
       break;
 
     case Token::STRING:
-      if (!DecodeString(token, node))
-        return false;
+      node.reset(DecodeString(token));
+      if (!node.get())
+        return NULL;
       break;
 
     case Token::ARRAY_BEGIN:
       {
         json_pos_ += token.length;
         token = ParseToken();
 
-        ListValue* array = new ListValue;
+        node.reset(new ListValue());
         while (token.type != Token::ARRAY_END) {
-          Value* array_node = NULL;
-          if (!BuildValue(&array_node, false)) {
-            delete array;
-            return false;
+          Value* array_node = BuildValue(false);
+          if (!array_node) {
+            return NULL;
           }
-          array->Append(array_node);
+          static_cast<ListValue*>(node.get())->Append(array_node);
 
           // After a list value, we expect a comma or the end of the list.
           token = ParseToken();
           if (token.type == Token::LIST_SEPARATOR) {
             json_pos_ += token.length;
             token = ParseToken();
             // Trailing commas are invalid according to the JSON RFC, but some
             // consumers need the parsing leniency, so handle accordingly.
             if (token.type == Token::ARRAY_END) {
               if (!allow_trailing_comma_) {
                 SetErrorMessage(kTrailingComma, json_pos_);
-                delete array;
-                return false;
+                return NULL;
               }
               // Trailing comma OK, stop parsing the Array.
               break;
             }
           } else if (token.type != Token::ARRAY_END) {
             // Unexpected value after list value.  Bail out.
-            delete array;
-            return false;
+            return NULL;
           }
         }
         if (token.type != Token::ARRAY_END) {
-          delete array;
-          return false;
+          return NULL;
         }
-        *node = array;
         break;
       }
 
     case Token::OBJECT_BEGIN:
       {
         json_pos_ += token.length;
         token = ParseToken();
 
-        DictionaryValue* dict = new DictionaryValue;
+        node.reset(new DictionaryValue);
         while (token.type != Token::OBJECT_END) {
           if (token.type != Token::STRING) {
             SetErrorMessage(kUnquotedDictionaryKey, json_pos_);
-            delete dict;
-            return false;
+            return NULL;
           }
-          Value* dict_key_value = NULL;
-          if (!DecodeString(token, &dict_key_value)) {
-            delete dict;
-            return false;
-          }
+          scoped_ptr<Value> dict_key_value(DecodeString(token));
+          if (!dict_key_value.get())
+            return NULL;
+
           // Convert the key into a wstring.
           std::wstring dict_key;
           bool success = dict_key_value->GetAsString(&dict_key);
           DCHECK(success);
-          delete dict_key_value;
 
           json_pos_ += token.length;
           token = ParseToken();
-          if (token.type != Token::OBJECT_PAIR_SEPARATOR) {
-            delete dict;
-            return false;
-          }
+          if (token.type != Token::OBJECT_PAIR_SEPARATOR)
+            return NULL;
 
           json_pos_ += token.length;
           token = ParseToken();
-          Value* dict_value = NULL;
-          if (!BuildValue(&dict_value, false)) {
-            delete dict;
-            return false;
-          }
-          dict->Set(dict_key, dict_value);
+          Value* dict_value = BuildValue(false);
+          if (!dict_value)
+            return NULL;
+          static_cast<DictionaryValue*>(node.get())->Set(dict_key, dict_value);
 
           // After a key/value pair, we expect a comma or the end of the
           // object.
           token = ParseToken();
           if (token.type == Token::LIST_SEPARATOR) {
             json_pos_ += token.length;
             token = ParseToken();
             // Trailing commas are invalid according to the JSON RFC, but some
             // consumers need the parsing leniency, so handle accordingly.
             if (token.type == Token::OBJECT_END) {
               if (!allow_trailing_comma_) {
                 SetErrorMessage(kTrailingComma, json_pos_);
-                delete dict;
-                return false;
+                return NULL;
               }
               // Trailing comma OK, stop parsing the Object.
               break;
             }
           } else if (token.type != Token::OBJECT_END) {
             // Unexpected value after last object value.  Bail out.
-            delete dict;
-            return false;
+            return NULL;
           }
         }
-        if (token.type != Token::OBJECT_END) {
-          delete dict;
-          return false;
-        }
-        *node = dict;
+        if (token.type != Token::OBJECT_END)
+          return NULL;
+
         break;
       }
 
     default:
       // We got a token that's not a value.
-      return false;
+      return NULL;
   }
   json_pos_ += token.length;
 
   --stack_depth_;
-  return true;
+  return node.release();
 }
 
 JSONReader::Token JSONReader::ParseNumberToken() {
   // We just grab the number here.  We validate the size in DecodeNumber.
   // According   to RFC4627, a valid number is: [minus] int [frac] [exp]
   Token token(Token::NUMBER, json_pos_, 0);
   wchar_t c = *json_pos_;
   if ('-' == c) {
     ++token.length;
     c = token.NextChar();
@@ skipping 19 matching lines @@
       ++token.length;
       c = token.NextChar();
     }
     if (!ReadInt(token, true))
       return kInvalidToken;
   }
 
   return token;
 }
 
-bool JSONReader::DecodeNumber(const Token& token, Value** node) {
+Value* JSONReader::DecodeNumber(const Token& token) {
   const std::wstring num_string(token.begin, token.length);
 
   int num_int;
-  if (StringToInt(num_string, &num_int)) {
-    *node = Value::CreateIntegerValue(num_int);
-    return true;
-  }
+  if (StringToInt(num_string, &num_int))
+    return Value::CreateIntegerValue(num_int);
 
   double num_double;
-  if (StringToDouble(num_string, &num_double) && base::IsFinite(num_double)) {
-    *node = Value::CreateRealValue(num_double);
-    return true;
-  }
+  if (StringToDouble(num_string, &num_double) && base::IsFinite(num_double))
+    return Value::CreateRealValue(num_double);
 
-  return false;
+  return NULL;
 }
 
 JSONReader::Token JSONReader::ParseStringToken() {
   Token token(Token::STRING, json_pos_, 1);
   wchar_t c = token.NextChar();
   while ('\0' != c) {
     if ('\\' == c) {
       ++token.length;
       c = token.NextChar();
       // Make sure the escaped char is valid.
@@ skipping 27 matching lines @@
     } else if ('"' == c) {
       ++token.length;
       return token;
     }
     ++token.length;
     c = token.NextChar();
   }
   return kInvalidToken;
 }
 
-bool JSONReader::DecodeString(const Token& token, Value** node) {
+Value* JSONReader::DecodeString(const Token& token) {
   std::wstring decoded_str;
   decoded_str.reserve(token.length - 2);
 
   for (int i = 1; i < token.length - 1; ++i) {
     wchar_t c = *(token.begin + i);
     if ('\\' == c) {
       ++i;
       c = *(token.begin + i);
       switch (c) {
         case '"':
@@ skipping 30 matching lines @@
                                 (HexToInt(*(token.begin + i + 2)) << 8) +
                                 (HexToInt(*(token.begin + i + 3)) << 4) +
                                 HexToInt(*(token.begin + i + 4)));
           i += 4;
           break;
 
         default:
           // We should only have valid strings at this point.  If not,
           // ParseStringToken didn't do it's job.
           NOTREACHED();
-          return false;
+          return NULL;
       }
     } else {
       // Not escaped
       decoded_str.push_back(c);
     }
   }
-  *node = Value::CreateStringValue(decoded_str);
-
-  return true;
+  return Value::CreateStringValue(decoded_str);
 }
 
 JSONReader::Token JSONReader::ParseToken() {
   static const std::wstring kNullString(L"null");
   static const std::wstring kTrueString(L"true");
   static const std::wstring kFalseString(L"false");
 
   EatWhitespaceAndComments();
 
   Token token(Token::INVALID_TOKEN, 0, 0);
@@ skipping 146 matching lines @@
     if (*pos == '\n') {
       ++line_number;
       column_number = 1;
     } else {
       ++column_number;
     }
   }
 
   error_message_ = FormatErrorMessage(line_number, column_number, description);
 }