Switch to standard integer types in ppapi/.

ppapi/proxy/ppb_var_deprecated_proxy.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/ppb_var_deprecated_proxy.h"
 
 #include <stdlib.h>  // For malloc
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 220 matching lines @@
 
 bool IsInstanceOf(PP_Var var,
                   const PPP_Class_Deprecated* ppp_class,
                   void** ppp_class_data) {
   ProxyAutoLock lock;
   Dispatcher* dispatcher = CheckExceptionAndGetDispatcher(var, NULL);
   if (!dispatcher)
     return false;
 
   PP_Bool result = PP_FALSE;
-  int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
-  int64 class_data_int = 0;
+  int64_t class_int =
+      static_cast<int64_t>(reinterpret_cast<intptr_t>(ppp_class));
+  int64_t class_data_int = 0;
   dispatcher->Send(new PpapiHostMsg_PPBVar_IsInstanceOfDeprecated(
       API_ID_PPB_VAR_DEPRECATED, SerializedVarSendInput(dispatcher, var),
       class_int, &class_data_int, &result));
   *ppp_class_data =
       reinterpret_cast<void*>(static_cast<intptr_t>(class_data_int));
   return PP_ToBool(result);
 }
 
 PP_Var CreateObject(PP_Instance instance,
                     const PPP_Class_Deprecated* ppp_class,
                     void* ppp_class_data) {
   ProxyAutoLock lock;
   Dispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return PP_MakeUndefined();
 
   PluginVarTracker* tracker = PluginGlobals::Get()->plugin_var_tracker();
   if (tracker->IsPluginImplementedObjectAlive(ppp_class_data))
     return PP_MakeUndefined();  // Object already exists with this user data.
 
   ReceiveSerializedVarReturnValue result;
-  int64 class_int = static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class));
-  int64 data_int =
-      static_cast<int64>(reinterpret_cast<intptr_t>(ppp_class_data));
+  int64_t class_int =
+      static_cast<int64_t>(reinterpret_cast<intptr_t>(ppp_class));
+  int64_t data_int =
+      static_cast<int64_t>(reinterpret_cast<intptr_t>(ppp_class_data));
   dispatcher->Send(new PpapiHostMsg_PPBVar_CreateObjectDeprecated(
       API_ID_PPB_VAR_DEPRECATED, instance, class_int, data_int,
       &result));
   PP_Var ret_var = result.Return(dispatcher);
 
   // Register this object as being implemented by the plugin.
   if (ret_var.type == PP_VARTYPE_OBJECT) {
     tracker->PluginImplementedObjectCreated(instance, ret_var,
                                             ppp_class, ppp_class_data);
   }
@@ skipping 71 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_IsInstanceOfDeprecated,
                         OnMsgIsInstanceOfDeprecated)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBVar_CreateObjectDeprecated,
                         OnMsgCreateObjectDeprecated)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   // TODO(brettw) handle bad messages!
   return handled;
 }
 
-void PPB_Var_Deprecated_Proxy::OnMsgAddRefObject(int64 object_id) {
+void PPB_Var_Deprecated_Proxy::OnMsgAddRefObject(int64_t object_id) {
   PP_Var var = { PP_VARTYPE_OBJECT };
   var.value.as_id = object_id;
   ppb_var_impl_->AddRef(var);
 }
 
-void PPB_Var_Deprecated_Proxy::OnMsgReleaseObject(int64 object_id) {
+void PPB_Var_Deprecated_Proxy::OnMsgReleaseObject(int64_t object_id) {
   // Ok, so this is super subtle.
   // When the browser side sends a sync IPC message that returns a var, and the
   // plugin wants to give ownership of that var to the browser, dropping all
   // references, it may call ReleaseObject right after returning the result.
   // However, the IPC system doesn't enforce strict ordering of messages in that
   // case, where a message that is set to unblock (e.g. a sync message, or in
   // our case all messages coming from the plugin) that is sent *after* the
   // result may be dispatched on the browser side *before* the sync send
   // returned (see ipc_sync_channel.cc). In this case, that means it could
   // release the object before it is AddRef'ed on the browser side.
@@ skipping 107 matching lines @@
   SetAllowPluginReentrancy();
   uint32_t arg_count = 0;
   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
   result.Return(dispatcher(), ppb_var_impl_->Construct(
       var.Get(dispatcher()), arg_count, args,
       exception.OutParam(dispatcher())));
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgIsInstanceOfDeprecated(
     SerializedVarReceiveInput var,
-    int64 ppp_class,
-    int64* ppp_class_data,
+    int64_t ppp_class,
+    int64_t* ppp_class_data,
     PP_Bool* result) {
   SetAllowPluginReentrancy();
   *result = PPP_Class_Proxy::IsInstanceOf(ppb_var_impl_,
                                           var.Get(dispatcher()),
                                           ppp_class,
                                           ppp_class_data);
 }
 
 void PPB_Var_Deprecated_Proxy::OnMsgCreateObjectDeprecated(
     PP_Instance instance,
-    int64 ppp_class,
-    int64 class_data,
+    int64_t ppp_class,
+    int64_t class_data,
     SerializedVarReturnValue result) {
   SetAllowPluginReentrancy();
   result.Return(dispatcher(), PPP_Class_Proxy::CreateProxiedObject(
       ppb_var_impl_, dispatcher(), instance, ppp_class, class_data));
 }
 
 void PPB_Var_Deprecated_Proxy::SetAllowPluginReentrancy() {
   if (dispatcher()->IsPlugin())
     NOTREACHED();
   else
     static_cast<HostDispatcher*>(dispatcher())->set_allow_plugin_reentrancy();
 }
 
-void PPB_Var_Deprecated_Proxy::DoReleaseObject(int64 object_id) {
+void PPB_Var_Deprecated_Proxy::DoReleaseObject(int64_t object_id) {
   PP_Var var = { PP_VARTYPE_OBJECT };
   var.value.as_id = object_id;
   ppb_var_impl_->Release(var);
 }
 
 }  // namespace proxy
 }  // namespace ppapi