Switch to standard integer types in url/.

url/origin_unittest.cc

 // Copyright 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 <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
-#include "url/origin.h"
+#include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
+#include "url/origin.h"
 
 namespace {
 
 TEST(OriginTest, UniqueOriginComparison) {
   url::Origin unique_origin;
   EXPECT_EQ("", unique_origin.scheme());
   EXPECT_EQ("", unique_origin.host());
   EXPECT_EQ(0, unique_origin.port());
   EXPECT_TRUE(unique_origin.unique());
   EXPECT_FALSE(unique_origin.IsSameOriginWith(unique_origin));
@@ skipping 18 matching lines @@
   }
 }
 
 TEST(OriginTest, ConstructFromGURL) {
   url::Origin different_origin(GURL("https://not-in-the-list.test/"));
 
   struct TestCases {
     const char* const url;
     const char* const expected_scheme;
     const char* const expected_host;
-    const uint16 expected_port;
+    const uint16_t expected_port;
   } cases[] = {
       // IP Addresses
       {"http://192.168.9.1/", "http", "192.168.9.1", 80},
       {"http://[2001:db8::1]/", "http", "[2001:db8::1]", 80},
 
       // Punycode
       {"http://☃.net/", "http", "xn--n3h.net", 80},
       {"blob:http://☃.net/", "http", "xn--n3h.net", 80},
 
       // Generic URLs
@@ skipping 97 matching lines @@
       EXPECT_EQ(i < j, current < to_compare) << i << " < " << j;
       EXPECT_EQ(j < i, to_compare < current) << j << " < " << i;
     }
   }
 }
 
 TEST(OriginTest, UnsafelyCreate) {
   struct TestCase {
     const char* scheme;
     const char* host;
-    uint16 port;
+    uint16_t port;
   } cases[] = {
       {"http", "example.com", 80},
       {"http", "example.com", 123},
       {"https", "example.com", 443},
       {"https", "example.com", 123},
       {"file", "", 0},
       {"file", "example.com", 0},
   };
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::Origin origin = url::Origin::UnsafelyCreateOriginWithoutNormalization(
         test.scheme, test.host, test.port);
     EXPECT_EQ(test.scheme, origin.scheme());
     EXPECT_EQ(test.host, origin.host());
     EXPECT_EQ(test.port, origin.port());
     EXPECT_FALSE(origin.unique());
     EXPECT_TRUE(origin.IsSameOriginWith(origin));
   }
 }
 
 TEST(OriginTest, UnsafelyCreateUniqueOnInvalidInput) {
   struct TestCases {
     const char* scheme;
     const char* host;
-    uint16 port;
+    uint16_t port;
   } cases[] = {{"", "", 0},
                {"data", "", 0},
                {"blob", "", 0},
                {"filesystem", "", 0},
                {"data", "example.com", 80},
                {"http", "☃.net", 80},
                {"http\nmore", "example.com", 80},
                {"http\rmore", "example.com", 80},
                {"http\n", "example.com", 80},
                {"http\r", "example.com", 80},
@@ skipping 16 matching lines @@
     EXPECT_FALSE(origin.IsSameOriginWith(origin));
   }
 }
 
 TEST(OriginTest, UnsafelyCreateUniqueViaEmbeddedNulls) {
   struct TestCases {
     const char* scheme;
     size_t scheme_length;
     const char* host;
     size_t host_length;
-    uint16 port;
+    uint16_t port;
   } cases[] = {{"http\0more", 9, "example.com", 11, 80},
                {"http\0", 5, "example.com", 11, 80},
                {"\0http", 5, "example.com", 11, 80},
                {"http", 4, "example.com\0not-example.com", 27, 80},
                {"http", 4, "example.com\0", 12, 80},
                {"http", 4, "\0example.com", 12, 80}};
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::Origin origin = url::Origin::UnsafelyCreateOriginWithoutNormalization(
         std::string(test.scheme, test.scheme_length),
         std::string(test.host, test.host_length), test.port);
     EXPECT_EQ("", origin.scheme());
     EXPECT_EQ("", origin.host());
     EXPECT_EQ(0, origin.port());
     EXPECT_TRUE(origin.unique());
     EXPECT_FALSE(origin.IsSameOriginWith(origin));
   }
 }
 
 }  // namespace url