Switch to standard integer types in content/browser/.

content/browser/appcache/mock_appcache_storage_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 "base/run_loop.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 class MockAppCacheStorageTest : public testing::Test {
  public:
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate()
         : loaded_cache_id_(0), stored_group_success_(false),
           obsoleted_success_(false), found_cache_id_(kAppCacheNoCacheId) {
     }
 
-    void OnCacheLoaded(AppCache* cache, int64 cache_id) override {
+    void OnCacheLoaded(AppCache* cache, int64_t cache_id) override {
       loaded_cache_ = cache;
       loaded_cache_id_ = cache_id;
     }
 
     void OnGroupLoaded(AppCacheGroup* group,
                        const GURL& manifest_url) override {
       loaded_group_ = group;
       loaded_manifest_url_ = manifest_url;
     }
 
     void OnGroupAndNewestCacheStored(AppCacheGroup* group,
                                      AppCache* newest_cache,
                                      bool success,
                                      bool would_exceed_quota) override {
       stored_group_ = group;
       stored_group_success_ = success;
     }
 
     void OnGroupMadeObsolete(AppCacheGroup* group,
                              bool success,
                              int response_code) override {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
     }
 
     void OnMainResponseFound(const GURL& url,
                              const AppCacheEntry& entry,
                              const GURL& fallback_url,
                              const AppCacheEntry& fallback_entry,
-                             int64 cache_id,
-                             int64 group_id,
+                             int64_t cache_id,
+                             int64_t group_id,
                              const GURL& manifest_url) override {
       found_url_ = url;
       found_entry_ = entry;
       found_fallback_url_ = fallback_url;
       found_fallback_entry_ = fallback_entry;
       found_cache_id_ = cache_id;
       found_manifest_url_ = manifest_url;
     }
 
     scoped_refptr<AppCache> loaded_cache_;
-    int64 loaded_cache_id_;
+    int64_t loaded_cache_id_;
     scoped_refptr<AppCacheGroup> loaded_group_;
     GURL loaded_manifest_url_;
     scoped_refptr<AppCacheGroup> stored_group_;
     bool stored_group_success_;
     scoped_refptr<AppCacheGroup> obsoleted_group_;
     bool obsoleted_success_;
     GURL found_url_;
     AppCacheEntry found_entry_;
     GURL found_fallback_url_;
     AppCacheEntry found_fallback_entry_;
-    int64 found_cache_id_;
+    int64_t found_cache_id_;
     GURL found_manifest_url_;
   };
 
  private:
   base::MessageLoop message_loop_;
 };
 
 TEST_F(MockAppCacheStorageTest, LoadCache_Miss) {
   // Attempt to load a cache that doesn't exist. Should
   // complete asyncly.
   MockAppCacheService service;
   MockStorageDelegate delegate;
   service.storage()->LoadCache(111, &delegate);
   EXPECT_NE(111, delegate.loaded_cache_id_);
   base::RunLoop().RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(111, delegate.loaded_cache_id_);
   EXPECT_FALSE(delegate.loaded_cache_.get());
 }
 
 TEST_F(MockAppCacheStorageTest, LoadCache_NearHit) {
   // Attempt to load a cache that is currently in use
   // and does not require loading from disk. This
   // load should complete syncly.
   MockAppCacheService service;
 
   // Setup some preconditions. Make an 'unstored' cache for
   // us to load. The ctor should put it in the working set.
-  int64 cache_id = service.storage()->NewCacheId();
+  int64_t cache_id = service.storage()->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
 
   // Conduct the test.
   MockStorageDelegate delegate;
   service.storage()->LoadCache(cache_id, &delegate);
   EXPECT_EQ(cache_id, delegate.loaded_cache_id_);
   EXPECT_EQ(cache.get(), delegate.loaded_cache_.get());
 }
 
 TEST_F(MockAppCacheStorageTest, CreateGroup) {
@@ skipping 47 matching lines @@
   // load should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "stored" and "not currently in use".
   GURL manifest_url("http://blah/");
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), manifest_url, 111));
-  int64 cache_id = storage->NewCacheId();
+  int64_t cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->set_complete(true);
   group->AddCache(cache.get());
   storage->AddStoredGroup(group.get());
   storage->AddStoredCache(cache.get());
 
   // Drop the references from above so the only refs to these
   // objects are from within the storage class. This is to make
   // these objects appear as "not currently in use".
   AppCache* cache_ptr = cache.get();
@@ skipping 30 matching lines @@
   // Store a group and its newest cache. Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "unstored".
   GURL manifest_url("http://blah/");
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), manifest_url, 111));
-  int64 cache_id = storage->NewCacheId();
+  int64_t cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   // Hold a ref to the cache simulate the UpdateJob holding that ref,
   // and hold a ref to the group to simulate the CacheHost holding that ref.
 
   // Conduct the store test.
   MockStorageDelegate delegate;
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
   storage->StoreGroupAndNewestCache(group.get(), cache.get(), &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
@@ skipping 11 matching lines @@
   // Store a group and its newest cache. Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and old complete cache
   // that appear to be "stored", and a newest unstored complete cache.
   GURL manifest_url("http://blah/");
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), manifest_url, 111));
-  int64 old_cache_id = storage->NewCacheId();
+  int64_t old_cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> old_cache(
       new AppCache(service.storage(), old_cache_id));
   old_cache->set_complete(true);
   group->AddCache(old_cache.get());
   storage->AddStoredGroup(group.get());
   storage->AddStoredCache(old_cache.get());
-  int64 new_cache_id = storage->NewCacheId();
+  int64_t new_cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> new_cache(
       new AppCache(service.storage(), new_cache_id));
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_TRUE(storage->IsCacheStored(old_cache.get()));
   EXPECT_FALSE(storage->IsCacheStored(new_cache.get()));
