Switch to standard integer types in base/strings/.

third_party/WebKit/Source/platform/weborigin/SecurityOriginTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 30 matching lines @@
 namespace blink {
 
 const int MaxAllowedPort = 65535;
 
 class SecurityOriginTest : public ::testing::Test { };
 
 TEST_F(SecurityOriginTest, InvalidPortsCreateUniqueOrigins)
 {
     int ports[] = { -100, -1, MaxAllowedPort + 1, 1000000 };
 
-    for (size_t i = 0; i < arraysize(ports); ++i) {
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(ports); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
         EXPECT_TRUE(origin->isUnique()) << "Port " << ports[i] << " should have generated a unique origin.";
     }
 }
 
 TEST_F(SecurityOriginTest, ValidPortsCreateNonUniqueOrigins)
 {
     int ports[] = { 0, 80, 443, 5000, MaxAllowedPort };
 
-    for (size_t i = 0; i < arraysize(ports); ++i) {
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(ports); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
         EXPECT_FALSE(origin->isUnique()) << "Port " << ports[i] << " should not have generated a unique origin.";
     }
 }
 
 TEST_F(SecurityOriginTest, LocalAccess)
 {
     RefPtr<SecurityOrigin> file1 = SecurityOrigin::createFromString("file:///etc/passwd");
     RefPtr<SecurityOrigin> file2 = SecurityOrigin::createFromString("file:///etc/shadow");
 
@@ skipping 74 matching lines @@
         { false, "blob:ftp://evil:99/578223a1-8c13-17b3-84d5-eca045ae384a" },
 
         // filesystem: URLs work the same as blob: URLs, and look to the inner
         // URL for security origin.
         { true, "filesystem:http://localhost:1000/foo" },
         { true, "filesystem:https://foopy:99/foo" },
         { false, "filesystem:http://baz:99/foo" },
         { false, "filesystem:ftp://evil:99/foo" },
     };
 
-    for (size_t i = 0; i < arraysize(inputs); ++i) {
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(inputs); ++i) {
         SCOPED_TRACE(i);
         RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString(inputs[i].url);
         String errorMessage;
         EXPECT_EQ(inputs[i].accessGranted, origin->isPotentiallyTrustworthy(errorMessage));
         EXPECT_EQ(inputs[i].accessGranted, errorMessage.isEmpty());
     }
 
     // Unique origins are not considered secure.
     RefPtr<SecurityOrigin> uniqueOrigin = SecurityOrigin::createUnique();
     String errorMessage;
@@ skipping 132 matching lines @@
     };
 
     TestCase tests[] = {
         { true, true, "https://foobar.com", "https://foobar.com" },
         { false, false, "https://foobar.com", "https://bazbar.com" },
         { true, false, "https://foobar.com", "https://name_foobar.com" },
         { true, false, "https://name_foobar.com", "https://foobar.com" },
         { true, true, "https://name_foobar.com", "https://name_foobar.com" },
     };
 
-    for (size_t i = 0; i < arraysize(tests); ++i) {
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(tests); ++i) {
         RefPtr<SecurityOrigin> origin1 = SecurityOrigin::createFromString(tests[i].origin1);
         RefPtr<SecurityOrigin> origin2 = SecurityOrigin::createFromString(tests[i].origin2);
         EXPECT_EQ(tests[i].canAccess, origin1->canAccess(origin2.get()));
         EXPECT_EQ(tests[i].canAccessCheckSuborigins, origin1->canAccessCheckSuborigins(origin2.get()));
     }
 }
 
 TEST_F(SecurityOriginTest, CanRequest)
 {
     RuntimeEnabledFeatures::setSuboriginsEnabled(true);
 
     struct TestCase {
         bool canRequest;
         bool canRequestNoSuborigin;
         const char* origin;
         const char* url;
     };
 
     TestCase tests[] = {
         { true, true, "https://foobar.com", "https://foobar.com" },
         { false, false, "https://foobar.com", "https://bazbar.com" },
         { true, false, "https://name_foobar.com", "https://foobar.com" },
         { false, false, "https://name_foobar.com", "https://bazbar.com" },
     };
 
-    for (size_t i = 0; i < arraysize(tests); ++i) {
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(tests); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString(tests[i].origin);
         blink::KURL url(blink::ParsedURLString, tests[i].url);
         EXPECT_EQ(tests[i].canRequest, origin->canRequest(url));
         EXPECT_EQ(tests[i].canRequestNoSuborigin, origin->canRequestNoSuborigin(url));
     }
 }
 
 TEST_F(SecurityOriginTest, EffectivePort)
 {
     struct TestCase {
@@ skipping 65 matching lines @@
 
         KURL blobUrl = BlobURL::createPublicURL(origin.get());
         RefPtr<SecurityOrigin> blobUrlOrigin = SecurityOrigin::create(blobUrl);
         EXPECT_EQ(blobUrlOrigin->isUnique(), origin->isUnique());
         EXPECT_EQ(blobUrlOrigin->toString(), origin->toString());
         EXPECT_EQ(blobUrlOrigin->toRawString(), origin->toRawString());
     }
 }
 
 } // namespace blink