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

src/shared/ppapi_proxy/plugin_image_data.cc

 /*
  * Copyright 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_image_data.h"
 
 #include <stdio.h>
 #include <string.h>
@@ skipping 35 matching lines @@
     return (result ? PP_TRUE : PP_FALSE);
   } else {
     return PP_FALSE;
   }
 }
 
 PP_Resource Create(PP_Module module,
                    PP_ImageDataFormat format,
                    const struct PP_Size* size,
                    PP_Bool init_to_zero) {
-  int64_t resource;
+  PP_Resource resource;
   NaClSrpcError retval =
       PpbImageDataRpcClient::PPB_ImageData_Create(
           GetMainSrpcChannel(),
-          static_cast<int64_t>(module),
+          module,
           static_cast<int32_t>(format),
           static_cast<nacl_abi_size_t>(sizeof(struct PP_Size)),
           reinterpret_cast<int32_t*>(const_cast<struct PP_Size*>(size)),
           (init_to_zero == PP_TRUE),
           &resource);
   if (retval == NACL_SRPC_RESULT_OK) {

[polina, 2010/12/23 21:58:30]

we can get rid of this if-else now if we set resource to kInvalidResourceId at
initialization, can't we?

[noelallen_use_chromium, 2010/12/23 22:23:23]

I'm not convinced we can count on the function not to change 'resource' on
error.  What if the resource is allocated, but failes to initialize?  What if
the function write is counting on the user to check for an error?

On 2010/12/23 21:58:30, polina wrote:

[polina, 2010/12/23 22:33:14]

We implement the server code, so we know exactly how this works. When it comes
to returning a resource, it is an actual return value (not output arg) from a
Chrome function. The server functions that call them always return OK.

That said, I am ok with keeping this "better-safe-than-sorry" code. But I would
suggest dropping the "else" and {}.

-    return static_cast<PP_Resource>(resource);
+    return resource;
   } else {
     return kInvalidResourceId;
   }
 }
 
 PP_Bool IsImageData(PP_Resource resource) {
   return PluginResource::GetAs<PluginImageData>(resource).get()
       ? PP_TRUE : PP_FALSE;
 }
 
 PP_Bool Describe(PP_Resource resource,
                  struct PP_ImageDataDesc* desc) {
   int32_t result;
   nacl_abi_size_t desc_size = kPpImageDataDescBytes;
   NaClSrpcError retval =
       PpbImageDataRpcClient::PPB_ImageData_Describe(
           GetMainSrpcChannel(),
-          static_cast<int64_t>(resource),
+          resource,
           &desc_size,
           reinterpret_cast<int32_t*>(desc),
           &result);
   if (retval == NACL_SRPC_RESULT_OK) {
     return (result ? PP_TRUE : PP_FALSE);
   } else {
     return PP_FALSE;
   }
 }
 
@@ skipping 21 matching lines @@
     Create,
     IsImageData,
     Describe,
     Map,
     Unmap,
   };
   return &intf;
 }
 
 }  // namespace ppapi_proxy