Switch to standard integer types in content/.

content/child/resource_dispatcher.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/debug/stack_trace.h"
 #include "base/files/file_path.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
+#include "build/build_config.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/child/resource_scheduling_filter.h"
 #include "content/child/shared_memory_received_data_factory.h"
 #include "content/child/site_isolation_stats_gatherer.h"
 #include "content/child/sync_load_response.h"
 #include "content/child/threaded_data_provider.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/navigation_params.h"
 #include "content/common/resource_messages.h"
@@ skipping 97 matching lines @@
 ResourceDispatcher::PendingRequestInfo*
 ResourceDispatcher::GetPendingRequestInfo(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     // This might happen for kill()ed requests on the webkit end.
     return NULL;
   }
   return &(it->second);
 }
 
-void ResourceDispatcher::OnUploadProgress(int request_id, int64 position,
-                                          int64 size) {
+void ResourceDispatcher::OnUploadProgress(int request_id,
+                                          int64_t position,
+                                          int64_t size) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   request_info->peer->OnUploadProgress(position, size);
 
   // Acknowledge receipt
   message_sender_->Send(new ResourceHostMsg_UploadProgress_ACK(request_id));
 }
 
@@ skipping 566 matching lines @@
     const PendingRequestInfo& request_info,
     const base::TimeTicks& browser_completion_time) const {
   if (request_info.completion_time.is_null()) {
     return browser_completion_time;
   }
 
   // TODO(simonjam): The optimal lower bound should be the most recent value of
   // TimeTicks::Now() returned to WebKit. Is it worth trying to cache that?
   // Until then, |response_start| is used as it is the most recent value
   // returned for this request.
-  int64 result = std::max(browser_completion_time.ToInternalValue(),
-                          request_info.response_start.ToInternalValue());
+  int64_t result = std::max(browser_completion_time.ToInternalValue(),
+                            request_info.response_start.ToInternalValue());
   result = std::min(result, request_info.completion_time.ToInternalValue());
   return base::TimeTicks::FromInternalValue(result);
 }
 
 base::TimeTicks ResourceDispatcher::ConsumeIOTimestamp() {
   if (io_timestamp_ == base::TimeTicks())
     return base::TimeTicks::Now();
   base::TimeTicks result = io_timestamp_;
   io_timestamp_ = base::TimeTicks();
   return result;
@@ skipping 123 matching lines @@
     *frame_origin = extra_data->frame_origin();
   return request.Pass();
 }
 
 void ResourceDispatcher::SetResourceSchedulingFilter(
     scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter) {
   resource_scheduling_filter_ = resource_scheduling_filter;
 }
 
 }  // namespace content