Proof-read comments in src/url/.

url/url_canon_internal.h

 // Copyright 2013 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.
 
 #ifndef URL_URL_CANON_INTERNAL_H_
 #define URL_URL_CANON_INTERNAL_H_
 
 // This file is intended to be included in another C++ file where the character
 // types are defined. This allows us to write mostly generic code, but not have
-// templace bloat because everything is inlined when anybody calls any of our
+// template bloat because everything is inlined when anybody calls any of our
 // functions.
 
 #include <stdlib.h>
 
 #include "base/logging.h"
 #include "url/url_canon.h"
 
 namespace url {
 
 // Character type handling -----------------------------------------------------
@@ skipping 13 matching lines @@
 
   // Valid in an ASCII-representation of a hex digit (as in %-escaped).
   CHAR_HEX = 8,
 
   // Valid in an ASCII-representation of a decimal digit.
   CHAR_DEC = 16,
 
   // Valid in an ASCII-representation of an octal digit.
   CHAR_OCT = 32,
 
-  // Characters that do not require escaping in encodeURIComponent.  Characters
+  // Characters that do not require escaping in encodeURIComponent. Characters
   // that do not have this flag will be escaped; see url_util.cc.
   CHAR_COMPONENT = 64,
 };
 
 // This table contains the flags in SharedCharTypes for each 8-bit character.
 // Some canonicalization functions have their own specialized lookup table.
 // For those with simple requirements, we have collected the flags in one
 // place so there are fewer lookup tables to load into the CPU cache.
 //
 // Using an unsigned char type has a small but measurable performance benefit
@@ skipping 113 matching lines @@
     Appender(static_cast<unsigned char>(0x80 | (char_value & 0x3f)),
              output);
   } else if (char_value <= 0xffff) {
     // 1110xxxx 10xxxxxx 10xxxxxx
     Appender(static_cast<unsigned char>(0xe0 | (char_value >> 12)),
              output);
     Appender(static_cast<unsigned char>(0x80 | ((char_value >> 6) & 0x3f)),
              output);
     Appender(static_cast<unsigned char>(0x80 | (char_value & 0x3f)),
              output);
-  } else if (char_value <= 0x10FFFF) {  // Max unicode code point.
+  } else if (char_value <= 0x10FFFF) {  // Max Unicode code point.
     // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
     Appender(static_cast<unsigned char>(0xf0 | (char_value >> 18)),
              output);
     Appender(static_cast<unsigned char>(0x80 | ((char_value >> 12) & 0x3f)),
              output);
     Appender(static_cast<unsigned char>(0x80 | ((char_value >> 6) & 0x3f)),
              output);
     Appender(static_cast<unsigned char>(0x80 | (char_value & 0x3f)),
              output);
   } else {
     // Invalid UTF-8 character (>20 bits).
     NOTREACHED();
   }
 }
 
 // Helper used by AppendUTF8Value below. We use an unsigned parameter so there
 // are no funny sign problems with the input, but then have to convert it to
 // a regular char for appending.
 inline void AppendCharToOutput(unsigned char ch, CanonOutput* output) {
   output->push_back(static_cast<char>(ch));
 }
 
 // Writes the given character to the output as UTF-8. This does NO checking
-// of the validity of the unicode characters; the caller should ensure that
+// of the validity of the Unicode characters; the caller should ensure that
 // the value it is appending is valid to append.
 inline void AppendUTF8Value(unsigned char_value, CanonOutput* output) {
   DoAppendUTF8<CanonOutput, AppendCharToOutput>(char_value, output);
 }
 
 // Writes the given character to the output as UTF-8, escaping ALL
 // characters (even when they are ASCII). This does NO checking of the
-// validity of the unicode characters; the caller should ensure that the value
+// validity of the Unicode characters; the caller should ensure that the value
 // it is appending is valid to append.
 inline void AppendUTF8EscapedValue(unsigned char_value, CanonOutput* output) {
   DoAppendUTF8<CanonOutput, AppendEscapedChar>(char_value, output);
 }
 
 // UTF-16 functions -----------------------------------------------------------
 
 // Reads one character in UTF-16 starting at |*begin| in |str| and places
 // the decoded value into |*code_point|. If the character is valid, we will
 // return true. If invalid, we'll return false and put the
@@ skipping 32 matching lines @@
 // Every single output character will be escaped. This means that if you
 // give it an ASCII character as input, it will be escaped. Some code uses
 // this when it knows that a character is invalid according to its rules
 // for validity. If you don't want escaping for ASCII characters, you will
 // have to filter them out prior to calling this function.
 //
 // Assumes that ch[begin] is within range in the array, but does not assume
 // that any following characters are.
 inline bool AppendUTF8EscapedChar(const base::char16* str, int* begin,
                                   int length, CanonOutput* output) {
-  // UTF-16 input. Readchar16 will handle invalid characters for us and give
+  // UTF-16 input. ReadUTFChar will handle invalid characters for us and give
   // us the kUnicodeReplacementCharacter, so we don't have to do special
   // checking after failure, just pass through the failure to the caller.
   unsigned char_value;
   bool success = ReadUTFChar(str, begin, length, &char_value);
   AppendUTF8EscapedValue(char_value, output);
   return success;
 }
 
 // Handles UTF-8 input. See the wide version above for usage.
 inline bool AppendUTF8EscapedChar(const char* str, int* begin, int length,
@@ skipping 150 matching lines @@
 inline unsigned long long _strtoui64(const char* nptr,
                                      char** endptr, int base) {
   return strtoull(nptr, endptr, base);
 }
 
 #endif  // WIN32
 
 }  // namespace url
 
 #endif  // URL_URL_CANON_INTERNAL_H_