Switch to standard integer types in content/browser/.

content/browser/appcache/mock_appcache_storage.h

 // 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.
 
 #ifndef CONTENT_BROWSER_APPCACHE_MOCK_APPCACHE_STORAGE_H_
 #define CONTENT_BROWSER_APPCACHE_MOCK_APPCACHE_STORAGE_H_
 
+#include <stdint.h>
+
 #include <deque>
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_disk_cache.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_storage.h"
 
 namespace content {
 FORWARD_DECLARE_TEST(AppCacheServiceImplTest, DeleteAppCachesForOrigin);
@@ skipping 18 matching lines @@
 // For use in unit tests.
 // Note: This class is also being used to bootstrap our development efforts.
 // We can get layout tests up and running, and back fill with real storage
 // somewhat in parallel.
 class MockAppCacheStorage : public AppCacheStorage {
  public:
   explicit MockAppCacheStorage(AppCacheServiceImpl* service);
   ~MockAppCacheStorage() override;
 
   void GetAllInfo(Delegate* delegate) override;
-  void LoadCache(int64 id, Delegate* delegate) override;
+  void LoadCache(int64_t id, Delegate* delegate) override;
   void LoadOrCreateGroup(const GURL& manifest_url, Delegate* delegate) override;
   void StoreGroupAndNewestCache(AppCacheGroup* group,
                                 AppCache* newest_cache,
                                 Delegate* delegate) override;
   void FindResponseForMainRequest(const GURL& url,
                                   const GURL& preferred_manifest_url,
                                   Delegate* delegate) override;
   void FindResponseForSubRequest(AppCache* cache,
                                  const GURL& url,
                                  AppCacheEntry* found_entry,
                                  AppCacheEntry* found_fallback_entry,
                                  bool* found_network_namespace) override;
-  void MarkEntryAsForeign(const GURL& entry_url, int64 cache_id) override;
+  void MarkEntryAsForeign(const GURL& entry_url, int64_t cache_id) override;
   void MakeGroupObsolete(AppCacheGroup* group,
                          Delegate* delegate,
                          int response_code) override;
   void StoreEvictionTimes(AppCacheGroup* group) override;
   AppCacheResponseReader* CreateResponseReader(const GURL& manifest_url,
-                                               int64 group_id,
-                                               int64 response_id) override;
+                                               int64_t group_id,
+                                               int64_t response_id) override;
   AppCacheResponseWriter* CreateResponseWriter(const GURL& manifest_url,
-                                               int64 group_id) override;
+                                               int64_t group_id) override;
   AppCacheResponseMetadataWriter* CreateResponseMetadataWriter(
-      int64 group_id,
-      int64 response_id) override;
+      int64_t group_id,
+      int64_t response_id) override;
   void DoomResponses(const GURL& manifest_url,
-                     const std::vector<int64>& response_ids) override;
+                     const std::vector<int64_t>& response_ids) override;
   void DeleteResponses(const GURL& manifest_url,
-                       const std::vector<int64>& response_ids) override;
+                       const std::vector<int64_t>& response_ids) override;
 
  private:
   friend class AppCacheRequestHandlerTest;
   friend class AppCacheServiceImplTest;
   friend class AppCacheUpdateJobTest;
   friend class MockAppCacheStorageTest;
 
-  typedef base::hash_map<int64, scoped_refptr<AppCache> > StoredCacheMap;
+  typedef base::hash_map<int64_t, scoped_refptr<AppCache>> StoredCacheMap;
   typedef std::map<GURL, scoped_refptr<AppCacheGroup> > StoredGroupMap;
-  typedef std::set<int64> DoomedResponseIds;
-  typedef std::map<int64, std::pair<base::Time, base::Time>>
+  typedef std::set<int64_t> DoomedResponseIds;
+  typedef std::map<int64_t, std::pair<base::Time, base::Time>>
       StoredEvictionTimesMap;
 
   void ProcessGetAllInfo(scoped_refptr<DelegateReference> delegate_ref);
