detect preferences errors

base/json/json_reader.cc

 // Copyright (c) 2009 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_reader.h"
 
 #include "base/float_util.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
@@ skipping 77 matching lines @@
 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 */
 Value* JSONReader::Read(const std::string& json,
                         bool allow_trailing_comma) {
-  return ReadAndReturnError(json, allow_trailing_comma, NULL);
+  return ReadAndReturnError(json, allow_trailing_comma, NULL, NULL);
 }
 
 /* static */
 Value* JSONReader::ReadAndReturnError(const std::string& json,
                                       bool allow_trailing_comma,
-                                      std::string *error_message_out) {
+                                      int* error_code_out,
+                                      std::string* error_msg_out) {
   JSONReader reader = JSONReader();
   Value* root = reader.JsonToValue(json, true, allow_trailing_comma);
   if (root)
     return root;
 
-  if (error_message_out)
-    *error_message_out = reader.error_message();
+  if (error_code_out)
+    *error_code_out = reader.error_code();
+  if (error_msg_out)
+    *error_msg_out = reader.GetErrorMessage();
 
   return NULL;
 }
 
 /* static */
 std::string JSONReader::FormatErrorMessage(int line, int column,
-                                           const char* description) {
-  return StringPrintf("Line: %i, column: %i, %s",
-                      line, column, description);
+                                           const std::string& description) {
+  if (line || column) {
+    return StringPrintf("Line: %i, column: %i, %s",
+                        line, column, description.c_str());
+  }
+  return description;
+}
+
+/* static */
+std::string JSONReader::ErrorCodeToString(JsonParseError error_code) {
+  switch (error_code) {
+    case JSON_NO_ERROR:
+      return std::string();
+    case JSON_BAD_ROOT_ELEMENT_TYPE:
+      return kBadRootElementType;
+    case JSON_INVALID_ESCAPE:
+      return kInvalidEscape;
+    case JSON_SYNTAX_ERROR:
+      return kSyntaxError;
+    case JSON_TRAILING_COMMA:
+      return kTrailingComma;
+    case JSON_TOO_MUCH_NESTING:
+      return kTooMuchNesting;
+    case JSON_UNEXPECTED_DATA_AFTER_ROOT:
+      return kUnexpectedDataAfterRoot;
+    case JSON_UNSUPPORTED_ENCODING:
+      return kUnsupportedEncoding;
+    case JSON_UNQUOTED_DICTIONARY_KEY:
+      return kUnquotedDictionaryKey;
+    default:
+      NOTREACHED();
+      return std::string();
+  }
+}
+
+std::string JSONReader::GetErrorMessage() const {
+  return FormatErrorMessage(error_line_, error_col_,
+                            ErrorCodeToString(error_code_));
 }
 
 JSONReader::JSONReader()
     : start_pos_(NULL), json_pos_(NULL), stack_depth_(0),
-      allow_trailing_comma_(false) {}
+      allow_trailing_comma_(false),
+      error_code_(JSON_NO_ERROR), error_line_(0), error_col_(0) {}
 
 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;
+    error_code_ = JSON_UNSUPPORTED_ENCODING;
     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 NULL,
   // 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();
+  error_code_ = JSON_NO_ERROR;
 
   scoped_ptr<Value> root(BuildValue(check_root));
   if (root.get()) {
     if (ParseToken().type == Token::END_OF_INPUT) {
       return root.release();
     } else {
-      SetErrorMessage(kUnexpectedDataAfterRoot, json_pos_);
+      SetErrorCode(JSON_UNEXPECTED_DATA_AFTER_ROOT, json_pos_);
     }
   }
 
   // Default to calling errors "syntax errors".
