Update some comments/nits following r7486.

base/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 69 matching lines @@
   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;
 
   // 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);
+  // 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.
+  // specified and NULL is returned, |error_message_out| will be populated with
+  // a string describing the error. Otherwise, |error_message_out| is
+  // unmodified.
   static Value* ReadAndReturnError(const std::string& json,
                                    bool allow_trailing_comma,
-                                   std::string *error_message_out);
+                                   std::string* error_message_out);
 
  private:
   static std::string FormatErrorMessage(int line, int column,
                                         const char* description);
 
   JSONReader();
   DISALLOW_EVIL_CONSTRUCTORS(JSONReader);
 
   FRIEND_TEST(JSONReaderTest, Reading);
   FRIEND_TEST(JSONReaderTest, ErrorMessages);
@@ skipping 22 matching lines @@
   // we can (ie., no overflow), return the value, else return NULL.
   Value* DecodeNumber(const Token& token);
 
   // 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), but returns a success bool
-  // just in case.
+  // (otherwise ParseStringToken would have failed).
   Value* DecodeString(const Token& token);
 
   // 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.
+  // Increments |json_pos_| past leading whitespace and comments.
   void EatWhitespaceAndComments();
 
-  // If json_pos_ is at the start of a comment, eat it, otherwise, returns
+  // If |json_pos_| is at the start of a comment, eat it, otherwise, returns
   // false.
   bool EatComment();
 
-  // Checks if json_pos_ matches str.
+  // 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
   // line and column are determined and added into the final message.
   void SetErrorMessage(const char* description, 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_;
 };
 
 #endif  // BASE_JSON_READER_H_