Switch to standard integer types in net/.

net/spdy/spdy_alt_svc_wire_format.cc

 // Copyright (c) 2015 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 "net/spdy/spdy_alt_svc_wire_format.h"
 
 #include <limits>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 23 matching lines @@
   return (c == end && *value > 0);
 }
 
 }  // namespace
 
 SpdyAltSvcWireFormat::AlternativeService::AlternativeService() {}
 
 SpdyAltSvcWireFormat::AlternativeService::AlternativeService(
     const std::string& protocol_id,
     const std::string& host,
-    uint16 port,
-    uint32 max_age,
+    uint16_t port,
+    uint32_t max_age,
     double probability,
     VersionVector version)
     : protocol_id(protocol_id),
       host(host),
       port(port),
       max_age(max_age),
       probability(probability),
       version(version) {}
 
 SpdyAltSvcWireFormat::AlternativeService::~AlternativeService() {}
@@ skipping 40 matching lines @@
       ++c;
       if (c == value.end()) {
         return false;
       }
     }
     if (c == alt_authority_begin || c == value.end()) {
       return false;
     }
     DCHECK_EQ('"', *c);
     std::string host;
-    uint16 port;
+    uint16_t port;
     if (!ParseAltAuthority(alt_authority_begin, c, &host, &port)) {
       return false;
     }
     ++c;
     // Parse parameters.
-    uint32 max_age = 86400;
+    uint32_t max_age = 86400;
     double probability = 1.0;
     VersionVector version;
     StringPiece::const_iterator parameters_end = std::find(c, value.end(), ',');
     while (c != parameters_end) {
       SkipWhiteSpace(&c, parameters_end);
       if (c == parameters_end) {
         break;
       }
       if (*c != ';') {
         return false;
@@ skipping 44 matching lines @@
           return false;
         }
         ++c;
         parameters_end = std::find(c, value.end(), ',');
         StringPiece::const_iterator v_begin = parameter_value_begin + 1;
         while (v_begin < c) {
           StringPiece::const_iterator v_end = v_begin;
           while (v_end < c - 1 && *v_end != ',') {
             ++v_end;
           }
-          uint16 v;
+          uint16_t v;
           if (!ParsePositiveInteger16(v_begin, v_end, &v)) {
             return false;
           }
           version.push_back(v);
           v_begin = v_end + 1;
           if (v_begin == c - 1) {
             // List ends in comma.
             return false;
           }
         }
@@ skipping 117 matching lines @@
     decoded += isdigit(*c) ? (0 - '0') : (10 - 'a');
     output->push_back(decoded);
   }
   return true;
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParseAltAuthority(StringPiece::const_iterator c,
                                              StringPiece::const_iterator end,
                                              std::string* host,
-                                             uint16* port) {
+                                             uint16_t* port) {
   host->clear();
   for (; c != end && *c != ':'; ++c) {
     if (*c == '"') {
       // Port is mandatory.
       return false;
     }
     if (*c == '\\') {
       ++c;
       if (c == end) {
         return false;
       }
     }
     host->push_back(*c);
   }
   if (c == end) {
     return false;
   }
   DCHECK_EQ(':', *c);
   ++c;
   return ParsePositiveInteger16(c, end, port);
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger16(
     StringPiece::const_iterator c,
     StringPiece::const_iterator end,
-    uint16* value) {
-  return ParsePositiveIntegerImpl<uint16>(c, end, value);
+    uint16_t* value) {
+  return ParsePositiveIntegerImpl<uint16_t>(c, end, value);
 }
 
 // static
 bool SpdyAltSvcWireFormat::ParsePositiveInteger32(
     StringPiece::const_iterator c,
     StringPiece::const_iterator end,
-    uint32* value) {
-  return ParsePositiveIntegerImpl<uint32>(c, end, value);
+    uint32_t* value) {
+  return ParsePositiveIntegerImpl<uint32_t>(c, end, value);
 }
 
 // Probability is a decimal fraction between 0.0 and 1.0, inclusive, with
 // optional leading zero, optional decimal point, and optional digits following
 // the decimal point, with the restriction that there has to be at least one
 // digit (that is, "" and "." are not valid).
 // static
 bool SpdyAltSvcWireFormat::ParseProbability(StringPiece::const_iterator c,
                                             StringPiece::const_iterator end,
                                             double* probability) {
@@ skipping 24 matching lines @@
   ++c;
   double place_value = 0.1;
   for (; c != end && isdigit(*c); ++c) {
     *probability += place_value * (*c - '0');
     place_value *= 0.1;
   }
   return (c == end && *probability <= 1.0);
 }
 
 }  // namespace net