Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_service_impl.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/appcache_service_impl.h"
 
 #include <functional>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.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_backend_impl.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_executable_handler.h"
 #include "content/browser/appcache/appcache_histograms.h"
 #include "content/browser/appcache/appcache_policy.h"
 #include "content/browser/appcache/appcache_quota_client.h"
@@ skipping 225 matching lines @@
   if (collection)
     collection->infos_by_origin.swap(collection_->infos_by_origin);
   CallCallback(collection ? net::OK : net::ERR_FAILED);
   delete this;
 }
 
 // CheckResponseHelper -------
 
 class AppCacheServiceImpl::CheckResponseHelper : AsyncHelper {
  public:
-  CheckResponseHelper(
-      AppCacheServiceImpl* service, const GURL& manifest_url, int64 cache_id,
-      int64 response_id)
+  CheckResponseHelper(AppCacheServiceImpl* service,
+                      const GURL& manifest_url,
+                      int64_t cache_id,
+                      int64_t response_id)
       : AsyncHelper(service, net::CompletionCallback()),
         manifest_url_(manifest_url),
         cache_id_(cache_id),
         response_id_(response_id),
         kIOBufferSize(32 * 1024),
         expected_total_size_(0),
         amount_headers_read_(0),
-        amount_data_read_(0) {
-  }
+        amount_data_read_(0) {}
 
   void Start() override {
     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
   }
 
   void Cancel() override {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::CHECK_CANCELED);
     response_reader_.reset();
     AsyncHelper::Cancel();
   }
 
  private:
   void OnGroupLoaded(AppCacheGroup* group, const GURL& manifest_url) override;
   void OnReadInfoComplete(int result);
   void OnReadDataComplete(int result);
 
   // Inputs describing what to check.
   GURL manifest_url_;
-  int64 cache_id_;
-  int64 response_id_;
+  int64_t cache_id_;
+  int64_t response_id_;
 
   // Internals used to perform the checks.
   const int kIOBufferSize;
   scoped_refptr<AppCache> cache_;
   scoped_ptr<AppCacheResponseReader> response_reader_;
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
   scoped_refptr<net::IOBuffer> data_buffer_;
-  int64 expected_total_size_;
+  int64_t expected_total_size_;
   int amount_headers_read_;
   int amount_data_read_;
   DISALLOW_COPY_AND_ASSIGN(CheckResponseHelper);
 };
 
 void AppCacheServiceImpl::CheckResponseHelper::OnGroupLoaded(
     AppCacheGroup* group, const GURL& manifest_url) {
   DCHECK_EQ(manifest_url_, manifest_url);
   if (!group || !group->newest_complete_cache() || group->is_being_deleted() ||
       group->is_obsolete()) {
@@ skipping 182 matching lines @@
   helper->Start();
 }
 
 void AppCacheServiceImpl::DeleteAppCachesForOrigin(
     const GURL& origin,  const net::CompletionCallback& callback) {
   DeleteOriginHelper* helper = new DeleteOriginHelper(this, origin, callback);
   helper->Start();
 }
 
 void AppCacheServiceImpl::CheckAppCacheResponse(const GURL& manifest_url,
-                                            int64 cache_id,
-                                            int64 response_id) {
+                                                int64_t cache_id,
+                                                int64_t response_id) {
   CheckResponseHelper* helper = new CheckResponseHelper(
       this, manifest_url, cache_id, response_id);
   helper->Start();
 }
 
 void AppCacheServiceImpl::set_special_storage_policy(
     storage::SpecialStoragePolicy* policy) {
   special_storage_policy_ = policy;
 }
 
 void AppCacheServiceImpl::RegisterBackend(
     AppCacheBackendImpl* backend_impl) {
   DCHECK(backends_.find(backend_impl->process_id()) == backends_.end());
   backends_.insert(
       BackendMap::value_type(backend_impl->process_id(), backend_impl));
 }
 
 void AppCacheServiceImpl::UnregisterBackend(
     AppCacheBackendImpl* backend_impl) {
   backends_.erase(backend_impl->process_id());
 }
 
 }  // namespace content