Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_host.cc

 // 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.
 
 #include "content/browser/appcache/appcache_host.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/appcache/appcache.h"
@@ skipping 63 matching lines @@
 
 void AppCacheHost::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void AppCacheHost::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool AppCacheHost::SelectCache(const GURL& document_url,
-                               const int64 cache_document_was_loaded_from,
+                               const int64_t cache_document_was_loaded_from,
                                const GURL& manifest_url) {
   if (was_select_cache_called_)
     return false;
 
   DCHECK(pending_start_update_callback_.is_null() &&
          pending_swap_cache_callback_.is_null() &&
          pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
   was_select_cache_called_ = true;
@@ skipping 68 matching lines @@
          pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
   was_select_cache_called_ = true;
   parent_process_id_ = parent_process_id;
   parent_host_id_ = parent_host_id;
   FinishCacheSelection(NULL, NULL);
   return true;
 }
 
-bool AppCacheHost::SelectCacheForSharedWorker(int64 appcache_id) {
+bool AppCacheHost::SelectCacheForSharedWorker(int64_t appcache_id) {
   if (was_select_cache_called_)
     return false;
 
   DCHECK(pending_start_update_callback_.is_null() &&
          pending_swap_cache_callback_.is_null() &&
          pending_get_status_callback_.is_null() &&
          !is_selection_pending());
 
   was_select_cache_called_ = true;
   if (appcache_id != kAppCacheNoCacheId) {
     LoadSelectedCache(appcache_id);
     return true;
   }
   FinishCacheSelection(NULL, NULL);
   return true;
 }
 
 // TODO(michaeln): change method name to MarkEntryAsForeign for consistency
 bool AppCacheHost::MarkAsForeignEntry(const GURL& document_url,
-                                      int64 cache_document_was_loaded_from) {
+                                      int64_t cache_document_was_loaded_from) {
   if (was_select_cache_called_)
     return false;
 
   // The document url is not the resource url in the fallback case.
   storage()->MarkEntryAsForeign(
       main_resource_was_namespace_entry_ ? namespace_entry_url_ : document_url,
       cache_document_was_loaded_from);
   SelectCache(document_url, kAppCacheNoCacheId, GURL());
   return true;
 }
@@ skipping 167 matching lines @@
   storage()->LoadOrCreateGroup(manifest_url, this);
 }
 
 void AppCacheHost::OnGroupLoaded(AppCacheGroup* group,
                                  const GURL& manifest_url) {
   DCHECK(manifest_url == pending_selected_manifest_url_);
   pending_selected_manifest_url_ = GURL();
   FinishCacheSelection(NULL, group);
 }
 
-void AppCacheHost::LoadSelectedCache(int64 cache_id) {
+void AppCacheHost::LoadSelectedCache(int64_t cache_id) {
   DCHECK(cache_id != kAppCacheNoCacheId);
   pending_selected_cache_id_ = cache_id;
   storage()->LoadCache(cache_id, this);
 }
 
-void AppCacheHost::OnCacheLoaded(AppCache* cache, int64 cache_id) {
+void AppCacheHost::OnCacheLoaded(AppCache* cache, int64_t cache_id) {
   if (cache_id == pending_main_resource_cache_id_) {
     pending_main_resource_cache_id_ = kAppCacheNoCacheId;
     main_resource_cache_ = cache;
   } else if (cache_id == pending_selected_cache_id_) {
     pending_selected_cache_id_ = kAppCacheNoCacheId;
     FinishCacheSelection(cache, NULL);
   }
 }
 
 void AppCacheHost::FinishCacheSelection(
@@ skipping 98 matching lines @@
     swappable_cache_ = NULL;
   } else {
     AppCache* new_cache = group->newest_complete_cache();
     if (new_cache != associated_cache_.get())
       swappable_cache_ = new_cache;
     else
       swappable_cache_ = NULL;
   }
 }
 
-void AppCacheHost::LoadMainResourceCache(int64 cache_id) {
+void AppCacheHost::LoadMainResourceCache(int64_t cache_id) {
   DCHECK(cache_id != kAppCacheNoCacheId);
   if (pending_main_resource_cache_id_ == cache_id ||
       (main_resource_cache_.get() &&
        main_resource_cache_->cache_id() == cache_id)) {
     return;
   }
   pending_main_resource_cache_id_ = cache_id;
   storage()->LoadCache(cache_id, this);
 }
 
@@ skipping 50 matching lines @@
   associated_cache_info_pending_ = cache && !cache->is_complete();
   AppCacheInfo info;
   if (cache)
     cache->AssociateHost(this);
 
   FillCacheInfo(cache, manifest_url, GetStatus(), &info);
   frontend_->OnCacheSelected(host_id_, info);
 }
 
 }  // namespace content