Switch to standard integer types in content/browser/.

content/browser/appcache/mock_appcache_storage.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 "content/browser/appcache/mock_appcache_storage.h"
 
+#include <stddef.h>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_group.h"
@@ skipping 30 matching lines @@
 MockAppCacheStorage::~MockAppCacheStorage() {
 }
 
 void MockAppCacheStorage::GetAllInfo(Delegate* delegate) {
   ScheduleTask(
       base::Bind(&MockAppCacheStorage::ProcessGetAllInfo,
                  weak_factory_.GetWeakPtr(),
                  make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
-void MockAppCacheStorage::LoadCache(int64 id, Delegate* delegate) {
+void MockAppCacheStorage::LoadCache(int64_t id, Delegate* delegate) {
   DCHECK(delegate);
   AppCache* cache = working_set_.GetCache(id);
   if (ShouldCacheLoadAppearAsync(cache)) {
     ScheduleTask(
         base::Bind(&MockAppCacheStorage::ProcessLoadCache,
                    weak_factory_.GetWeakPtr(), id,
                    make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
   ProcessLoadCache(id, GetOrCreateDelegateReference(delegate));
@@ skipping 55 matching lines @@
   }
 
   GURL fallback_namespace_not_used;
   GURL intercept_namespace_not_used;
   cache->FindResponseForRequest(
       url, found_entry, &intercept_namespace_not_used,
       found_fallback_entry,  &fallback_namespace_not_used,
       found_network_namespace);
 }
 
-void MockAppCacheStorage::MarkEntryAsForeign(
-    const GURL& entry_url, int64 cache_id) {
+void MockAppCacheStorage::MarkEntryAsForeign(const GURL& entry_url,
+                                             int64_t cache_id) {
   AppCache* cache = working_set_.GetCache(cache_id);
   if (cache) {
     AppCacheEntry* entry = cache->GetEntry(entry_url);
     DCHECK(entry);
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
   }
 }
 
 void MockAppCacheStorage::MakeGroupObsolete(AppCacheGroup* group,
@@ skipping 10 matching lines @@
                  response_code));
 }
 
 void MockAppCacheStorage::StoreEvictionTimes(AppCacheGroup* group) {
   stored_eviction_times_[group->group_id()] =
       std::make_pair(group->last_full_update_check_time(),
                      group->first_evictable_error_time());
 }
 
 AppCacheResponseReader* MockAppCacheStorage::CreateResponseReader(
-    const GURL& manifest_url, int64 group_id, int64 response_id) {
+    const GURL& manifest_url,
+    int64_t group_id,
+    int64_t response_id) {
   if (simulated_reader_)
     return simulated_reader_.release();
   return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* MockAppCacheStorage::CreateResponseWriter(
-    const GURL& manifest_url, int64 group_id) {
+    const GURL& manifest_url,
+    int64_t group_id) {
   return new AppCacheResponseWriter(NewResponseId(),  group_id, disk_cache());
 }
 
 AppCacheResponseMetadataWriter*
-MockAppCacheStorage::CreateResponseMetadataWriter(int64 group_id,
-                                                  int64 response_id) {
+MockAppCacheStorage::CreateResponseMetadataWriter(int64_t group_id,
+                                                  int64_t response_id) {
   return new AppCacheResponseMetadataWriter(response_id, group_id,
                                             disk_cache());
 }
 
 void MockAppCacheStorage::DoomResponses(
-    const GURL& manifest_url, const std::vector<int64>& response_ids) {
+    const GURL& manifest_url,
+    const std::vector<int64_t>& response_ids) {
   DeleteResponses(manifest_url, response_ids);
 }
 
 void MockAppCacheStorage::DeleteResponses(
-    const GURL& manifest_url, const std::vector<int64>& response_ids) {
+    const GURL& manifest_url,
+    const std::vector<int64_t>& response_ids) {
   // We don't bother with actually removing responses from the disk-cache,
   // just keep track of which ids have been doomed or deleted
-  std::vector<int64>::const_iterator it = response_ids.begin();
+  std::vector<int64_t>::const_iterator it = response_ids.begin();
   while (it != response_ids.end()) {
     doomed_response_ids_.insert(*it);
     ++it;
   }
 }
 
 void MockAppCacheStorage::ProcessGetAllInfo(
     scoped_refptr<DelegateReference> delegate_ref) {
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnAllInfo(simulated_appcache_info_.get());
 }
 
 void MockAppCacheStorage::ProcessLoadCache(
-    int64 id, scoped_refptr<DelegateReference> delegate_ref) {
+    int64_t id,
+    scoped_refptr<DelegateReference> delegate_ref) {
   AppCache* cache = working_set_.GetCache(id);
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnCacheLoaded(cache, id);
 }
 
 void MockAppCacheStorage::ProcessLoadOrCreateGroup(
     const GURL& manifest_url, scoped_refptr<DelegateReference> delegate_ref) {
   scoped_refptr<AppCacheGroup> group(working_set_.GetGroup(manifest_url));
 
   // Newly created groups are not put in the stored_groups collection
@@ skipping 32 matching lines @@
   if (delegate)
     delegate->OnGroupAndNewestCacheStored(
         group.get(), newest_cache.get(), true, false);
 }
 
 namespace {
 
 struct FoundCandidate {
   GURL namespace_entry_url;
   AppCacheEntry entry;
-  int64 cache_id;
-  int64 group_id;
+  int64_t cache_id;
+  int64_t group_id;
   GURL manifest_url;
   bool is_cache_in_use;
 
   FoundCandidate()
       : cache_id(kAppCacheNoCacheId), group_id(0), is_cache_in_use(false) {}
 };
 
 void MaybeTakeNewNamespaceEntry(
     AppCacheNamespaceType namespace_type,
     const AppCacheEntry &entry,
@@ skipping 201 matching lines @@
 }
 
 void MockAppCacheStorage::RunOnePendingTask() {
   DCHECK(!pending_tasks_.empty());
   base::Closure task = pending_tasks_.front();
   pending_tasks_.pop_front();
   task.Run();
 }
 
 void MockAppCacheStorage::AddStoredCache(AppCache* cache) {
-  int64 cache_id = cache->cache_id();
+  int64_t cache_id = cache->cache_id();
   if (stored_caches_.find(cache_id) == stored_caches_.end()) {
     stored_caches_.insert(
         StoredCacheMap::value_type(cache_id, make_scoped_refptr(cache)));
   }
 }
 
 void MockAppCacheStorage::RemoveStoredCache(AppCache* cache) {
   // Do not remove from the working set, active caches are still usable
   // and may be looked up by id until they fall out of use.
   stored_caches_.erase(cache->cache_id());
@@ skipping 56 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace content