Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_unittest.cc

 // Copyright 2014 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 "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 class MockAppCacheFrontend : public AppCacheFrontend {
@@ skipping 40 matching lines @@
 }
 
 TEST(AppCacheTest, AddModifyRemoveEntry) {
   MockAppCacheService service;
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 111));
 
   EXPECT_TRUE(cache->entries().empty());
   EXPECT_EQ(0L, cache->cache_size());
 
   const GURL kFooUrl("http://foo.com");
-  const int64 kFooResponseId = 1;
-  const int64 kFooSize = 100;
+  const int64_t kFooResponseId = 1;
+  const int64_t kFooSize = 100;
   AppCacheEntry entry1(AppCacheEntry::MASTER, kFooResponseId, kFooSize);
   cache->AddEntry(kFooUrl, entry1);
   EXPECT_EQ(entry1.types(), cache->GetEntry(kFooUrl)->types());
   EXPECT_EQ(1UL, cache->entries().size());
   EXPECT_EQ(kFooSize, cache->cache_size());
 
   const GURL kBarUrl("http://bar.com");
-  const int64 kBarResponseId = 2;
-  const int64 kBarSize = 200;
+  const int64_t kBarResponseId = 2;
+  const int64_t kBarSize = 200;
   AppCacheEntry entry2(AppCacheEntry::FALLBACK, kBarResponseId, kBarSize);
   EXPECT_TRUE(cache->AddOrModifyEntry(kBarUrl, entry2));
   EXPECT_EQ(entry2.types(), cache->GetEntry(kBarUrl)->types());
   EXPECT_EQ(2UL, cache->entries().size());
   EXPECT_EQ(kFooSize + kBarSize, cache->cache_size());
 
   // Expected to return false when an existing entry is modified.
   AppCacheEntry entry3(AppCacheEntry::EXPLICIT);
   EXPECT_FALSE(cache->AddOrModifyEntry(kFooUrl, entry3));
   EXPECT_EQ((AppCacheEntry::MASTER | AppCacheEntry::EXPLICIT),
@@ skipping 72 matching lines @@
       "http://blah/online_namespace/explicit");
   const GURL kFallbackTestUrl1("http://blah/fallback_namespace/1");
   const GURL kFallbackTestUrl2("http://blah/fallback_namespace/longer2");
   const GURL kInterceptNamespace("http://blah/intercept_namespace/");
   const GURL kInterceptNamespaceWithinFallback(
       "http://blah/fallback_namespace/intercept_namespace/");
   const GURL kInterceptNamespaceEntry("http://blah/intercept_entry");
   const GURL kOnlineNamespaceWithinOtherNamespaces(
       "http://blah/fallback_namespace/intercept_namespace/1/online");
 
-  const int64 kFallbackResponseId1 = 1;
-  const int64 kFallbackResponseId2 = 2;
-  const int64 kManifestResponseId = 3;
-  const int64 kForeignExplicitResponseId = 4;
-  const int64 kExplicitInOnlineNamespaceResponseId = 5;
-  const int64 kInterceptResponseId = 6;
+  const int64_t kFallbackResponseId1 = 1;
+  const int64_t kFallbackResponseId2 = 2;
+  const int64_t kManifestResponseId = 3;
+  const int64_t kForeignExplicitResponseId = 4;
+  const int64_t kExplicitInOnlineNamespaceResponseId = 5;
+  const int64_t kInterceptResponseId = 6;
 
   AppCacheManifest manifest;
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl,
           GURL(), false));
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
           kOnlineNamespaceWithinOtherNamespaces, GURL(), false));
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl1,
@@ skipping 171 matching lines @@
 }
 
 TEST(AppCacheTest, FindInterceptPatternResponseForRequest) {
   MockAppCacheService service;
 
   // Setup an appcache with an intercept namespace that uses pattern matching.
   const GURL kInterceptNamespaceBase("http://blah/intercept_namespace/");
   const GURL kInterceptPatternNamespace(
       kInterceptNamespaceBase.Resolve("*.hit*"));
   const GURL kInterceptNamespaceEntry("http://blah/intercept_resource");
-  const int64 kInterceptResponseId = 1;
+  const int64_t kInterceptResponseId = 1;
   AppCacheManifest manifest;
   manifest.intercept_namespaces.push_back(
       AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE,
           kInterceptPatternNamespace, kInterceptNamespaceEntry, true));
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kInterceptNamespaceEntry,
       AppCacheEntry(AppCacheEntry::INTERCEPT, kInterceptResponseId));
   cache->set_complete(true);
@@ skipping 50 matching lines @@
 }
 
 TEST(AppCacheTest, FindFallbackPatternResponseForRequest) {
   MockAppCacheService service;
 
   // Setup an appcache with a fallback namespace that uses pattern matching.
   const GURL kFallbackNamespaceBase("http://blah/fallback_namespace/");
   const GURL kFallbackPatternNamespace(
       kFallbackNamespaceBase.Resolve("*.hit*"));
   const GURL kFallbackNamespaceEntry("http://blah/fallback_resource");
-  const int64 kFallbackResponseId = 1;
+  const int64_t kFallbackResponseId = 1;
   AppCacheManifest manifest;
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackPatternNamespace,
                 kFallbackNamespaceEntry, true));
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kFallbackNamespaceEntry,
       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId));
   cache->set_complete(true);
@@ skipping 87 matching lines @@
       &fallback_entry, &fallback_namespace,
       &network_namespace);
   EXPECT_TRUE(found);
   EXPECT_TRUE(network_namespace);
   EXPECT_FALSE(entry.has_response_id());
   EXPECT_FALSE(fallback_entry.has_response_id());
 }
 
 TEST(AppCacheTest, ToFromDatabaseRecords) {
   // Setup a cache with some entries.
-  const int64 kCacheId = 1234;
-  const int64 kGroupId = 4321;
+  const int64_t kCacheId = 1234;
+  const int64_t kGroupId = 4321;
   const GURL kManifestUrl("http://foo.com/manifest");
   const GURL kInterceptUrl("http://foo.com/intercept.html");
   const GURL kFallbackUrl("http://foo.com/fallback.html");
   const GURL kWhitelistUrl("http://foo.com/whitelist*");
   const std::string kData(
     "CACHE MANIFEST\r"
     "CHROMIUM-INTERCEPT:\r"
     "/intercept return /intercept.html\r"
     "FALLBACK:\r"
     "/ /fallback.html\r"
@@ skipping 134 matching lines @@
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/01234567890abcdef/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/01234567890abcdef/b01234567890abcdef/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/01234567890abcdef_eat_some_more_characters_"
            "/and_even_more_for_the_heck_of_it/01234567890abcdef/b")));
 }
 
 }  // namespace content