-  if (error_message_.empty())
-    SetErrorMessage(kSyntaxError, json_pos_);
+  if (error_code_ == 0)
+    SetErrorCode(JSON_SYNTAX_ERROR, json_pos_);
 
   return NULL;
 }
 
 Value* JSONReader::BuildValue(bool is_root) {
   ++stack_depth_;
   if (stack_depth_ > kStackLimit) {
-    SetErrorMessage(kTooMuchNesting, json_pos_);
+    SetErrorCode(JSON_TOO_MUCH_NESTING, json_pos_);
     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_);
+    SetErrorCode(JSON_BAD_ROOT_ELEMENT_TYPE, json_pos_);
     return NULL;
   }
 
   scoped_ptr<Value> node;
 
   switch (token.type) {
     case Token::END_OF_INPUT:
     case Token::INVALID_TOKEN:
       return NULL;
 
@@ skipping 35 matching lines @@
 
           // 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_);
+                SetErrorCode(JSON_TRAILING_COMMA, json_pos_);
                 return NULL;
               }
               // Trailing comma OK, stop parsing the Array.
               break;
             }
           } else if (token.type != Token::ARRAY_END) {
             // Unexpected value after list value.  Bail out.
             return NULL;
           }
         }
         if (token.type != Token::ARRAY_END) {
           return NULL;
         }
         break;
       }
 
     case Token::OBJECT_BEGIN:
       {
         json_pos_ += token.length;
         token = ParseToken();
 
         node.reset(new DictionaryValue);
         while (token.type != Token::OBJECT_END) {
           if (token.type != Token::STRING) {
-            SetErrorMessage(kUnquotedDictionaryKey, json_pos_);
+            SetErrorCode(JSON_UNQUOTED_DICTIONARY_KEY, json_pos_);
             return NULL;
           }
           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);
@@ skipping 14 matching lines @@
           // 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_);
+                SetErrorCode(JSON_TRAILING_COMMA, json_pos_);
                 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.
             return NULL;
           }
         }
@@ skipping 69 matching lines @@
   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.
       switch (c) {
         case 'x':
           if (!ReadHexDigits(token, 2)) {
-            SetErrorMessage(kInvalidEscape, json_pos_ + token.length);
+            SetErrorCode(JSON_INVALID_ESCAPE, json_pos_ + token.length);
             return kInvalidToken;
           }
           break;
         case 'u':
           if (!ReadHexDigits(token, 4)) {
-            SetErrorMessage(kInvalidEscape, json_pos_ + token.length);
+            SetErrorCode(JSON_INVALID_ESCAPE, json_pos_ + token.length);
             return kInvalidToken;
           }
           break;
         case '\\':
         case '/':
         case 'b':
         case 'f':
         case 'n':
         case 'r':
         case 't':
         case 'v':
         case '"':
           break;
         default:
-          SetErrorMessage(kInvalidEscape, json_pos_ + token.length);
+          SetErrorCode(JSON_INVALID_ESCAPE, json_pos_ + token.length);
           return kInvalidToken;
       }
     } else if ('"' == c) {
       ++token.length;
       return token;
     }
     ++token.length;
     c = token.NextChar();
   }
   return kInvalidToken;
@@ skipping 191 matching lines @@
         return true;
       }
       ++json_pos_;
     }
   } else {
     return false;
   }
   return true;
 }
 
-void JSONReader::SetErrorMessage(const char* description,
-                                 const wchar_t* error_pos) {
+void JSONReader::SetErrorCode(JsonParseError error,
+                              const wchar_t* error_pos) {
   int line_number = 1;
   int column_number = 1;
 
   // Figure out the line and column the error occured at.
   for (const wchar_t* pos = start_pos_; pos != error_pos; ++pos) {
     if (*pos == '\0') {
       NOTREACHED();
       return;
     }
 
     if (*pos == '\n') {
       ++line_number;
       column_number = 1;
     } else {
       ++column_number;
     }
   }
 
-  error_message_ = FormatErrorMessage(line_number, column_number, description);
+  error_line_ = line_number;
+  error_col_ = column_number;
+  error_code_ = error;
 }
 
 }  // namespace base