Update to Chromium //url at Chromium commit 79dc59ac7602413181079ecb463873e29a1d7d0a.

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>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "url/url_canon_internal.h"
 
 namespace url {
 
 namespace {
 
 // Converts one of the character types that represent a numerical base to the
 // corresponding base.
 int BaseForType(SharedCharTypes type) {
@@ skipping 65 matching lines @@
 // - IPV4    - The number was valid, and did not overflow.
 // - BROKEN  - The input was numeric, but too large for a 32-bit field.
 // - NEUTRAL - Input was not numeric.
 //
 // The input is assumed to be ASCII. FindIPv4Components should have stripped
 // out any input that is greater than 7 bits. The components are assumed
 // to be non-empty.
 template<typename CHAR>
 CanonHostInfo::Family IPv4ComponentToNumber(const CHAR* spec,
                                             const Component& component,
-                                            uint32* number) {
+                                            uint32_t* number) {
   // Figure out the base
   SharedCharTypes base;
   int base_prefix_len = 0;  // Size of the prefix for this base.
   if (spec[component.begin] == '0') {
     // Either hex or dec, or a standalone zero.
     if (component.len == 1) {
       base = CHAR_DEC;
     } else if (spec[component.begin + 1] == 'X' ||
                spec[component.begin + 1] == 'x') {
       base = CHAR_HEX;
       base_prefix_len = 2;
     } else {
       base = CHAR_OCT;
       base_prefix_len = 1;
     }
   } 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 num = _strtoui64(buf, NULL, BaseForType(base));
+  uint64_t num = _strtoui64(buf, NULL, BaseForType(base));
 
   // Check for 32-bit overflow.
-  if (num > kuint32max)
+  if (num > std::numeric_limits<uint32_t>::max())
     return CanonHostInfo::BROKEN;
 
-  // No overflow.  Success!
-  *number = static_cast<uint32>(num);
+  // 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 component_values[4];
+  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) {
       broken = true;
     } else if (family != CanonHostInfo::IPV4) {
       // Stop if we hit a non-BROKEN invalid non-empty component.
       return family;
     }
 
     existing_components++;
   }
 
   if (broken)
     return CanonHostInfo::BROKEN;
 
   // Use that sequence of numbers to fill out the 4-component IP address.
 
   // First, process all components but the last, while making sure each fits
   // within an 8-bit field.
   for (int i = 0; i < existing_components - 1; i++) {
-    if (component_values[i] > kuint8max)
+    if (component_values[i] > std::numeric_limits<uint8_t>::max())
       return CanonHostInfo::BROKEN;
     address[i] = static_cast<unsigned char>(component_values[i]);
   }
 
   // Next, consume the last component to fill in the remaining bytes.
   // Work around a gcc 4.9 bug. crbug.com/392872
 #if ((__GNUC__ == 4 && __GNUC_MINOR__ >= 9) || __GNUC__ > 4)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Warray-bounds"
 #endif
-  uint32 last_value = component_values[existing_components - 1];
+  uint32_t last_value = component_values[existing_components - 1];
 #if ((__GNUC__ == 4 && __GNUC_MINOR__ >= 9) || __GNUC__ > 4)
 #pragma GCC diagnostic pop
 #endif
   for (int i = 3; i >= existing_components - 1; i--) {
     address[i] = static_cast<unsigned char>(last_value);
     last_value >>= 8;
   }
 
   // If the last component has residual bits, report overflow.
   if (last_value != 0)
@@ skipping 210 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 IPv6HexComponentToNumber(const CHAR* spec, const Component& component) {
+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)
     buf[i] = static_cast<char>(spec[component.begin + i]);
   buf[component.len] = '\0';
 
   // Convert it to a number (overflow is not possible, since with 4 hex
   // characters we can at most have a 16 bit number).
-  return static_cast<uint16>(_strtoui64(buf, NULL, 16));
+  return static_cast<uint16_t>(_strtoui64(buf, NULL, 16));
 }
 
 // Converts an IPv6 address to a 128-bit number (network byte order), returning
 // true on success. False means that the input was not a valid IPv6 address.
 template<typename CHAR, typename UCHAR>
 bool DoIPv6AddressToNumber(const CHAR* spec,
                            const Component& host,
                            unsigned char address[16]) {
   // Make sure the component is bounded by '[' and ']'.
   int end = host.end();
@@ skipping 21 matching lines @@
   // Loop through each hex components, and contraction in order.
   for (int i = 0; i <= ipv6_parsed.num_hex_components; ++i) {
     // Append the contraction if it appears before this component.
     if (i == ipv6_parsed.index_of_contraction) {
       for (int j = 0; j < num_bytes_of_contraction; ++j)
         address[cur_index_in_address++] = 0;
     }
     // Append the hex component's value.
     if (i != ipv6_parsed.num_hex_components) {
       // Get the 16-bit value for this hex component.
-      uint16 number = IPv6HexComponentToNumber<CHAR>(
+      uint16_t number = IPv6HexComponentToNumber<CHAR>(
           spec, ipv6_parsed.hex_components[i]);
       // Append to |address|, in network byte order.
       address[cur_index_in_address++] = (number & 0xFF00) >> 8;
       address[cur_index_in_address++] = (number & 0x00FF);
     }
   }
 
   // If there was an IPv4 section, convert it into a 32-bit number and append
   // it to |address|.
   if (ipv6_parsed.ipv4_component.is_valid()) {
@@ skipping 58 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