Switch to standard integer types in ppapi/.

ppapi/proxy/ppp_class_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/ppp_class_proxy.h"
 
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/dev/ppp_class_deprecated.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/proxy/dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/serialized_var.h"
+#include "ppapi/shared_impl/api_id.h"
 #include "ppapi/shared_impl/proxy_lock.h"
-#include "ppapi/shared_impl/api_id.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // PPP_Class in the browser implementation -------------------------------------
 
 // Represents a plugin-implemented class in the browser process. This just
 // stores the data necessary to call back the plugin.
 struct ObjectProxy {
-  ObjectProxy(Dispatcher* d, int64 p, int64 ud)
-      : dispatcher(d),
-        ppp_class(p),
-        user_data(ud) {
-  }
+  ObjectProxy(Dispatcher* d, int64_t p, int64_t ud)
+      : dispatcher(d), ppp_class(p), user_data(ud) {}
 
   Dispatcher* dispatcher;
-  int64 ppp_class;
-  int64 user_data;
+  int64_t ppp_class;
+  int64_t user_data;
 };
 
 ObjectProxy* ToObjectProxy(void* data) {
   ObjectProxy* obj = reinterpret_cast<ObjectProxy*>(data);
   if (!obj || !obj->dispatcher)
     return NULL;
   if (!obj->dispatcher->permissions().HasPermission(PERMISSION_DEV))
     return NULL;
   return obj;
 }
@@ skipping 134 matching lines @@
   &GetAllPropertyNames,
   &SetProperty,
   &RemoveProperty,
   &Call,
   &Construct,
   &Deallocate
 };
 
 // Plugin helper functions -----------------------------------------------------
 
-// Converts an int64 object from IPC to a PPP_Class* for calling into the
+// Converts an int64_t object from IPC to a PPP_Class* for calling into the
 // plugin's implementation.
-const PPP_Class_Deprecated* ToPPPClass(int64 value) {
+const PPP_Class_Deprecated* ToPPPClass(int64_t value) {
   return reinterpret_cast<const PPP_Class_Deprecated*>(
       static_cast<intptr_t>(value));
 }
 
-// Converts an int64 object from IPC to a void* for calling into the plugin's
+// Converts an int64_t object from IPC to a void* for calling into the plugin's
 // implementation as the user data.
-void* ToUserData(int64 value) {
+void* ToUserData(int64_t value) {
   return reinterpret_cast<void*>(static_cast<intptr_t>(value));
 }
 
 }  // namespace
 
 // PPP_Class_Proxy -------------------------------------------------------------
 
 PPP_Class_Proxy::PPP_Class_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher) {
 }
 
 PPP_Class_Proxy::~PPP_Class_Proxy() {
 }
 
 // static
 InterfaceProxy* PPP_Class_Proxy::Create(Dispatcher* dispatcher) {
   return new PPP_Class_Proxy(dispatcher);
 }
 
 // static
 PP_Var PPP_Class_Proxy::CreateProxiedObject(const PPB_Var_Deprecated* var,
                                             Dispatcher* dispatcher,
                                             PP_Instance instance_id,
-                                            int64 ppp_class,
-                                            int64 class_data) {
+                                            int64_t ppp_class,
+                                            int64_t class_data) {
   ObjectProxy* object_proxy = new ObjectProxy(dispatcher,
                                               ppp_class, class_data);
   return var->CreateObject(instance_id, &class_interface, object_proxy);
 }
 
 // static
 PP_Bool PPP_Class_Proxy::IsInstanceOf(const PPB_Var_Deprecated* ppb_var_impl,
                                       const PP_Var& var,
-                                      int64 ppp_class,
-                                      int64* ppp_class_data) {
+                                      int64_t ppp_class,
+                                      int64_t* ppp_class_data) {
   void* proxied_object = NULL;
   if (ppb_var_impl->IsInstanceOf(var,
                                  &class_interface,
                                  &proxied_object)) {
     if (static_cast<ObjectProxy*>(proxied_object)->ppp_class == ppp_class) {
       DCHECK(ppp_class_data);
       *ppp_class_data = static_cast<ObjectProxy*>(proxied_object)->user_data;
       return PP_TRUE;
     }
   }
@@ skipping 20 matching lines @@
                         OnMsgCall)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPClass_Construct,
                         OnMsgConstruct)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPPClass_Deallocate,
                         OnMsgDeallocate)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void PPP_Class_Proxy::OnMsgHasProperty(int64 ppp_class, int64 object,
+void PPP_Class_Proxy::OnMsgHasProperty(int64_t ppp_class,
+                                       int64_t object,
                                        SerializedVarReceiveInput property,
                                        SerializedVarOutParam exception,
                                        bool* result) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   *result = CallWhileUnlocked(ToPPPClass(ppp_class)->HasProperty,
                               ToUserData(object),
                               property.Get(dispatcher()),
                               exception.OutParam(dispatcher()));
 }
 
-void PPP_Class_Proxy::OnMsgHasMethod(int64 ppp_class, int64 object,
+void PPP_Class_Proxy::OnMsgHasMethod(int64_t ppp_class,
+                                     int64_t object,
                                      SerializedVarReceiveInput property,
                                      SerializedVarOutParam exception,
                                      bool* result) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   *result = CallWhileUnlocked(ToPPPClass(ppp_class)->HasMethod,
                               ToUserData(object),
                               property.Get(dispatcher()),
                               exception.OutParam(dispatcher()));
 }
 
