Switch to standard integer types in content/renderer/.

content/renderer/scheduler/resource_dispatch_throttler.cc

 // Copyright 2015 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/scheduler/resource_dispatch_throttler.h"
 
 #include "base/auto_reset.h"
 #include "base/trace_event/trace_event.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/common/resource_messages.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace content {
 namespace {
 
 bool IsResourceRequest(const IPC::Message& msg) {
   return msg.type() == ResourceHostMsg_RequestResource::ID;
 }
 
 }  // namespace
 
 ResourceDispatchThrottler::ResourceDispatchThrottler(
     IPC::Sender* proxied_sender,
     scheduler::RendererScheduler* scheduler,
     base::TimeDelta flush_period,
-    uint32 max_requests_per_flush)
+    uint32_t max_requests_per_flush)
     : proxied_sender_(proxied_sender),
       scheduler_(scheduler),
       flush_period_(flush_period),
       max_requests_per_flush_(max_requests_per_flush),
       flush_timer_(
           FROM_HERE,
           flush_period_,
           base::Bind(&ResourceDispatchThrottler::Flush, base::Unretained(this)),
           false /* is_repeating */),
       sent_requests_since_last_flush_(0) {
@@ skipping 60 matching lines @@
 
 void ResourceDispatchThrottler::Flush() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT1("loader", "ResourceDispatchThrottler::Flush",
                "total_throttled_messages", throttled_messages_.size());
   sent_requests_since_last_flush_ = 0;
 
   // If high-priority work is no longer anticipated, dispatch can be safely
   // accelerated. Avoid completely flushing in such case in the event that
   // a large number of requests have been throttled.
-  uint32 max_requests = scheduler_->IsHighPriorityWorkAnticipated()
-                            ? max_requests_per_flush_
-                            : max_requests_per_flush_ * 2;
+  uint32_t max_requests = scheduler_->IsHighPriorityWorkAnticipated()
+                              ? max_requests_per_flush_
+                              : max_requests_per_flush_ * 2;
 
   while (!throttled_messages_.empty() &&
          (sent_requests_since_last_flush_ < max_requests ||
           !IsResourceRequest(*throttled_messages_.front()))) {
     IPC::Message* msg = throttled_messages_.front();
     throttled_messages_.pop_front();
     ForwardMessage(msg);
   }
 
   if (!throttled_messages_.empty())
@@ skipping 17 matching lines @@
 
 bool ResourceDispatchThrottler::ForwardMessage(IPC::Message* msg) {
   if (IsResourceRequest(*msg)) {
     last_sent_request_time_ = Now();
     ++sent_requests_since_last_flush_;
   }
   return proxied_sender_->Send(msg);
 }
 
 }  // namespace content