Convert srpc definitions from using int64 to using PP_Instance, PP_Module, an...

src/shared/ppapi_proxy/plugin_ppp_instance_rpc_server.cc

 // Copyright (c) 2010 The Native Client Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // SRPC-abstraction wrappers around PPB_Instance functions.
 
 #include <string.h>
 
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/portability_process.h"
@@ skipping 56 matching lines @@
   return array;
 }
 
 }  // namespace
 
 
 void PppInstanceRpcServer::PPP_Instance_DidCreate(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance,
+    PP_Instance instance,
     int32_t argc,
     uint32_t argn_bytes, char* argn,
     uint32_t argv_bytes, char* argv,
     // outputs
     int32_t* success) {
   NaClSrpcClosureRunner runner(done);
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   *success = kMethodFailure;
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface == NULL || instance_interface->DidCreate == NULL) {
@@ skipping 13 matching lines @@
                                                          argn_copy.get(),
                                                          argv_copy.get());
   *success = initialize_result ? kMethodSuccess : kMethodFailure;
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void PppInstanceRpcServer::PPP_Instance_DidDestroy(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance) {
+    PP_Instance instance) {
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   NaClSrpcClosureRunner runner(done);
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface == NULL || instance_interface->DidDestroy == NULL) {
     rpc->result = NACL_SRPC_RESULT_OK;
     return;
   }
   instance_interface->DidDestroy(instance);
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void PppInstanceRpcServer::PPP_Instance_DidChangeView(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance,
+    PP_Instance instance,
     uint32_t position_count, int32_t* position,
     uint32_t clip_count, int32_t* clip) {
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   NaClSrpcClosureRunner runner(done);
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface == NULL ||
       instance_interface->DidChangeView == NULL) {
     return;
   }
   if (position_count != 4 || clip_count != 4) {
     return;
   }
   const PP_Rect position_rect =
       PP_MakeRectFromXYWH(position[0], position[1], position[2], position[3]);
   const PP_Rect clip_rect =
       PP_MakeRectFromXYWH(clip[0], clip[1], clip[2], clip[3]);
 
   instance_interface->DidChangeView(instance, &position_rect, &clip_rect);
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void PppInstanceRpcServer::PPP_Instance_DidChangeFocus(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance,
+    PP_Instance instance,
     bool has_focus) {
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   NaClSrpcClosureRunner runner(done);
   // FocusChanged() has a void return, so it always succeeds at this interface
   // level.
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface != NULL &&
       instance_interface->DidChangeFocus != NULL) {
     instance_interface->DidChangeFocus(instance,
         static_cast<PP_Bool>(has_focus));
   }
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void PppInstanceRpcServer::PPP_Instance_HandleInputEvent(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance,
+    PP_Instance instance,
     uint32_t event_data_bytes, char* event_data,
     // outputs
     int32_t* success) {
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   NaClSrpcClosureRunner runner(done);
   *success = kMethodFailure;
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface == NULL ||
       instance_interface->HandleInputEvent == NULL) {
     rpc->result = NACL_SRPC_RESULT_OK;
     return;
   }
   const PP_InputEvent* event =
       reinterpret_cast<const PP_InputEvent*>(event_data);
   bool event_result = instance_interface->HandleInputEvent(instance, event);
   *success = event_result ? kMethodSuccess : kMethodFailure;
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void PppInstanceRpcServer::PPP_Instance_HandleDocumentLoad(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance,
-    int64_t url_loader,
+    PP_Instance instance,
+    PP_Resource url_loader,
     // outputs
     int32_t* success) {
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   NaClSrpcClosureRunner runner(done);
   *success = kMethodFailure;
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface == NULL ||
       instance_interface->HandleDocumentLoad == NULL) {
     return;
   }
   bool handle_result = instance_interface->HandleDocumentLoad(instance,
                                                               url_loader);
   *success = handle_result ? kMethodSuccess : kMethodFailure;
   rpc->result = NACL_SRPC_RESULT_OK;
 }
 
 void PppInstanceRpcServer::PPP_Instance_GetInstanceObject(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     // inputs
-    int64_t instance,
+    PP_Instance instance,
     // outputs
     uint32_t* capability_bytes, char* capability) {
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   NaClSrpcClosureRunner runner(done);
   const PPP_Instance* instance_interface = GetInstanceInterface();
   if (instance_interface == NULL ||
       instance_interface->GetInstanceObject == NULL ||
       *capability_bytes < sizeof(ppapi_proxy::ObjectCapability)) {
     return;
   }
   PP_Var instance_var = instance_interface->GetInstanceObject(instance);
   if (instance_var.type != PP_VARTYPE_OBJECT) {
     return;
   }
   // Create the return capability.
   ppapi_proxy::ObjectCapability cap(GETPID(), instance_var.value.as_id);
   *reinterpret_cast<ppapi_proxy::ObjectCapability*>(capability) = cap;
   *capability_bytes = sizeof(ppapi_proxy::ObjectCapability);
   rpc->result = NACL_SRPC_RESULT_OK;
 }