@@ skipping 17 matching lines @@
   // Store a group with updates to its existing newest complete cache.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and a complete cache that
   // appear to be "stored".
   GURL manifest_url("http://blah");
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), manifest_url, 111));
-  int64 cache_id = storage->NewCacheId();
+  int64_t cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->set_complete(true);
   group->AddCache(cache.get());
   storage->AddStoredGroup(group.get());
   storage->AddStoredCache(cache.get());
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Change the group's newest cache.
   EXPECT_EQ(cache.get(), group->newest_complete_cache());
   GURL entry_url("http://blah/blah");
@@ skipping 21 matching lines @@
   // Make a group obsolete, should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "stored" and "currently in use".
   GURL manifest_url("http://blah/");
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), manifest_url, 111));
-  int64 cache_id = storage->NewCacheId();
+  int64_t cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->set_complete(true);
   group->AddCache(cache.get());
   storage->AddStoredGroup(group.get());
   storage->AddStoredCache(cache.get());
   // Hold our refs to simulate the UpdateJob holding these refs.
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_FALSE(group->is_obsolete());
@@ skipping 21 matching lines @@
 }
 
 TEST_F(MockAppCacheStorageTest, MarkEntryAsForeign) {
   // Should complete syncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a cache with an entry.
   GURL entry_url("http://blah/entry");
-  int64 cache_id = storage->NewCacheId();
+  int64_t cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), cache_id));
   cache->AddEntry(entry_url, AppCacheEntry(AppCacheEntry::EXPLICIT));
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_FALSE(cache->GetEntry(entry_url)->IsForeign());
   storage->MarkEntryAsForeign(entry_url, cache_id);
   EXPECT_TRUE(cache->GetEntry(entry_url)->IsForeign());
   EXPECT_TRUE(cache->GetEntry(entry_url)->IsExplicit());
 }
@@ skipping 22 matching lines @@
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 TEST_F(MockAppCacheStorageTest, BasicFindMainResponse) {
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a complete cache with an entry.
-  const int64 kCacheId = storage->NewCacheId();
+  const int64_t kCacheId = storage->NewCacheId();
   const GURL kEntryUrl("http://blah/entry");
   const GURL kManifestUrl("http://blah/manifest");
-  const int64 kResponseId = 1;
+  const int64_t kResponseId = 1;
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId));
   cache->set_complete(true);
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), kManifestUrl, 111));
   group->AddCache(cache.get());
   storage->AddStoredGroup(group.get());
   storage->AddStoredCache(cache.get());
 
@@ skipping 12 matching lines @@
 }
 
 TEST_F(MockAppCacheStorageTest, BasicFindMainFallbackResponse) {
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a complete cache with a
   // fallback namespace and entry.
-  const int64 kCacheId = storage->NewCacheId();
+  const int64_t kCacheId = storage->NewCacheId();
   const GURL kFallbackEntryUrl1("http://blah/fallback_entry1");
   const GURL kFallbackNamespaceUrl1("http://blah/fallback_namespace/");
   const GURL kFallbackEntryUrl2("http://blah/fallback_entry2");
   const GURL kFallbackNamespaceUrl2("http://blah/fallback_namespace/longer");
   const GURL kManifestUrl("http://blah/manifest");
-  const int64 kResponseId1 = 1;
-  const int64 kResponseId2 = 2;
+  const int64_t kResponseId1 = 1;
+  const int64_t kResponseId2 = 2;
 
   AppCacheManifest manifest;
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl1,
                 kFallbackEntryUrl1, false));
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl2,
                 kFallbackEntryUrl2, false));
 
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId));
@@ skipping 32 matching lines @@
 TEST_F(MockAppCacheStorageTest, FindMainResponseWithMultipleCandidates) {
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create 2 complete caches with an entry
   // for the same url.
 
   const GURL kEntryUrl("http://blah/entry");
-  const int64 kCacheId1 = storage->NewCacheId();
-  const int64 kCacheId2 = storage->NewCacheId();
+  const int64_t kCacheId1 = storage->NewCacheId();
+  const int64_t kCacheId2 = storage->NewCacheId();
   const GURL kManifestUrl1("http://blah/manifest1");
   const GURL kManifestUrl2("http://blah/manifest2");
-  const int64 kResponseId1 = 1;
-  const int64 kResponseId2 = 2;
+  const int64_t kResponseId1 = 1;
+  const int64_t kResponseId2 = 2;
 
   // The first cache.
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId1));
   cache->AddEntry(
       kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, kResponseId1));
   cache->set_complete(true);
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), kManifestUrl1, 111));
   group->AddCache(cache.get());
   storage->AddStoredGroup(group.get());
@@ skipping 29 matching lines @@
 
 TEST_F(MockAppCacheStorageTest, FindMainResponseExclusions) {
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a complete cache with a
   // foreign entry and an online namespace.
 
-  const int64 kCacheId = storage->NewCacheId();
+  const int64_t kCacheId = storage->NewCacheId();
   const GURL kEntryUrl("http://blah/entry");
   const GURL kManifestUrl("http://blah/manifest");
   const GURL kOnlineNamespaceUrl("http://blah/online_namespace");
-  const int64 kResponseId = 1;
+  const int64_t kResponseId = 1;
 
   AppCacheManifest manifest;
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl,
                 GURL(), false));
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kEntryUrl,
       AppCacheEntry(AppCacheEntry::EXPLICIT | AppCacheEntry::FOREIGN,
@@ skipping 32 matching lines @@
   EXPECT_EQ(kAppCacheNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kAppCacheNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kAppCacheNoResponseId,
             delegate.found_fallback_entry_.response_id());
   EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 }  // namespace content