Pepper SRPC proxy style and type nits

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_audio.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "native_client/src/shared/ppapi_proxy/plugin_ppb_audio.h"
 
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/errno.h>
 #include <sys/mman.h>
@@ skipping 49 matching lines @@
     close(shm_);
     shm_ = -1;
   }
   if (socket_ != -1) {
     close(socket_);
     socket_ = -1;
   }
 }
 
 bool PluginAudio::InitFromBrowserResource(PP_Resource resource) {
-  DebugPrintf("PluginAudio::InitFromBrowserResource: resource=%"NACL_PRIu32"\n",
+  DebugPrintf("PluginAudio::InitFromBrowserResource: resource=%"NACL_PRId32"\n",
               resource);
   resource_ = resource;
   return true;
 }
 
 void PluginAudio::AudioThread(void* self) {
   PluginAudio* audio = static_cast<PluginAudio*>(self);
   DebugPrintf("PluginAudio::AudioThread: self=%p\n", self);
   while (true) {
     int32_t sync_value;
@@ skipping 64 matching lines @@
   return false;
 }
 
 // Start of untrusted PPB_Audio functions
 namespace {
 
 PP_Resource Create(PP_Instance instance,
                    PP_Resource config,
                    PPB_Audio_Callback user_callback,
                    void* user_data) {
-  DebugPrintf("PPB_Audio::Create: instance=%"NACL_PRIu32" config=%"NACL_PRIu32
+  DebugPrintf("PPB_Audio::Create: instance=%"NACL_PRId32" config=%"NACL_PRId32
               " user_callback=%p user_data=%p\n",
               instance, config, user_callback, user_data);
   PP_Resource audio_resource;
   // Proxy to browser Create, get audio PP_Resource
   NaClSrpcError srpc_result = PpbAudioRpcClient::PPB_Audio_Create(
       GetMainSrpcChannel(),
       instance,
       config,
       &audio_resource);
   DebugPrintf("PPB_Audio::Create: %s\n", NaClSrpcErrorString(srpc_result));
   if (NACL_SRPC_RESULT_OK != srpc_result) {
     return kInvalidResourceId;
   }
   if (kInvalidResourceId == audio_resource) {
     return kInvalidResourceId;
   }
   scoped_refptr<PluginAudio> audio =
       PluginResource::AdoptAs<PluginAudio>(audio_resource);
   if (audio.get()) {
     audio->set_callback(user_callback, user_data);
     return audio_resource;
   }
   return kInvalidResourceId;
 }
 
 PP_Bool IsAudio(PP_Resource resource) {
   int32_t success;
-  DebugPrintf("PPB_Audio::IsAudio: resource=%"NACL_PRIu32"\n", resource);
+  DebugPrintf("PPB_Audio::IsAudio: resource=%"NACL_PRId32"\n", resource);
   NaClSrpcError srpc_result =
       PpbAudioRpcClient::PPB_Audio_IsAudio(
           GetMainSrpcChannel(),
           resource,
           &success);
   DebugPrintf("PPB_Audio::IsAudio: %s\n", NaClSrpcErrorString(srpc_result));
   if (NACL_SRPC_RESULT_OK != srpc_result) {
     return PP_FALSE;
   }
   return PP_FromBool(success);
 }
 
 PP_Resource GetCurrentConfig(PP_Resource audio) {
-  DebugPrintf("PPB_Audio::GetCurrentConfig: audio=%"NACL_PRIu32"\n", audio);
+  DebugPrintf("PPB_Audio::GetCurrentConfig: audio=%"NACL_PRId32"\n", audio);
   PP_Resource config_resource;
   NaClSrpcError srpc_result =
       PpbAudioRpcClient::PPB_Audio_GetCurrentConfig(
           GetMainSrpcChannel(),
           audio,
           &config_resource);
   DebugPrintf("PPB_Audio::GetCurrentConfig: %s\n",
               NaClSrpcErrorString(srpc_result));
   if (NACL_SRPC_RESULT_OK != srpc_result) {
     return kInvalidResourceId;
   }
   return config_resource;
 }
 
 PP_Bool StartPlayback(PP_Resource audio_resource) {
-  DebugPrintf("PPB_Audio::StartPlayback: audio_resource=%"NACL_PRIu32"\n",
+  DebugPrintf("PPB_Audio::StartPlayback: audio_resource=%"NACL_PRId32"\n",
               audio_resource);
   scoped_refptr<PluginAudio> audio =
       PluginResource::GetAs<PluginAudio>(audio_resource);
   if (NULL == audio.get()) {
     return PP_FALSE;
   }
   if (audio->state() == AUDIO_INCOMPLETE) {
     audio->set_state(AUDIO_PENDING);
   }
   if (audio->state() == AUDIO_READY) {
     if (!audio->StartAudioThread()) {
       return PP_FALSE;
     }
   }
   int32_t success;
   NaClSrpcError srpc_result =
       PpbAudioRpcClient::PPB_Audio_StartPlayback(
           GetMainSrpcChannel(),
           audio_resource,
           &success);
   DebugPrintf("PPB_Audio::StartPlayback: %s\n",
               NaClSrpcErrorString(srpc_result));
   if (NACL_SRPC_RESULT_OK != srpc_result || !success) {
     return PP_FALSE;
   }
   return PP_TRUE;
 }
 
 PP_Bool StopPlayback(PP_Resource audio_resource) {
-  DebugPrintf("PPB_Audio::StopPlayback: audio_resource=%"NACL_PRIu32"\n",
+  DebugPrintf("PPB_Audio::StopPlayback: audio_resource=%"NACL_PRId32"\n",
               audio_resource);
   scoped_refptr<PluginAudio> audio =
       PluginResource::GetAs<PluginAudio>(audio_resource);
   if (NULL == audio.get()) {
     return PP_FALSE;
   }
   if (audio->state() == AUDIO_PENDING) {
     // audio is pending to start, but StreamCreated() hasn't occurred yet...
     audio->set_state(AUDIO_INCOMPLETE);
   }
@@ skipping 37 matching lines @@
 // memory, provided by the trusted audio implementation.
 void PppAudioRpcServer::PPP_Audio_StreamCreated(
     NaClSrpcRpc* rpc,
     NaClSrpcClosure* done,
     PP_Resource audio_resource,
     NaClSrpcImcDescType shm,
     int32_t shm_size,
     NaClSrpcImcDescType sync_socket) {
   NaClSrpcClosureRunner runner(done);
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
-  DebugPrintf("PPP_Audio::StreamCreated: audio_resource=%"NACL_PRIu32
+  DebugPrintf("PPP_Audio::StreamCreated: audio_resource=%"NACL_PRId32
               " shm=%"NACL_PRIx32" shm_size=%"NACL_PRIuS
               " sync_socket=%"NACL_PRIx32"\n",
               audio_resource, shm, shm_size, sync_socket);
   scoped_refptr<ppapi_proxy::PluginAudio> audio =
       ppapi_proxy::PluginResource::
       GetAs<ppapi_proxy::PluginAudio>(audio_resource);
   if (NULL == audio.get()) {
     // Ignore if no audio_resource -> audio_instance 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;
 }