Change trusted shared memory interface to match audio....

ppapi/proxy/ppb_image_data_proxy.cc

 // Copyright (c) 2010 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 "ppapi/proxy/ppb_image_data_proxy.h"
 
 #include <string.h>  // For memcpy
 
 #include <vector>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_image_data.h"
 #include "ppapi/c/trusted/ppb_image_data_trusted.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
 
 #if defined(OS_LINUX)
 #include <sys/shm.h>
 #endif
 
 namespace pp {
 namespace proxy {
 
 class ImageData : public PluginResource {
  public:
-  ImageData(const PP_ImageDataDesc& desc, uint64_t memory_handle);
+  ImageData(const PP_ImageDataDesc& desc, int memory_handle);
   virtual ~ImageData();
 
   // Resource overrides.
   virtual ImageData* AsImageData() { return this; }
 
   void* Map();
   void Unmap();
 
   const PP_ImageDataDesc& desc() const { return desc_; }
 
  private:
   PP_ImageDataDesc desc_;
-  uint64_t memory_handle_;
+  int memory_handle_;
 
   void* mapped_data_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageData);
 };
 
 ImageData::ImageData(const PP_ImageDataDesc& desc,
-                     uint64_t memory_handle)
+                     int memory_handle)
     : desc_(desc),
       memory_handle_(memory_handle),
       mapped_data_(NULL) {
 }
 
 ImageData::~ImageData() {
   Unmap();
 }
 
 void* ImageData::Map() {
 #if defined(OS_LINUX)
   // On linux, the memory handle is a SysV shared memory segment.
-  int shmkey = static_cast<int>(memory_handle_);
+  int shmkey = memory_handle_;
   void* address = shmat(shmkey, NULL, 0);
   // Mark for deletion in case we crash so the kernel will clean it up.
   shmctl(shmkey, IPC_RMID, 0);
   if (address == (void*)-1)
     return NULL;
   mapped_data_ = address;
   return address;
 #else
   NOTIMPLEMENTED();
   return NULL;
@@ skipping 28 matching lines @@
           &supported));
   return supported;
 }
 
 PP_Resource Create(PP_Module module_id,
                    PP_ImageDataFormat format,
                    const PP_Size* size,
                    PP_Bool init_to_zero) {
   PP_Resource result = 0;
   std::string image_data_desc;
-  uint64_t shm_handle = -1;
+  int shm_handle = -1;
   PluginDispatcher::Get()->Send(
       new PpapiHostMsg_PPBImageData_Create(
           INTERFACE_ID_PPB_IMAGE_DATA, module_id, format, *size, init_to_zero,
           &result, &image_data_desc, &shm_handle));
 
   if (result && image_data_desc.size() == sizeof(PP_ImageDataDesc)) {
     // We serialize the PP_ImageDataDesc just by copying to a string.
     PP_ImageDataDesc desc;
     memcpy(&desc, image_data_desc.data(), sizeof(PP_ImageDataDesc));
 
@@ skipping 79 matching lines @@
   *result = ppb_image_data_target()->IsImageDataFormatSupported(
       static_cast<PP_ImageDataFormat>(format));
 }
 
 void PPB_ImageData_Proxy::OnMsgCreate(PP_Module module,
                                       int32_t format,
                                       const PP_Size& size,
                                       PP_Bool init_to_zero,
                                       PP_Resource* result,
                                       std::string* image_data_desc,
-                                      uint64_t* result_shm_handle) {
+                                      int* result_shm_handle) {
   *result = ppb_image_data_target()->Create(
       module, static_cast<PP_ImageDataFormat>(format), &size, init_to_zero);
   *result_shm_handle = 0;
   if (*result) {
     // The ImageDesc is just serialized as a string.
     PP_ImageDataDesc desc;
     if (ppb_image_data_target()->Describe(*result, &desc)) {
       image_data_desc->resize(sizeof(PP_ImageDataDesc));
       memcpy(&(*image_data_desc)[0], &desc, sizeof(PP_ImageDataDesc));
     }
 
     // Get the shared memory handle.
     const PPB_ImageDataTrusted* trusted =
         reinterpret_cast<const PPB_ImageDataTrusted*>(
             dispatcher()->GetLocalInterface(PPB_IMAGEDATA_TRUSTED_INTERFACE));
     uint32_t byte_count = 0;
-    if (trusted)
-      *result_shm_handle = trusted->GetNativeMemoryHandle(*result, &byte_count);
+    if (trusted) {
+      int32_t handle;
+      if (trusted->GetSharedMemory(*result, &handle, &byte_count) == PP_OK)
+        *result_shm_handle = static_cast<int>(handle);
+    }
   }
 }
 
 }  // namespace proxy
 }  // namespace pp