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

src/shared/ppapi_proxy/plugin_audio.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.
 
 #include "native_client/src/shared/ppapi_proxy/plugin_audio.h"
 
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/errno.h>
@@ skipping 204 matching lines @@
 // Start of untrusted PPB_Audio functions
 
 PP_Resource Create(PP_Instance instance,
                    PP_Resource config,
                    PPB_Audio_Callback user_callback,
                    void* user_data) {
   PP_Resource audioResource;
   NaClSrpcError retval = NACL_SRPC_RESULT_OK;
   NaClSrpcChannel* channel = NULL;
   AudioProxy* audio = NULL;
-  int64_t audioResource64 = 0;
-  int64_t instance64 = static_cast<int64_t>(instance);
-  int64_t config64 = static_cast<int64_t>(config);
   // TODO(audio): remove check below when & if we support
   // multiple simultanious audio devices from same untrusted instance
   if (NULL != GetCurrentAudio()) {
     return kInvalidResourceId;
   }
   // Proxy to browser Create, get audio PP_Resource
   channel = ppapi_proxy::GetMainSrpcChannel();
   retval = PpbAudioDevRpcClient::PPB_Audio_Dev_Create(
       channel,
-      instance64,
-      config64,
-      &audioResource64);
-  audioResource = static_cast<PP_Resource>(audioResource64);
+      instance,
+      config,
+      &audioResource);
   if (NACL_SRPC_RESULT_OK != retval) {
     return kInvalidResourceId;
   }
   if (kInvalidResourceId == audioResource) {
     return kInvalidResourceId;
   }
   // Create an AudioProxy
   audio = new AudioProxy(audioResource, user_callback, user_data);
   if (NULL == audio) {
     return kInvalidResourceId;
@@ skipping 16 matching lines @@
           resource,
           &out_bool);
   if (NACL_SRPC_RESULT_OK != retval) {
     return PP_FALSE;
   }
   return pp::BoolToPPBool(out_bool);
 }
 
 PP_Resource GetCurrentConfig(PP_Resource audio) {
   NaClSrpcChannel* channel = ppapi_proxy::GetMainSrpcChannel();
-  int64_t out_resource;
+  PP_Resource out_resource;
   NaClSrpcError retval =
       PpbAudioDevRpcClient::PPB_Audio_Dev_GetCurrentConfig(
           channel,
           audio,
           &out_resource);
   if (NACL_SRPC_RESULT_OK != retval) {
     return kInvalidResourceId;
   }
-  return static_cast<PP_Resource>(out_resource);
+  return out_resource;
 }
 
 PP_Bool StartPlayback(PP_Resource audioResource) {
   NaClSrpcChannel* channel = ppapi_proxy::GetMainSrpcChannel();
   int32_t out_bool;
   AudioProxy* audio = GetBoundAudio(audioResource);
   if (NULL == audio) {
     return PP_FALSE;
   }
   if (audio->state() == AUDIO_INCOMPLETE) {
@@ skipping 59 matching lines @@
 }
 
 }  // namespace ppapi_proxy
 
 // PppAudioDevRpcServer::PPP_Audio_Dev_StreamCreated() must be in global
 // namespace.  This function receives handles for the socket and shared
 // memory, provided by the trusted audio implementation.
 void PppAudioDevRpcServer::PPP_Audio_Dev_StreamCreated(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
-    int64_t audioResource64,
+    PP_Resource audioResource,
     NaClSrpcImcDescType shm,
     int32_t shm_size,
     NaClSrpcImcDescType sync_socket) {
   NaClSrpcClosureRunner runner(done);
-  PP_Resource audioResource = static_cast<PP_Resource>(audioResource64);
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   ppapi_proxy::AudioProxy* audio = ppapi_proxy::GetBoundAudio(audioResource);
   if (NULL == audio) {
     // Ignore if no audioResource -> audioInstance mapping exists,
     // the app may have shutdown audio before StreamCreated() invoked.
     rpc->result = NACL_SRPC_RESULT_OK;
     return;
   }
   audio->StreamCreated(sync_socket, shm, shm_size);
   rpc->result = NACL_SRPC_RESULT_OK;
 }