Switch to standard integer types in content/renderer/.

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
+#include "build/build_config.h"
 #include "cc/base/histograms.h"
 #include "cc/base/switches.h"
 #include "cc/blink/web_external_bitmap_impl.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/layer_settings.h"
 #include "cc/raster/task_graph_runner.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/scheduler/child/webthread_base.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
@@ skipping 169 matching lines @@
 using blink::WebRuntimeFeatures;
 using blink::WebScriptController;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebView;
 
 namespace content {
 
 namespace {
 
-const int64 kInitialIdleHandlerDelayMs = 1000;
-const int64 kLongIdleHandlerDelayMs = 30*1000;
+const int64_t kInitialIdleHandlerDelayMs = 1000;
+const int64_t kLongIdleHandlerDelayMs = 30 * 1000;
 
 #if defined(OS_ANDROID)
 // On Android, resource messages can each take ~1.5ms to dispatch on the browser
 // IO thread. Limiting the message rate to 3/frame at 60hz ensures that the
 // induced work takes but a fraction (~1/4) of the overall frame budget.
 const int kMaxResourceRequestsPerFlushWhenThrottled = 3;
 #else
 const int kMaxResourceRequestsPerFlushWhenThrottled = 8;
 #endif
 const double kThrottledResourceRequestFlushPeriodS = 1. / 60.;
@@ skipping 790 matching lines @@
 
 IPC::SyncMessageFilter* RenderThreadImpl::GetSyncMessageFilter() {
   return sync_message_filter();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetIOMessageLoopProxy() {
   return ChildProcess::current()->io_task_runner();
 }
 
-void RenderThreadImpl::AddRoute(int32 routing_id, IPC::Listener* listener) {
+void RenderThreadImpl::AddRoute(int32_t routing_id, IPC::Listener* listener) {
   ChildThreadImpl::GetRouter()->AddRoute(routing_id, listener);
   PendingRenderFrameConnectMap::iterator it =
       pending_render_frame_connects_.find(routing_id);
   if (it == pending_render_frame_connects_.end())
     return;
 
   RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(routing_id);
   if (!frame)
     return;
 
   scoped_refptr<PendingRenderFrameConnect> connection(it->second);
   mojo::InterfaceRequest<mojo::ServiceProvider> services(
       connection->services().Pass());
   mojo::ServiceProviderPtr exposed_services(
       connection->exposed_services().Pass());
   exposed_services.set_connection_error_handler(mojo::Closure());
   pending_render_frame_connects_.erase(it);
 
   frame->BindServiceRegistry(services.Pass(), exposed_services.Pass());
 }
 
-void RenderThreadImpl::RemoveRoute(int32 routing_id) {
+void RenderThreadImpl::RemoveRoute(int32_t routing_id) {
   ChildThreadImpl::GetRouter()->RemoveRoute(routing_id);
 }
 
-void RenderThreadImpl::AddEmbeddedWorkerRoute(int32 routing_id,
+void RenderThreadImpl::AddEmbeddedWorkerRoute(int32_t routing_id,
                                               IPC::Listener* listener) {
   AddRoute(routing_id, listener);
   if (devtools_agent_message_filter_.get()) {
     devtools_agent_message_filter_->AddEmbeddedWorkerRouteOnMainThread(
         routing_id);
   }
 }
 
-void RenderThreadImpl::RemoveEmbeddedWorkerRoute(int32 routing_id) {
+void RenderThreadImpl::RemoveEmbeddedWorkerRoute(int32_t routing_id) {
   RemoveRoute(routing_id);
   if (devtools_agent_message_filter_.get()) {
     devtools_agent_message_filter_->RemoveEmbeddedWorkerRouteOnMainThread(
         routing_id);
   }
 }
 
 void RenderThreadImpl::RegisterPendingRenderFrameConnect(
     int routing_id,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
@@ skipping 243 matching lines @@
 
 cc::SharedBitmapManager* RenderThreadImpl::GetSharedBitmapManager() {
   return shared_bitmap_manager();
 }
 
 void RenderThreadImpl::RegisterExtension(v8::Extension* extension) {
   EnsureWebKitInitialized();
   WebScriptController::registerExtension(extension);
 }
 
-void RenderThreadImpl::ScheduleIdleHandler(int64 initial_delay_ms) {
+void RenderThreadImpl::ScheduleIdleHandler(int64_t initial_delay_ms) {
   idle_notification_delay_in_ms_ = initial_delay_ms;
   idle_timer_.Stop();
   idle_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(initial_delay_ms),
       this, &RenderThreadImpl::IdleHandler);
 }
 
 void RenderThreadImpl::IdleHandler() {
   bool run_in_foreground_tab = (widget_count_ > hidden_widget_count_) &&
                                GetContentClient()->renderer()->
@@ skipping 33 matching lines @@
                  idle_notification_delay_in_ms_ +
                  1000000 / (idle_notification_delay_in_ms_ + 2000)));
 
   } else {
     idle_timer_.Stop();
   }
 
   FOR_EACH_OBSERVER(RenderProcessObserver, observers_, IdleNotification());
 }
 
-int64 RenderThreadImpl::GetIdleNotificationDelayInMs() const {
+int64_t RenderThreadImpl::GetIdleNotificationDelayInMs() const {
   return idle_notification_delay_in_ms_;
 }
 
 void RenderThreadImpl::SetIdleNotificationDelayInMs(
-    int64 idle_notification_delay_in_ms) {
+    int64_t idle_notification_delay_in_ms) {
   idle_notification_delay_in_ms_ = idle_notification_delay_in_ms;
 }
 
 void RenderThreadImpl::UpdateHistograms(int sequence_number) {
   child_histogram_message_filter()->SendHistograms(sequence_number);
 }
 
 int RenderThreadImpl::PostTaskToAllWebWorkers(const base::Closure& closure) {
   return WorkerThreadRegistry::Instance()->PostTaskToAllThreads(closure);
 }
@@ skipping 247 matching lines @@
 RenderThreadImpl::GetIOThreadTaskRunner() {
   return io_thread_task_runner_;
 }
 
 scoped_ptr<base::SharedMemory> RenderThreadImpl::AllocateSharedMemory(
     size_t size) {
   return HostAllocateSharedMemoryBuffer(size);
 }
 
 CreateCommandBufferResult RenderThreadImpl::CreateViewCommandBuffer(
-      int32 surface_id,
-      const GPUCreateCommandBufferConfig& init_params,
-      int32 route_id) {
+    int32_t surface_id,
+    const GPUCreateCommandBufferConfig& init_params,
+    int32_t route_id) {
   NOTREACHED();
   return CREATE_COMMAND_BUFFER_FAILED;
 }
 
 void RenderThreadImpl::DoNotNotifyWebKitOfModalLoop() {
   notify_webkit_of_modal_loop_ = false;
 }
 
 bool RenderThreadImpl::OnControlMessageReceived(const IPC::Message& msg) {
   base::ObserverListBase<RenderProcessObserver>::Iterator it(&observers_);
@@ skipping 415 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content