-  void ProcessLoadCache(
-      int64 id, scoped_refptr<DelegateReference> delegate_ref);
+  void ProcessLoadCache(int64_t id,
+                        scoped_refptr<DelegateReference> delegate_ref);
   void ProcessLoadOrCreateGroup(
       const GURL& manifest_url, scoped_refptr<DelegateReference> delegate_ref);
   void ProcessStoreGroupAndNewestCache(
       scoped_refptr<AppCacheGroup> group, scoped_refptr<AppCache> newest_cache,
       scoped_refptr<DelegateReference> delegate_ref);
   void ProcessMakeGroupObsolete(scoped_refptr<AppCacheGroup> group,
                                 scoped_refptr<DelegateReference> delegate_ref,
                                 int response_code);
   void ProcessFindResponseForMainRequest(
       const GURL& url, scoped_refptr<DelegateReference> delegate_ref);
@@ skipping 40 matching lines @@
     simulate_make_group_obsolete_failure_ = true;
   }
   void SimulateStoreGroupAndNewestCacheFailure() {
     simulate_store_group_and_newest_cache_failure_ = true;
   }
 
   // Simulate FindResponseFor results for testing. These
   // provided values will be return on the next call to
   // the corresponding Find method, subsequent calls are
   // unaffected.
-  void SimulateFindMainResource(
-      const AppCacheEntry& entry,
-      const GURL& fallback_url,
-      const AppCacheEntry& fallback_entry,
-      int64 cache_id,
-      int64 group_id,
-      const GURL& manifest_url) {
+  void SimulateFindMainResource(const AppCacheEntry& entry,
+                                const GURL& fallback_url,
+                                const AppCacheEntry& fallback_entry,
+                                int64_t cache_id,
+                                int64_t group_id,
+                                const GURL& manifest_url) {
     simulate_find_main_resource_ = true;
     simulate_find_sub_resource_ = false;
     simulated_found_entry_ = entry;
     simulated_found_fallback_url_ = fallback_url;
     simulated_found_fallback_entry_ = fallback_entry;
     simulated_found_cache_id_ = cache_id;
     simulated_found_group_id_ = group_id;
     simulated_found_manifest_url_ = manifest_url,
     simulated_found_network_namespace_ = false;  // N/A to main resource loads
   }
@@ skipping 26 matching lines @@
   scoped_ptr<AppCacheDiskCache> disk_cache_;
   std::deque<base::Closure> pending_tasks_;
 
   bool simulate_make_group_obsolete_failure_;
   bool simulate_store_group_and_newest_cache_failure_;
 
   bool simulate_find_main_resource_;
   bool simulate_find_sub_resource_;
   AppCacheEntry simulated_found_entry_;
   AppCacheEntry simulated_found_fallback_entry_;
-  int64 simulated_found_cache_id_;
-  int64 simulated_found_group_id_;
+  int64_t simulated_found_cache_id_;
+  int64_t simulated_found_group_id_;
   GURL simulated_found_fallback_url_;
   GURL simulated_found_manifest_url_;
   bool simulated_found_network_namespace_;
   scoped_refptr<AppCacheInfoCollection> simulated_appcache_info_;
   scoped_ptr<AppCacheResponseReader> simulated_reader_;
 
   base::WeakPtrFactory<MockAppCacheStorage> weak_factory_;
 
   FRIEND_TEST_ALL_PREFIXES(MockAppCacheStorageTest,
                            BasicFindMainResponse);
@@ skipping 15 matching lines @@
                            StoreExistingGroupExistingCache);
   FRIEND_TEST_ALL_PREFIXES(AppCacheServiceImplTest,
                            DeleteAppCachesForOrigin);
 
   DISALLOW_COPY_AND_ASSIGN(MockAppCacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_MOCK_APPCACHE_STORAGE_H_