Improve JSONReader performance by up to 55% by using std::string instead of wstring.

base/json/json_reader.h

 // Copyright (c) 2011 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 53 matching lines @@
      NUMBER,
      BOOL_TRUE,              // true
      BOOL_FALSE,             // false
      NULL_TOKEN,             // null
      LIST_SEPARATOR,         // ,
      OBJECT_PAIR_SEPARATOR,  // :
      END_OF_INPUT,
      INVALID_TOKEN,
     };
 
-    Token(Type t, const wchar_t* b, int len)
+    Token(Type t, const char* b, int len)
         : type(t), begin(b), length(len) {}
 
     // Get the character that's one past the end of this token.
-    wchar_t NextChar() {
+    char NextChar() {
       return *(begin + length);
     }
 
     static Token CreateInvalidToken() {
       return Token(INVALID_TOKEN, 0, 0);
     }
 
     Type type;
 
     // A pointer into JSONReader::json_pos_ that's the beginning of this token.
-    const wchar_t* begin;
+    const char* begin;
 
     // End should be one char past the end of the token.
     int length;
   };
 
   // Error codes during parsing.
   enum JsonParseError {
     JSON_NO_ERROR = 0,
     JSON_BAD_ROOT_ELEMENT_TYPE,
     JSON_INVALID_ESCAPE,
@@ skipping 79 matching lines @@
   // Parses a sequence of characters into a Token::STRING. If the sequence of
   // characters is not a valid string, returns a Token::INVALID_TOKEN. Note
   // that DecodeString is used to actually decode the escaped string into an
   // actual wstring.
   Token ParseStringToken();
 
   // Convert the substring into a value string.  This should always succeed
   // (otherwise ParseStringToken would have failed).
   Value* DecodeString(const Token& token);
 
+  // Helper function for DecodeString that consumes UTF16 [0,2] code units and
+  // convers them to UTF8 code untis.  |token| is the string token in which the
+  // units should be read, |i| is the position in the token at which the first
+  // code unit starts, immediately after the |\u|. This will be mutated if code
+  // units are consumed. |dest_string| is a string to which the UTF8 code units
+  // should be appended. Returns true on success and false if there's an
+  // encoding error.
+  bool ConvertUTF16Units(const Token& token,
+                         int* i,
+                         std::string* dest_string);
+
+  // Helper function for DecodeString that reads four characters from buf and
+  // returns a UTF16 code unit. |buf| is not range checked in this function.
+  uint32 ReadUTF16Unit(const char* buf);
+
   // Grabs the next token in the JSON stream.  This does not increment the
   // stream so it can be used to look ahead at the next token.
   Token ParseToken();
 
   // 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 wchar_t* str, size_t length);
+  bool NextStringMatch(const char* str, size_t length);
 
   // 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 SetErrorCode(const JsonParseError error, const wchar_t* error_pos);
+  void SetErrorCode(const JsonParseError error, const char* error_pos);
 
   // Pointer to the starting position in the input string.
-  const wchar_t* start_pos_;
+  const char* start_pos_;
 
   // Pointer to the current position in the input string.
-  const wchar_t* json_pos_;
+  const char* json_pos_;
+
+  // Pointer to the last position in the input string.
+  const char* end_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 code for the last call to JsonToValue(), if any.
   JsonParseError error_code_;
   int error_line_;
   int error_col_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONReader);
 };
 
 }  // namespace base
 
 #endif  // BASE_JSON_JSON_READER_H_