Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_url_request_job.cc

 // Copyright (c) 2012 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_url_request_job.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 38 matching lines @@
       on_prepare_to_restart_callback_(restart_callback),
       weak_factory_(this) {
   DCHECK(storage_);
 }
 
 AppCacheURLRequestJob::~AppCacheURLRequestJob() {
   if (storage_)
     storage_->CancelDelegateCallbacks(this);
 }
 
-void AppCacheURLRequestJob::DeliverAppCachedResponse(
-    const GURL& manifest_url, int64 group_id, int64 cache_id,
-    const AppCacheEntry& entry, bool is_fallback) {
+void AppCacheURLRequestJob::DeliverAppCachedResponse(const GURL& manifest_url,
+                                                     int64_t group_id,
+                                                     int64_t cache_id,
+                                                     const AppCacheEntry& entry,
+                                                     bool is_fallback) {
   DCHECK(!has_delivery_orders());
   DCHECK(entry.has_response_id());
   delivery_type_ = APPCACHED_DELIVERY;
   manifest_url_ = manifest_url;
   group_id_ = group_id;
   cache_id_ = cache_id;
   entry_ = entry;
   is_fallback_ = is_fallback;
   MaybeBeginDelivery();
 }
@@ skipping 88 matching lines @@
   // provides a response. The sequence goes like this...
   //
   // 1. First we load the cache.
   // 2. Then if the handler is not spun up, we load the script resource which
   //    is needed to spin it up.
   // 3. Then we ask then we ask the handler to compute a response.
   // 4. Finally we deilver that response to the caller.
   storage_->LoadCache(cache_id_, this);
 }
 
-void AppCacheURLRequestJob::OnCacheLoaded(AppCache* cache, int64 cache_id) {
+void AppCacheURLRequestJob::OnCacheLoaded(AppCache* cache, int64_t cache_id) {
   DCHECK_EQ(cache_id_, cache_id);
   DCHECK(!has_been_killed());
 
   if (!cache) {
     BeginErrorDelivery("cache load failed");
     return;
   }
 
   // Keep references to ensure they don't go out of scope until job completion.
   cache_ = cache;
   group_ = cache->owning_group();
 
   // If the handler is spun up, ask it to compute a response.
   AppCacheExecutableHandler* handler =
       cache->GetExecutableHandler(entry_.response_id());
   if (handler) {
     InvokeExecutableHandler(handler);
     return;
   }
 
   // Handler is not spun up yet, load the script resource to do that.
   // NOTE: This is not ideal since multiple jobs may be doing this,
   // concurrently but close enough for now, the first to load the script
   // will win.
 
   // Read the script data, truncating if its too large.
   // NOTE: we just issue one read and don't bother chaining if the resource
   // is very (very) large, close enough for now.
-  const int64 kLimit = 500 * 1000;
+  const int64_t kLimit = 500 * 1000;
   handler_source_buffer_ = new net::GrowableIOBuffer();
   handler_source_buffer_->SetCapacity(kLimit);
   handler_source_reader_.reset(storage_->CreateResponseReader(
       manifest_url_, group_id_, entry_.response_id()));
   handler_source_reader_->ReadData(
       handler_source_buffer_.get(),
       kLimit,
       base::Bind(&AppCacheURLRequestJob::OnExecutableSourceLoaded,
                  base::Unretained(this)));
 }
@@ skipping 59 matching lines @@
 void AppCacheURLRequestJob::BeginErrorDelivery(const char* message) {
   if (host_)
     host_->frontend()->OnLogMessage(host_->host_id(), APPCACHE_LOG_ERROR,
                                     message);
   delivery_type_ = ERROR_DELIVERY;
   storage_ = NULL;
   BeginDelivery();
 }
 
 void AppCacheURLRequestJob::OnResponseInfoLoaded(
-      AppCacheResponseInfo* response_info, int64 response_id) {
+    AppCacheResponseInfo* response_info,
+    int64_t response_id) {
   DCHECK(is_delivering_appcache_response());
   if (response_info) {
     info_ = response_info;
     reader_.reset(storage_->CreateResponseReader(
         manifest_url_, group_id_, entry_.response_id()));
 
     if (is_range_request())
       SetupRangeResponse();
 
     NotifyHeadersComplete();
@@ skipping 154 matching lines @@
   if (ranges.size() == 1U)
     range_requested_ = ranges[0];
 }
 
 void AppCacheURLRequestJob::NotifyRestartRequired() {
   on_prepare_to_restart_callback_.Run();
   URLRequestJob::NotifyRestartRequired();
 }
 
 }  // namespace content