Proof-read comments in src/url/.

url/url_canon_host.cc

 // 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.
 
 #include "base/logging.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 
 namespace url {
 
@@ skipping 16 matching lines @@
 // 2   E  +  E  E  +  E  +  +  +  +  +  +  +  U  U  0
 // 3                                 %  %  E  +  E  0  <-- Those are  : ; < = > ?
 // 4   %
 // 5                                    U  0  U  U  U  <-- Those are  [ \ ] ^ _
 // 6   E                                               <-- That's  `
 // 7                                    E  E  E  U  E  <-- Those are { | } ~ (UNPRINTABLE)
 //
 // NOTE: I didn't actually test all the control characters. Some may be
 // disallowed in the input, but they are all accepted escaped except for 0.
 // I also didn't test if characters affecting HTML parsing are allowed
-// unescaped, eg. (") or (#), which would indicate the beginning of the path.
+// unescaped, e.g. (") or (#), which would indicate the beginning of the path.
 // Surprisingly, space is accepted in the input and always escaped.
 
 // This table lists the canonical version of all characters we allow in the
 // input, with 0 indicating it is disallowed. We use the magic kEscapedHostChar
 // value to indicate that this character should be escaped. We are a little more
 // restrictive than IE, but less restrictive than Firefox.
 //
 // Note that we disallow the % character. We will allow it when part of an
 // escape sequence, of course, but this disallows "%25". Even though IE allows
 // it, allowing it would put us in a funny state. If there was an invalid
@@ skipping 261 matching lines @@
   if (!has_non_ascii && !has_escaped) {
     success = DoSimpleHost(&spec[host.begin], host.len,
                            output, &has_non_ascii);
     DCHECK(!has_non_ascii);
   } else {
     success = DoComplexHost(&spec[host.begin], host.len,
                             has_non_ascii, has_escaped, output);
   }
 
   if (!success) {
-    // Canonicalization failed.  Set BROKEN to notify the caller.
+    // Canonicalization failed. Set BROKEN to notify the caller.
     host_info->family = CanonHostInfo::BROKEN;
   } else {
     // After all the other canonicalization, check if we ended up with an IP
-    // address.  IP addresses are small, so writing into this temporary buffer
+    // address. IP addresses are small, so writing into this temporary buffer
     // should not cause an allocation.
     RawCanonOutput<64> canon_ip;
     CanonicalizeIPAddress(output->data(),
                           MakeRange(output_begin, output->length()),
                           &canon_ip, host_info);
 
     // If we got an IPv4/IPv6 address, copy the canonical form back to the
-    // real buffer.  Otherwise, it's a hostname or broken IP, in which case
+    // real buffer. Otherwise, it's a hostname or broken IP, in which case
     // we just leave it in place.
     if (host_info->IsIPAddress()) {
       output->set_length(output_begin);
       output->Append(canon_ip.data(), canon_ip.length());
     }
   }
 
   host_info->out_host = MakeRange(output_begin, output->length());
 }
 
@@ skipping 27 matching lines @@
 }
 
 void CanonicalizeHostVerbose(const base::char16* spec,
                              const Component& host,
                              CanonOutput* output,
                              CanonHostInfo* host_info) {
   DoHost<base::char16, base::char16>(spec, host, output, host_info);
 }
 
 }  // namespace url