Switch to standard integer types in content/browser/.

content/browser/loader/resource_scheduler.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/loader/resource_scheduler.h"
 
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/supports_user_data.h"
 #include "base/time/time.h"
 #include "content/common/resource_messages.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
@@ skipping 137 matching lines @@
   bool IsQueued(ScheduledResourceRequest* request) const {
     return ContainsKey(pointers_, request);
   }
 
   // Returns true if no requests are queued.
   bool IsEmpty() const { return queue_.size() == 0; }
 
  private:
   typedef std::map<ScheduledResourceRequest*, NetQueue::iterator> PointerMap;
 
-  uint32 MakeFifoOrderingId() {
+  uint32_t MakeFifoOrderingId() {
     fifo_ordering_ids_ += 1;
     return fifo_ordering_ids_;
   }
 
   // Used to create an ordering ID for scheduled resources so that resources
   // with same priority/intra_priority stay in fifo order.
-  uint32 fifo_ordering_ids_;
+  uint32_t fifo_ordering_ids_;
 
   NetQueue queue_;
   PointerMap pointers_;
 };
 
 // This is the handle we return to the ResourceDispatcherHostImpl so it can
 // interact with the request.
 class ResourceScheduler::ScheduledResourceRequest : public ResourceThrottle {
  public:
   ScheduledResourceRequest(const ClientId& client_id,
@@ skipping 87 matching lines @@
   void set_request_priority_params(const RequestPriorityParams& priority) {
     priority_ = priority;
   }
   const RequestPriorityParams& get_request_priority_params() const {
     return priority_;
   }
   const ClientId& client_id() const { return client_id_; }
   net::URLRequest* url_request() { return request_; }
   const net::URLRequest* url_request() const { return request_; }
   bool is_async() const { return is_async_; }
-  uint32 fifo_ordering() const { return fifo_ordering_; }
-  void set_fifo_ordering(uint32 fifo_ordering) {
+  uint32_t fifo_ordering() const { return fifo_ordering_; }
+  void set_fifo_ordering(uint32_t fifo_ordering) {
     fifo_ordering_ = fifo_ordering;
   }
   RequestAttributes attributes() const {
     return attributes_;
   }
   void set_attributes(RequestAttributes attributes) {
     attributes_ = attributes;
   }
 
  private:
@@ skipping 22 matching lines @@
 
   const ClientId client_id_;
   const ResourceScheduler::ClientState client_state_on_creation_;
   net::URLRequest* request_;
   bool ready_;
   bool deferred_;
   bool is_async_;
   RequestAttributes attributes_;
   ResourceScheduler* scheduler_;
   RequestPriorityParams priority_;
-  uint32 fifo_ordering_;
+  uint32_t fifo_ordering_;
   base::TimeTicks time_deferred_;
 
   base::WeakPtrFactory<ResourceScheduler::ScheduledResourceRequest>
       weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ScheduledResourceRequest);
 };
 
 const void* const ResourceScheduler::ScheduledResourceRequest::kUserDataKey =
     &ResourceScheduler::ScheduledResourceRequest::kUserDataKey;
@@ skipping 1026 matching lines @@
   client->ReprioritizeRequest(scheduled_resource_request, old_priority_params,
                               new_priority_params);
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content