Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_host.h

 // Copyright (c) 2011 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_APPCACHE_HOST_H_
 #define CONTENT_BROWSER_APPCACHE_APPCACHE_HOST_H_
 
+#include <stdint.h>
+
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/common/appcache_interfaces.h"
 #include "content/common/content_export.h"
 #include "content/public/common/resource_type.h"
 #include "url/gurl.h"
 
@@ skipping 51 matching lines @@
                AppCacheServiceImpl* service);
   ~AppCacheHost() override;
 
   // Adds/removes an observer, the AppCacheHost does not take
   // ownership of the observer.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Support for cache selection and scriptable method calls.
   bool SelectCache(const GURL& document_url,
-                   const int64 cache_document_was_loaded_from,
+                   const int64_t cache_document_was_loaded_from,
                    const GURL& manifest_url);
   bool SelectCacheForWorker(int parent_process_id,
                             int parent_host_id);
-  bool SelectCacheForSharedWorker(int64 appcache_id);
+  bool SelectCacheForSharedWorker(int64_t appcache_id);
   bool MarkAsForeignEntry(const GURL& document_url,
-                          int64 cache_document_was_loaded_from);
+                          int64_t cache_document_was_loaded_from);
   void GetStatusWithCallback(const GetStatusCallback& callback,
                              void* callback_param);
   void StartUpdateWithCallback(const StartUpdateCallback& callback,
                                void* callback_param);
   void SwapCacheWithCallback(const SwapCacheCallback& callback,
                              void* callback_param);
 
   // Called prior to the main resource load. When the system contains multiple
   // candidates for a main resource load, the appcache preferred by the host
   // that created this host is used to break ties.
@@ skipping 38 matching lines @@
   // Associations with complete caches are established either thru the cache
   // selection algorithm implemented (in this class), or by the update algorithm
   // (see AppCacheUpdateJob).
   void AssociateCompleteCache(AppCache* cache);
 
   // Adds a reference to the newest complete cache in a group, unless it's the
   // same as the cache that is currently associated with the host.
   void SetSwappableCache(AppCacheGroup* group);
 
   // Used to ensure that a loaded appcache survives a frame navigation.
-  void LoadMainResourceCache(int64 cache_id);
+  void LoadMainResourceCache(int64_t cache_id);
 
   // Used to notify the host that a namespace resource is being delivered as
   // the main resource of the page and to provide its url.
   void NotifyMainResourceIsNamespaceEntry(const GURL& namespace_entry_url);
 
   // Used to notify the host that the main resource was blocked by a policy. To
   // work properly, this method needs to by invoked prior to cache selection.
   void NotifyMainResourceBlocked(const GURL& manifest_url);
 
   // Used by the update job to keep track of which hosts are associated
@@ skipping 23 matching lines @@
   void PrepareForTransfer();
   void CompleteTransfer(int host_id, AppCacheFrontend* frontend);
 
  private:
   friend class content::AppCacheHostTest;
   friend class content::AppCacheStorageImplTest;
   friend class content::AppCacheRequestHandlerTest;
   friend class content::AppCacheUpdateJobTest;
 
   AppCacheStatus GetStatus();
-  void LoadSelectedCache(int64 cache_id);
+  void LoadSelectedCache(int64_t cache_id);
   void LoadOrCreateGroup(const GURL& manifest_url);
 
   // See public Associate*Host() methods above.
   void AssociateCacheHelper(AppCache* cache, const GURL& manifest_url);
 
   // AppCacheStorage::Delegate impl
-  void OnCacheLoaded(AppCache* cache, int64 cache_id) override;
+  void OnCacheLoaded(AppCache* cache, int64_t cache_id) override;
   void OnGroupLoaded(AppCacheGroup* group, const GURL& manifest_url) override;
   // AppCacheServiceImpl::Observer impl
   void OnServiceReinitialized(
       AppCacheStorageReference* old_storage_ref) override;
 
   void FinishCacheSelection(AppCache* cache, AppCacheGroup* group);
   void DoPendingGetStatus();
   void DoPendingStartUpdate();
   void DoPendingSwapCache();
 
@@ skipping 47 matching lines @@
   scoped_refptr<AppCacheGroup> group_being_updated_;
 
   // Similarly, keep a reference to the newest cache of the group until the
   // update completes. When adding a new master entry to a cache that is not
   // in use in any other host, this reference keeps the cache in  memory.
   scoped_refptr<AppCache> newest_cache_of_group_being_updated_;
 
   // Keep a reference to the cache of the main resource so it survives frame
   // navigations.
   scoped_refptr<AppCache> main_resource_cache_;
-  int64 pending_main_resource_cache_id_;
+  int64_t pending_main_resource_cache_id_;
 
   // Cache loading is async, if we're loading a specific cache or group
   // for the purposes of cache selection, one or the other of these will
   // indicate which cache or group is being loaded.
-  int64 pending_selected_cache_id_;
+  int64_t pending_selected_cache_id_;
   GURL pending_selected_manifest_url_;
 
   // Used to defend against bad IPC messages.
   bool was_select_cache_called_;
 
   // Used to avoid stepping on pages controlled by ServiceWorkers.
   bool is_cache_selection_enabled_;
 
   // A new master entry to be added to the cache, may be empty.
   GURL new_master_entry_url_;
@@ skipping 57 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, SelectCacheBlocked);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, SelectCacheTwice);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheTest, CleanupUnusedCache);
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_HOST_H_