Switch to standard integer types in net/.

net/spdy/spdy_alt_svc_wire_format_test.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 "base/logging.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/platform_test.h"
 
@@ skipping 12 matching lines @@
     SpdyAltSvcWireFormat::SkipWhiteSpace(c, end);
   }
   static bool PercentDecode(StringPiece::const_iterator c,
                             StringPiece::const_iterator end,
                             std::string* output) {
     return SpdyAltSvcWireFormat::PercentDecode(c, end, output);
   }
   static bool ParseAltAuthority(StringPiece::const_iterator c,
                                 StringPiece::const_iterator end,
                                 std::string* host,
-                                uint16* port) {
+                                uint16_t* port) {
     return SpdyAltSvcWireFormat::ParseAltAuthority(c, end, host, port);
   }
   static bool ParsePositiveInteger16(StringPiece::const_iterator c,
                                      StringPiece::const_iterator end,
-                                     uint16* max_age) {
+                                     uint16_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger16(c, end, max_age);
   }
   static bool ParsePositiveInteger32(StringPiece::const_iterator c,
                                      StringPiece::const_iterator end,
-                                     uint32* max_age) {
+                                     uint32_t* max_age) {
     return SpdyAltSvcWireFormat::ParsePositiveInteger32(c, end, max_age);
   }
   static bool ParseProbability(StringPiece::const_iterator c,
                                StringPiece::const_iterator end,
                                double* probability) {
     return SpdyAltSvcWireFormat::ParseProbability(c, end, probability);
   }
 };
 
 }  // namespace test
@@ skipping 370 matching lines @@
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::PercentDecode(
         input.begin(), input.end(), &output))
         << input;
   }
 }
 
 // Test ParseAltAuthority() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityValid) {
   StringPiece input(":42");
   std::string host;
-  uint16 port;
+  uint16_t port;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_TRUE(host.empty());
   EXPECT_EQ(42, port);
 
   input = StringPiece("foo:137");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
       input.begin(), input.end(), &host, &port));
   EXPECT_EQ("foo", host);
   EXPECT_EQ(137, port);
 }
 
 // Test ParseAltAuthority() on invalid input: empty string, no port, zero port,
 // non-digit characters following port.
 TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityInvalid) {
   const char* invalid_input_array[] = {"", ":", "foo:", ":bar", ":0", "foo:0",
       ":12bar", "foo:23bar", " ", ":12 ", "foo:12 "};
   for (const char* invalid_input : invalid_input_array) {
     StringPiece input(invalid_input);
     std::string host;
-    uint16 port;
+    uint16_t port;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParseAltAuthority(
         input.begin(), input.end(), &host, &port))
         << input;
   }
 }
 
 // Test ParseInteger() on valid input.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerValid) {
   StringPiece input("3");
-  uint16 value;
+  uint16_t value;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value));
   EXPECT_EQ(3, value);
 
   input = StringPiece("1337");
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value));
   EXPECT_EQ(1337, value);
 }
 
 // Test ParseIntegerValid() on invalid input: empty, zero, non-numeric, trailing
 // non-numeric characters.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerInvalid) {
   const char* invalid_input_array[] = {"", " ", "a", "0", "00", "1 ", "12b"};
   for (const char* invalid_input : invalid_input_array) {
     StringPiece input(invalid_input);
-    uint16 value;
+    uint16_t value;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
         input.begin(), input.end(), &value))
         << input;
   }
 }
 
 // Test ParseIntegerValid() around overflow limit.
 TEST(SpdyAltSvcWireFormatTest, ParseIntegerOverflow) {
-  // Largest possible uint16 value.
+  // Largest possible uint16_t value.
   StringPiece input("65535");
-  uint16 value16;
+  uint16_t value16;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
   EXPECT_EQ(65535, value16);
 
-  // Overflow uint16, ParsePositiveInteger16() should return false.
+  // Overflow uint16_t, ParsePositiveInteger16() should return false.
   input = StringPiece("65536");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
 
   // However, even if overflow is not checked for, 65536 overflows to 0, which
   // returns false anyway.  Check for a larger number which overflows to 1.
   input = StringPiece("65537");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger16(
       input.begin(), input.end(), &value16));
 
-  // Largest possible uint32 value.
+  // Largest possible uint32_t value.
   input = StringPiece("4294967295");
-  uint32 value32;
+  uint32_t value32;
   ASSERT_TRUE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32(
       input.begin(), input.end(), &value32));
   EXPECT_EQ(4294967295, value32);
 
-  // Overflow uint32, ParsePositiveInteger32() should return false.
+  // Overflow uint32_t, ParsePositiveInteger32() should return false.
   input = StringPiece("4294967296");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32(
       input.begin(), input.end(), &value32));
 
   // However, even if overflow is not checked for, 4294967296 overflows to 0,
   // which returns false anyway.  Check for a larger number which overflows to
   // 1.
   input = StringPiece("4294967297");
   ASSERT_FALSE(test::SpdyAltSvcWireFormatPeer::ParsePositiveInteger32(
       input.begin(), input.end(), &value32));
@@ skipping 60 matching lines @@
     StringPiece input(invalid_input);
     double probability;
     EXPECT_FALSE(test::SpdyAltSvcWireFormatPeer::ParseProbability(
         input.begin(), input.end(), &probability));
   }
 }
 
 }  // namespace
 
 }  // namespace net