Switch to standard integer types in ppapi/.

ppapi/proxy/plugin_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 "ppapi/proxy/plugin_var_tracker.h"
 
+#include <stddef.h>
+
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "ipc/ipc_message.h"
 #include "ppapi/c/dev/ppp_class_deprecated.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/proxy/file_system_resource.h"
 #include "ppapi/proxy/media_stream_audio_track_resource.h"
 #include "ppapi/proxy/media_stream_video_track_resource.h"
 #include "ppapi/proxy/plugin_array_buffer_var.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
@@ skipping 13 matching lines @@
 namespace {
 
 Connection GetConnectionForInstance(PP_Instance instance) {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   DCHECK(dispatcher);
   return Connection(PluginGlobals::Get()->GetBrowserSender(), dispatcher);
 }
 
 }  // namespace
 
-PluginVarTracker::HostVar::HostVar(PluginDispatcher* d, int32 i)
-    : dispatcher(d),
-      host_object_id(i) {
-}
+PluginVarTracker::HostVar::HostVar(PluginDispatcher* d, int32_t i)
+    : dispatcher(d), host_object_id(i) {}
 
 bool PluginVarTracker::HostVar::operator<(const HostVar& other) const {
   if (dispatcher < other.dispatcher)
     return true;
   if (other.dispatcher < dispatcher)
     return false;
   return host_object_id < other.host_object_id;
 }
 
 PluginVarTracker::PluginVarTracker() : VarTracker(THREAD_SAFE) {
@@ skipping 98 matching lines @@
   return object->dispatcher();
 }
 
 void PluginVarTracker::ReleaseHostObject(PluginDispatcher* dispatcher,
                                          const PP_Var& host_object) {
   CheckThreadingPreconditions();
   DCHECK(host_object.type == PP_VARTYPE_OBJECT);
 
   // Convert the host object to a normal var valid in the plugin.
   HostVarToPluginVarMap::iterator found = host_var_to_plugin_var_.find(
-      HostVar(dispatcher, static_cast<int32>(host_object.value.as_id)));
+      HostVar(dispatcher, static_cast<int32_t>(host_object.value.as_id)));
   if (found == host_var_to_plugin_var_.end()) {
     NOTREACHED();
     return;
   }
 
   // Now just release the object given the plugin var ID.
   ReleaseVar(found->second);
 }
 
 PP_Var PluginVarTracker::MakeResourcePPVarFromMessage(
@@ skipping 123 matching lines @@
        it != live_vars_.end();
        ++it) {
     if (it->second.var.get() == NULL)
       continue;
     ProxyObjectVar* object = it->second.var->AsProxyObjectVar();
     if (object && object->dispatcher() == dispatcher)
       object->clear_dispatcher();
   }
 }
 
-ArrayBufferVar* PluginVarTracker::CreateArrayBuffer(uint32 size_in_bytes) {
+ArrayBufferVar* PluginVarTracker::CreateArrayBuffer(uint32_t size_in_bytes) {
   return new PluginArrayBufferVar(size_in_bytes);
 }
 
 ArrayBufferVar* PluginVarTracker::CreateShmArrayBuffer(
-    uint32 size_in_bytes,
+    uint32_t size_in_bytes,
     base::SharedMemoryHandle handle) {
   return new PluginArrayBufferVar(size_in_bytes, handle);
 }
 
 void PluginVarTracker::PluginImplementedObjectCreated(
     PP_Instance instance,
     const PP_Var& created_var,
     const PPP_Class_Deprecated* ppp_class,
     void* ppp_class_data) {
   PluginImplementedVar p;
@@ skipping 24 matching lines @@
 bool PluginVarTracker::ValidatePluginObjectCall(
     const PPP_Class_Deprecated* ppp_class,
     void* user_data) {
   UserDataToPluginImplementedVarMap::iterator found =
       user_data_to_plugin_.find(user_data);
   if (found == user_data_to_plugin_.end())
     return false;
   return found->second.ppp_class == ppp_class;
 }
 
-int32 PluginVarTracker::AddVarInternal(Var* var, AddVarRefMode mode) {
+int32_t PluginVarTracker::AddVarInternal(Var* var, AddVarRefMode mode) {
   // Normal adding.
-  int32 new_id = VarTracker::AddVarInternal(var, mode);
+  int32_t new_id = VarTracker::AddVarInternal(var, mode);
 
   // Need to add proxy objects to the host var map.
   ProxyObjectVar* proxy_object = var->AsProxyObjectVar();
   if (proxy_object) {
     HostVar host_var(proxy_object->dispatcher(), proxy_object->host_var_id());
     // TODO(teravest): Change to DCHECK when http://crbug.com/276347 is
     // resolved.
     CHECK(host_var_to_plugin_var_.find(host_var) ==
           host_var_to_plugin_var_.end());  // Adding an object twice, use
                                            // FindOrMakePluginVarFromHostVar.
@@ skipping 67 matching lines @@
   // Clean up the host var mapping.
   DCHECK(host_var_to_plugin_var_.find(host_var) !=
          host_var_to_plugin_var_.end());
   host_var_to_plugin_var_.erase(host_var);
   return true;
 }
 
 PP_Var PluginVarTracker::GetOrCreateObjectVarID(ProxyObjectVar* object) {
   // We can't use object->GetPPVar() because we don't want to affect the
   // refcount, so we have to add everything manually here.
-  int32 var_id = object->GetExistingVarID();
+  int32_t var_id = object->GetExistingVarID();
   if (!var_id) {
     var_id = AddVarInternal(object, ADD_VAR_CREATE_WITH_NO_REFERENCE);
     object->AssignVarID(var_id);
   }
 
   PP_Var ret = { PP_VARTYPE_OBJECT };
   ret.value.as_id = var_id;
   return ret;
 }
 
@@ skipping 17 matching lines @@
     const PP_Var& var,
     PluginDispatcher* dispatcher) {
   DCHECK(var.type == PP_VARTYPE_OBJECT);
   HostVar host_var(dispatcher, var.value.as_id);
 
   HostVarToPluginVarMap::iterator found =
       host_var_to_plugin_var_.find(host_var);
   if (found == host_var_to_plugin_var_.end()) {
     // Create a new object.
     return scoped_refptr<ProxyObjectVar>(
-        new ProxyObjectVar(dispatcher, static_cast<int32>(var.value.as_id)));
+        new ProxyObjectVar(dispatcher, static_cast<int32_t>(var.value.as_id)));
   }
 
   // Have this host var, look up the object.
   VarMap::iterator ret = live_vars_.find(found->second);
 
   // We CHECK here because we currently don't fall back sanely.
   // This may be involved in a NULL dereference. http://crbug.com/276347
   CHECK(ret != live_vars_.end());
 
   // All objects should be proxy objects.
   DCHECK(ret->second.var->AsProxyObjectVar());
   return scoped_refptr<ProxyObjectVar>(ret->second.var->AsProxyObjectVar());
 }
 
 int PluginVarTracker::TrackSharedMemoryHandle(PP_Instance instance,
                                               base::SharedMemoryHandle handle,
-                                              uint32 size_in_bytes) {
+                                              uint32_t size_in_bytes) {
   NOTREACHED();
   return -1;
 }
 
 bool PluginVarTracker::StopTrackingSharedMemoryHandle(
     int id,
     PP_Instance instance,
     base::SharedMemoryHandle* handle,
-    uint32* size_in_bytes) {
+    uint32_t* size_in_bytes) {
   NOTREACHED();
   return false;
 }
 
 }  // namesace proxy
 }  // namespace ppapi