Pepper SRPC proxy style and type nits

ppapi/native_client/src/shared/ppapi_proxy/plugin_ppb_graphics_3d.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_graphics_3d.h"
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "native_client/src/shared/ppapi_proxy/command_buffer_nacl.h"
 #include "native_client/src/shared/ppapi_proxy/object_serialize.h"
 #include "native_client/src/shared/ppapi_proxy/plugin_callback.h"
@@ skipping 23 matching lines @@
       num += 2;
     // Add one more for PP_GRAPHICS3DATTRIB_NONE.
     num += 1;
   }
   return num;
 }
 
 int32_t GetAttribMaxValue(PP_Instance instance,
                           int32_t attrib,
                           int32_t* attrib_value) {
-  DebugPrintf("PPB_Graphics3D::GetAttribMaxValue: instance=%"NACL_PRIu32"\n",
+  DebugPrintf("PPB_Graphics3D::GetAttribMaxValue: instance=%"NACL_PRId32"\n",
               instance);
   int32_t pp_error;
   NaClSrpcError retval =
       PpbGraphics3DRpcClient::PPB_Graphics3D_GetAttribMaxValue(
           GetMainSrpcChannel(),
           instance,
           attrib,
           attrib_value,
           &pp_error);
   if (retval != NACL_SRPC_RESULT_OK) {
     return PP_ERROR_BADARGUMENT;
   }
   return pp_error;
 }
 
 PP_Resource Create(PP_Instance instance,
                    PP_Resource share_context,
                    const int32_t* attrib_list) {
-  DebugPrintf("PPB_Graphics3D::Create: instance=%"NACL_PRIu32"\n", instance);
+  DebugPrintf("PPB_Graphics3D::Create: instance=%"NACL_PRId32"\n", instance);
   PP_Resource graphics3d_id = kInvalidResourceId;
   nacl_abi_size_t num_attribs = GetNumAttribs(attrib_list);
   NaClSrpcError retval =
       PpbGraphics3DRpcClient::PPB_Graphics3DTrusted_CreateRaw(
           GetMainSrpcChannel(),
           instance,
           share_context,
           num_attribs, const_cast<int32_t *>(attrib_list),
           &graphics3d_id);
   if (retval == NACL_SRPC_RESULT_OK) {
     scoped_refptr<PluginGraphics3D> graphics_3d =
         PluginResource::AdoptAs<PluginGraphics3D>(graphics3d_id);
     if (graphics_3d.get()) {
       graphics_3d->set_instance_id(instance);
       return graphics3d_id;
     }
   }
   return kInvalidResourceId;
 }
 
 PP_Bool IsGraphics3D(PP_Resource resource) {
-  DebugPrintf("PPB_Graphics3D::IsGraphics3D: resource=%"NACL_PRIu32"\n",
+  DebugPrintf("PPB_Graphics3D::IsGraphics3D: resource=%"NACL_PRId32"\n",
               resource);
-  return PluginResource::GetAs<PluginGraphics3D>(resource).get()
-      ? PP_TRUE : PP_FALSE;
+  return PP_FromBool(PluginResource::GetAs<PluginGraphics3D>(resource).get());
 }
 
 int32_t GetAttribs(PP_Resource graphics3d_id,
                    int32_t* attrib_list) {
   int32_t pp_error;
   nacl_abi_size_t num_attribs = GetNumAttribs(attrib_list);
   NaClSrpcError retval =
       PpbGraphics3DRpcClient::PPB_Graphics3D_GetAttribs(
           GetMainSrpcChannel(),
           graphics3d_id,
@@ skipping 16 matching lines @@
           graphics3d_id,
           num_attribs, attrib_list,
           &pp_error);
   if (retval != NACL_SRPC_RESULT_OK) {
     return PP_ERROR_BADARGUMENT;
   }
   return pp_error;
 }
 
 int32_t GetError(PP_Resource graphics3d_id) {
-  DebugPrintf("PPB_Graphics3D::GetError: graphics3d_id=%"NACL_PRIu32"\n",
+  DebugPrintf("PPB_Graphics3D::GetError: graphics3d_id=%"NACL_PRId32"\n",
               graphics3d_id);
   int32_t pp_error;
   NaClSrpcError retval =
       PpbGraphics3DRpcClient::PPB_Graphics3D_GetError(
           GetMainSrpcChannel(),
           graphics3d_id,
           &pp_error);
   if (retval != NACL_SRPC_RESULT_OK) {
     DebugPrintf("PPB_Graphics3D::GetError: retval != NACL_SRPC_RESULT_OK\n");
     return PP_ERROR_BADARGUMENT;
   }
-  DebugPrintf("PPB_Graphics3D::GetError: pp_error=%"NACL_PRIu32"\n", pp_error);
+  DebugPrintf("PPB_Graphics3D::GetError: pp_error=%"NACL_PRId32"\n", pp_error);
   return pp_error;
 }
 
 int32_t ResizeBuffers(PP_Resource graphics3d_id,
                       int32_t width,
                       int32_t height) {
   if ((width < 0) || (height < 0))
     return PP_ERROR_BADARGUMENT;
   gpu::gles2::GLES2Implementation* impl =
       PluginGraphics3D::implFromResource(graphics3d_id);
   if (impl == NULL)
     return PP_ERROR_BADRESOURCE;
   impl->ResizeCHROMIUM(width, height);
   return PP_OK;
 }
 
 int32_t SwapBuffs(PP_Resource graphics3d_id,
                   struct PP_CompletionCallback callback) {
-  DebugPrintf("PPB_Graphics3D::SwapBuffers: graphics3d_id=%"NACL_PRIu32"\n",
+  DebugPrintf("PPB_Graphics3D::SwapBuffers: graphics3d_id=%"NACL_PRId32"\n",
               graphics3d_id);
 
   scoped_refptr<PluginGraphics3D> graphics3d =
       PluginResource::GetAs<PluginGraphics3D>(graphics3d_id).get();
   if (!graphics3d.get())
     return MayForceCallback(callback, PP_ERROR_BADRESOURCE);
 
   return MayForceCallback(callback,
       graphics3d->SwapBuffers(graphics3d_id, callback));
 }
@@ skipping 17 matching lines @@
   command_buffer_.reset();
   // Invalidate the cache.
   cached_graphics3d_id = 0;
   cached_implementation = NULL;
 }
 
 // static
 gpu::gles2::GLES2Implementation* PluginGraphics3D::implFromResourceSlow(
     PP_Resource graphics3d_id) {
   DebugPrintf("PluginGraphics3D::implFromResourceSlow: "
-              "resource=%"NACL_PRIu32"\n", graphics3d_id);
+              "resource=%"NACL_PRId32"\n", graphics3d_id);
 
   // For performance reasons, we don't error-check the context, but crash on
   // NULL instead.
   gpu::gles2::GLES2Implementation* impl =
       PluginResource::GetAs<PluginGraphics3D>(graphics3d_id)->impl();
   cached_graphics3d_id = graphics3d_id;
   cached_implementation = impl;
   return impl;
 }
 
 
 bool PluginGraphics3D::InitFromBrowserResource(PP_Resource res) {
   DebugPrintf("PluginGraphics3D::InitFromBrowserResource: "
-              "resource=%"NACL_PRIu32"\n", res);
+              "resource=%"NACL_PRId32"\n", res);
 
   // Create and initialize the objects required to issue GLES2 calls.
   command_buffer_.reset(new CommandBufferNacl(res, PluginCore::GetInterface()));
   if (command_buffer_->Initialize()) {
     gles2_helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
     if (gles2_helper_->Initialize(kRingBufferSize)) {
       // Request id -1 to signify 'don't care'
       int32 transfer_buffer_id =
           command_buffer_->CreateTransferBuffer(kTransferBufferSize, -1);
       gpu::Buffer transfer_buffer =
@@ skipping 46 matching lines @@
     &GetAttribs,
     &SetAttribs,
     &GetError,
     &ResizeBuffers,
     &SwapBuffs,
   };
   return &intf;
 }
 
 }  // namespace ppapi_proxy
-