Proof-read comments in src/url/.

url/url_canon_ip.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 "url/url_canon_ip.h"
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <limits>
 
@@ skipping 101 matching lines @@
   } else {
     base = CHAR_DEC;
   }
 
   // Extend the prefix to consume all leading zeros.
   while (base_prefix_len < component.len &&
          spec[component.begin + base_prefix_len] == '0')
     base_prefix_len++;
 
   // Put the component, minus any base prefix, into a NULL-terminated buffer so
-  // we can call the standard library.  Because leading zeros have already been
+  // we can call the standard library. Because leading zeros have already been
   // discarded, filling the entire buffer is guaranteed to trigger the 32-bit
   // overflow check.
   const int kMaxComponentLen = 16;
   char buf[kMaxComponentLen + 1];  // digits + '\0'
   int dest_i = 0;
   for (int i = component.begin + base_prefix_len; i < component.end(); i++) {
     // We know the input is 7-bit, so convert to narrow (if this is the wide
     // version of the template) by casting.
     char input = static_cast<char>(spec[i]);
 
     // Validate that this character is OK for the given base.
     if (!IsCharOfType(input, base))
       return CanonHostInfo::NEUTRAL;
 
-    // Fill the buffer, if there's space remaining.  This check allows us to
+    // Fill the buffer, if there's space remaining. This check allows us to
     // verify that all characters are numeric, even those that don't fit.
     if (dest_i < kMaxComponentLen)
       buf[dest_i++] = input;
   }
 
   buf[dest_i] = '\0';
 
   // Use the 64-bit strtoi so we get a big number (no hex, decimal, or octal
   // number can overflow a 64-bit number in <= 16 characters).
   uint64_t num = _strtoui64(buf, NULL, BaseForType(base));
 
   // Check for 32-bit overflow.
   if (num > std::numeric_limits<uint32_t>::max())
     return CanonHostInfo::BROKEN;
 
-  // No overflow.  Success!
+  // No overflow. Success!
   *number = static_cast<uint32_t>(num);
   return CanonHostInfo::IPV4;
 }
 
 // See declaration of IPv4AddressToNumber for documentation.
 template<typename CHAR>
 CanonHostInfo::Family DoIPv4AddressToNumber(const CHAR* spec,
                                             const Component& host,
                                             unsigned char address[4],
                                             int* num_ipv4_components) {
   // The identified components. Not all may exist.
   Component components[4];
   if (!FindIPv4Components(spec, host, components))
     return CanonHostInfo::NEUTRAL;
 
   // Convert existing components to digits. Values up to
   // |existing_components| will be valid.
   uint32_t component_values[4];
   int existing_components = 0;
 
-  // Set to true if one or more components are BROKEN.  BROKEN is only
+  // Set to true if one or more components are BROKEN. BROKEN is only
   // returned if all components are IPV4 or BROKEN, so, for example,
   // 12345678912345.de returns NEUTRAL rather than broken.
   bool broken = false;
   for (int i = 0; i < 4; i++) {
     if (components[i].len <= 0)
       continue;
     CanonHostInfo::Family family = IPv4ComponentToNumber(
         spec, components[i], &component_values[existing_components]);
 
     if (family == CanonHostInfo::BROKEN) {
@@ skipping 249 matching lines @@
   }
 
   // Check that the numbers add up.
   if (num_bytes_without_contraction + num_bytes_of_contraction != 16)
     return false;
 
   *out_num_bytes_of_contraction = num_bytes_of_contraction;
   return true;
 }
 
-// Converts a hex comonent into a number. This cannot fail since the caller has
+// Converts a hex component into a number. This cannot fail since the caller has
 // already verified that each character in the string was a hex digit, and
 // that there were no more than 4 characters.
 template <typename CHAR>
 uint16_t IPv6HexComponentToNumber(const CHAR* spec,
                                   const Component& component) {
   DCHECK(component.len <= 4);
 
   // Copy the hex string into a C-string.
   char buf[5];
   for (int i = 0; i < component.len; ++i)
@@ skipping 116 matching lines @@
     for (int i = host.begin; i < host.end(); i++) {
       switch (spec[i]) {
         case '[':
         case ']':
         case ':':
           host_info->family = CanonHostInfo::BROKEN;
           return true;
       }
     }
 
-    // No invalid characters.  Could still be IPv4 or a hostname.
+    // No invalid characters. Could still be IPv4 or a hostname.
     host_info->family = CanonHostInfo::NEUTRAL;
     return false;
   }
 
   host_info->out_host.begin = output->length();
   output->push_back('[');
   AppendIPv6Address(host_info->address, output);
   output->push_back(']');
   host_info->out_host.len = output->length() - host_info->out_host.begin;
 
@@ skipping 110 matching lines @@
   return DoIPv6AddressToNumber<char, unsigned char>(spec, host, address);
 }
 
 bool IPv6AddressToNumber(const base::char16* spec,
                          const Component& host,
                          unsigned char address[16]) {
   return DoIPv6AddressToNumber<base::char16, base::char16>(spec, host, address);
 }
 
 }  // namespace url