detect preferences errors

base/json/json_reader.h

 // 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.
 //
 // A JSON parser.  Converts strings of JSON into a Value object (see
 // base/values.h).
 // http://www.ietf.org/rfc/rfc4627.txt?number=4627
 //
 // Known limitations/deviations from the RFC:
 // - Only knows how to parse ints within the range of a signed 32 bit int and
@@ skipping 64 matching lines @@
 
     // End should be one char past the end of the token.
     int length;
 
     // Get the character that's one past the end of this token.
     wchar_t NextChar() {
       return *(begin + length);
     }
   };
 
-  // Error messages that can be returned.
+  // Error codes during parsing.
+  enum JsonParseError {
+    JSON_NO_ERROR = 0,
+    JSON_BAD_ROOT_ELEMENT_TYPE,
+    JSON_INVALID_ESCAPE,
+    JSON_SYNTAX_ERROR,
+    JSON_TRAILING_COMMA,
+    JSON_TOO_MUCH_NESTING,
+    JSON_UNEXPECTED_DATA_AFTER_ROOT,
+    JSON_UNSUPPORTED_ENCODING,
+    JSON_UNQUOTED_DICTIONARY_KEY,
+  };
+
+  // String versions of parse error codes.
   static const char* kBadRootElementType;
   static const char* kInvalidEscape;
   static const char* kSyntaxError;
   static const char* kTrailingComma;
   static const char* kTooMuchNesting;
   static const char* kUnexpectedDataAfterRoot;
   static const char* kUnsupportedEncoding;
   static const char* kUnquotedDictionaryKey;
 
   JSONReader();
 
   // Reads and parses |json|, returning a Value. The caller owns the returned
   // instance. If |json| is not a properly formed JSON string, returns NULL.
   // If |allow_trailing_comma| is true, we will ignore trailing commas in
   // objects and arrays even though this goes against the RFC.
   static Value* Read(const std::string& json, bool allow_trailing_comma);
 
-  // Reads and parses |json| like Read(). |error_message_out| is optional. If
-  // specified and NULL is returned, |error_message_out| will be populated with
-  // a string describing the error. Otherwise, |error_message_out| is
-  // unmodified.
+  // Reads and parses |json| like Read(). |error_code_out| and |error_msg_out|
+  // are optional. If specified and NULL is returned, they will be populated
+  // an error code and a formatted error message (including error location if
+  // appropriate). Otherwise, they will be unmodified.
   static Value* ReadAndReturnError(const std::string& json,
                                    bool allow_trailing_comma,
-                                   std::string* error_message_out);
+                                   int* error_code_out,
+                                   std::string* error_msg_out);
 
-  // Returns the error message if the last call to JsonToValue() failed. If the
-  // last call did not fail, returns a valid empty string.
-  std::string error_message() { return error_message_; }
+  // Converts a JSON parse error code into a human readable message.
+  // Returns an empty string if error_code is JSON_NO_ERROR.
+  static std::string ErrorCodeToString(JsonParseError error_code);
+
+  // Returns the error code if the last call to JsonToValue() failed.
+  // Returns JSON_NO_ERROR otherwise.
+  JsonParseError error_code() const { return error_code_; }
+
+  // Converts error_code_ to a human-readable string, including line and column
+  // numbers if appropriate.
+  std::string GetErrorMessage() const;
 
   // Reads and parses |json|, returning a Value. The caller owns the returned
   // instance. If |json| is not a properly formed JSON string, returns NULL and
   // a detailed error can be retrieved from |error_message()|.
   // If |check_root| is true, we require that the root object be an object or
   // array. Otherwise, it can be any valid JSON type.
   // If |allow_trailing_comma| is true, we will ignore trailing commas in
   // objects and arrays even though this goes against the RFC.
   Value* JsonToValue(const std::string& json, bool check_root,
                      bool allow_trailing_comma);
 
  private:
   static std::string FormatErrorMessage(int line, int column,
-                                        const char* description);
+                                        const std::string& description);
 
   DISALLOW_COPY_AND_ASSIGN(JSONReader);
 
   FRIEND_TEST(JSONReaderTest, Reading);
   FRIEND_TEST(JSONReaderTest, ErrorMessages);
 
   // Recursively build Value.  Returns NULL if we don't have a valid JSON
   // string.  If |is_root| is true, we verify that the root element is either
   // an object or an array.
   Value* BuildValue(bool is_root);
@@ skipping 25 matching lines @@
   // Increments |json_pos_| past leading whitespace and comments.
   void EatWhitespaceAndComments();
 
   // If |json_pos_| is at the start of a comment, eat it, otherwise, returns
   // false.
   bool EatComment();
 
   // Checks if |json_pos_| matches str.
   bool NextStringMatch(const std::wstring& str);
 
-  // Creates the error message that will be returned to the caller. The current
+  // Sets the error code that will be returned to the caller. The current
   // line and column are determined and added into the final message.
-  void SetErrorMessage(const char* description, const wchar_t* error_pos);
+  void SetErrorCode(const JsonParseError error, const wchar_t* error_pos);
 
   // Pointer to the starting position in the input string.
   const wchar_t* start_pos_;
 
   // Pointer to the current position in the input string.
   const wchar_t* json_pos_;
 
   // Used to keep track of how many nested lists/dicts there are.
   int stack_depth_;
 
   // A parser flag that allows trailing commas in objects and arrays.
   bool allow_trailing_comma_;
 
-  // Contains the error message for the last call to JsonToValue(), if any.
-  std::string error_message_;
+  // Contains the error code for the last call to JsonToValue(), if any.
+  JsonParseError error_code_;
+  int error_line_;
+  int error_col_;
 };
 
 }  // namespace base
 
 #endif  // BASE_JSON_JSON_READER_H_