-void PPP_Class_Proxy::OnMsgGetProperty(int64 ppp_class, int64 object,
+void PPP_Class_Proxy::OnMsgGetProperty(int64_t ppp_class,
+                                       int64_t object,
                                        SerializedVarReceiveInput property,
                                        SerializedVarOutParam exception,
                                        SerializedVarReturnValue result) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   result.Return(dispatcher(), CallWhileUnlocked(
       ToPPPClass(ppp_class)->GetProperty,
       ToUserData(object), property.Get(dispatcher()),
       exception.OutParam(dispatcher())));
 }
 
 void PPP_Class_Proxy::OnMsgEnumerateProperties(
-    int64 ppp_class, int64 object,
+    int64_t ppp_class,
+    int64_t object,
     std::vector<SerializedVar>* props,
     SerializedVarOutParam exception) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   NOTIMPLEMENTED();
   // TODO(brettw) implement this.
 }
 
-void PPP_Class_Proxy::OnMsgSetProperty(int64 ppp_class, int64 object,
+void PPP_Class_Proxy::OnMsgSetProperty(int64_t ppp_class,
+                                       int64_t object,
                                        SerializedVarReceiveInput property,
                                        SerializedVarReceiveInput value,
                                        SerializedVarOutParam exception) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   CallWhileUnlocked(ToPPPClass(ppp_class)->SetProperty,
       ToUserData(object), property.Get(dispatcher()), value.Get(dispatcher()),
       exception.OutParam(dispatcher()));
 }
 
-void PPP_Class_Proxy::OnMsgRemoveProperty(int64 ppp_class, int64 object,
+void PPP_Class_Proxy::OnMsgRemoveProperty(int64_t ppp_class,
+                                          int64_t object,
                                           SerializedVarReceiveInput property,
                                           SerializedVarOutParam exception) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   CallWhileUnlocked(ToPPPClass(ppp_class)->RemoveProperty,
       ToUserData(object), property.Get(dispatcher()),
       exception.OutParam(dispatcher()));
 }
 
-void PPP_Class_Proxy::OnMsgCall(
-    int64 ppp_class, int64 object,
-    SerializedVarReceiveInput method_name,
-    SerializedVarVectorReceiveInput arg_vector,
-    SerializedVarOutParam exception,
-    SerializedVarReturnValue result) {
+void PPP_Class_Proxy::OnMsgCall(int64_t ppp_class,
+                                int64_t object,
+                                SerializedVarReceiveInput method_name,
+                                SerializedVarVectorReceiveInput arg_vector,
+                                SerializedVarOutParam exception,
+                                SerializedVarReturnValue result) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   uint32_t arg_count = 0;
   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
   result.Return(dispatcher(), CallWhileUnlocked(ToPPPClass(ppp_class)->Call,
       ToUserData(object), method_name.Get(dispatcher()),
       arg_count, args, exception.OutParam(dispatcher())));
 }
 
-void PPP_Class_Proxy::OnMsgConstruct(
-    int64 ppp_class, int64 object,
-    SerializedVarVectorReceiveInput arg_vector,
-    SerializedVarOutParam exception,
-    SerializedVarReturnValue result) {
+void PPP_Class_Proxy::OnMsgConstruct(int64_t ppp_class,
+                                     int64_t object,
+                                     SerializedVarVectorReceiveInput arg_vector,
+                                     SerializedVarOutParam exception,
+                                     SerializedVarReturnValue result) {
   if (!ValidateUserData(ppp_class, object, &exception))
     return;
   uint32_t arg_count = 0;
   PP_Var* args = arg_vector.Get(dispatcher(), &arg_count);
   result.Return(dispatcher(), CallWhileUnlocked(
       ToPPPClass(ppp_class)->Construct,
       ToUserData(object), arg_count, args, exception.OutParam(dispatcher())));
 }
 
-void PPP_Class_Proxy::OnMsgDeallocate(int64 ppp_class, int64 object) {
+void PPP_Class_Proxy::OnMsgDeallocate(int64_t ppp_class, int64_t object) {
   if (!ValidateUserData(ppp_class, object, NULL))
     return;
   PluginGlobals::Get()->plugin_var_tracker()->PluginImplementedObjectDestroyed(
       ToUserData(object));
   CallWhileUnlocked(ToPPPClass(ppp_class)->Deallocate, ToUserData(object));
 }
 
-bool PPP_Class_Proxy::ValidateUserData(int64 ppp_class, int64 class_data,
+bool PPP_Class_Proxy::ValidateUserData(int64_t ppp_class,
+                                       int64_t class_data,
                                        SerializedVarOutParam* exception) {
   if (!PluginGlobals::Get()->plugin_var_tracker()->ValidatePluginObjectCall(
           ToPPPClass(ppp_class), ToUserData(class_data))) {
     // Set the exception. This is so the caller will know about the error and
     // also that we won't assert that somebody forgot to call OutParam on the
     // output parameter. Although this exception of "1" won't be very useful
     // this shouldn't happen in normal usage, only when the renderer is being
     // malicious.
     if (exception)
       *exception->OutParam(dispatcher()) = PP_MakeInt32(1);
     return false;
   }
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi