Switch to standard integer types in content/renderer/.

content/renderer/pepper/host_var_tracker.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/pepper/host_var_tracker.h"
 
 #include <tuple>
 
 #include "base/logging.h"
 #include "content/renderer/pepper/host_array_buffer_var.h"
@@ skipping 24 matching lines @@
 bool HostVarTracker::V8ObjectVarKey::operator<(
     const V8ObjectVarKey& other) const {
   return std::tie(instance, hash) < std::tie(other.instance, other.hash);
 }
 
 HostVarTracker::HostVarTracker()
     : VarTracker(SINGLE_THREADED), last_shared_memory_map_id_(0) {}
 
 HostVarTracker::~HostVarTracker() {}
 
-ArrayBufferVar* HostVarTracker::CreateArrayBuffer(uint32 size_in_bytes) {
+ArrayBufferVar* HostVarTracker::CreateArrayBuffer(uint32_t size_in_bytes) {
   return new HostArrayBufferVar(size_in_bytes);
 }
 
 ArrayBufferVar* HostVarTracker::CreateShmArrayBuffer(
-    uint32 size_in_bytes,
+    uint32_t size_in_bytes,
     base::SharedMemoryHandle handle) {
   return new HostArrayBufferVar(size_in_bytes, handle);
 }
 
 void HostVarTracker::AddV8ObjectVar(V8ObjectVar* object_var) {
   CheckThreadingPreconditions();
   v8::HandleScope handle_scope(object_var->instance()->GetIsolate());
   DCHECK(GetForV8Object(object_var->instance()->pp_instance(),
                         object_var->GetHandle()) == object_map_.end());
   object_map_.insert(std::make_pair(V8ObjectVarKey(object_var), object_var));
@@ skipping 86 matching lines @@
 
   for (ObjectMap::iterator it = range.first; it != range.second; ++it) {
     if (object == it->second->GetHandle())
       return it;
   }
   return object_map_.end();
 }
 
 int HostVarTracker::TrackSharedMemoryHandle(PP_Instance instance,
                                             base::SharedMemoryHandle handle,
-                                            uint32 size_in_bytes) {
+                                            uint32_t size_in_bytes) {
   SharedMemoryMapEntry entry;
   entry.instance = instance;
   entry.handle = handle;
   entry.size_in_bytes = size_in_bytes;
 
   // Find a free id for our map.
   while (shared_memory_map_.find(last_shared_memory_map_id_) !=
          shared_memory_map_.end()) {
     ++last_shared_memory_map_id_;
   }
   shared_memory_map_[last_shared_memory_map_id_] = entry;
   return last_shared_memory_map_id_;
 }
 
 bool HostVarTracker::StopTrackingSharedMemoryHandle(
     int id,
     PP_Instance instance,
     base::SharedMemoryHandle* handle,
-    uint32* size_in_bytes) {
+    uint32_t* size_in_bytes) {
   SharedMemoryMap::iterator it = shared_memory_map_.find(id);
   if (it == shared_memory_map_.end())
     return false;
   if (it->second.instance != instance)
     return false;
 
   *handle = it->second.handle;
   *size_in_bytes = it->second.size_in_bytes;
   shared_memory_map_.erase(it);
   return true;
 }
 
 }  // namespace content