Update pepper to not assume that SharedMemoryHandle is an int.

ppapi/proxy/ppb_image_data_proxy.cc

 // 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 "ppapi/proxy/ppb_image_data_proxy.h"
 
 #include <string.h>  // For memcpy
 
 #include <map>
 #include <vector>
@@ skipping 329 matching lines @@
 
 void ImageData::InstanceWasDeleted() {
   ImageDataCache::GetInstance()->DidDeleteInstance(pp_instance());
 }
 
 PP_Bool ImageData::Describe(PP_ImageDataDesc* desc) {
   memcpy(desc, &desc_, sizeof(PP_ImageDataDesc));
   return PP_TRUE;
 }
 
-int32_t ImageData::GetSharedMemory(int* /* handle */,
+int32_t ImageData::GetSharedMemory(base::SharedMemoryHandle* /* handle */,
                                    uint32_t* /* byte_count */) {
   // Not supported in the proxy (this method is for actually implementing the
   // proxy in the host).
   return PP_ERROR_NOACCESS;
 }
 
 void ImageData::SetIsCandidateForReuse() {
   is_candidate_for_reuse_ = true;
 }
 
@@ skipping 187 matching lines @@
 
 #if !defined(OS_NACL)
 // static
 PP_Resource PPB_ImageData_Proxy::CreateImageData(
     PP_Instance instance,
     PPB_ImageData_Shared::ImageDataType type,
     PP_ImageDataFormat format,
     const PP_Size& size,
     bool init_to_zero,
     PP_ImageDataDesc* desc,
-    IPC::PlatformFileForTransit* image_handle,
+    base::SharedMemoryHandle* image_handle,
     uint32_t* byte_count) {
   HostDispatcher* dispatcher = HostDispatcher::GetForInstance(instance);
   if (!dispatcher)
     return 0;
 
   thunk::EnterResourceCreation enter(instance);
   if (enter.failed())
     return 0;
 
   PP_Bool pp_init_to_zero = init_to_zero ? PP_TRUE : PP_FALSE;
@@ skipping 17 matching lines @@
   ppapi::ScopedPPResource resource(ppapi::ScopedPPResource::PassRef(),
                                    pp_resource);
 
   thunk::EnterResourceNoLock<PPB_ImageData_API> enter_resource(resource.get(),
                                                                false);
   if (enter_resource.object()->Describe(desc) != PP_TRUE) {
     DVLOG(1) << "CreateImageData failed: could not Describe";
     return 0;
   }
 
-  int local_fd = 0;
-  if (enter_resource.object()->GetSharedMemory(&local_fd,
-                                               byte_count) != PP_OK) {
+  base::SharedMemoryHandle local_handle;
+  if (enter_resource.object()->GetSharedMemory(&local_handle, byte_count) !=
+      PP_OK) {
     DVLOG(1) << "CreateImageData failed: could not GetSharedMemory";
     return 0;
   }
 
-#if defined(OS_WIN)
-  *image_handle = dispatcher->ShareHandleWithRemote(
-      reinterpret_cast<HANDLE>(static_cast<intptr_t>(local_fd)), false);
-#elif defined(OS_POSIX)
-  *image_handle = dispatcher->ShareHandleWithRemote(local_fd, false);
-#else
-  #error Not implemented.
-#endif
-
+  *image_handle = dispatcher->ShareSharedMemoryHandleWithRemote(local_handle);
   return resource.Release();
 }
 
 void PPB_ImageData_Proxy::OnHostMsgCreatePlatform(
     PP_Instance instance,
     int32_t format,
     const PP_Size& size,
     PP_Bool init_to_zero,
     HostResource* result,
     PP_ImageDataDesc* desc,
     ImageHandle* result_image_handle) {
   // Clear |desc| so we don't send unitialized memory to the plugin.
   // https://crbug.com/391023.
   *desc = PP_ImageDataDesc();
-  IPC::PlatformFileForTransit image_handle;
+  base::SharedMemoryHandle image_handle;
   uint32_t byte_count;
   PP_Resource resource =
       CreateImageData(instance,
                       PPB_ImageData_Shared::PLATFORM,
                       static_cast<PP_ImageDataFormat>(format),
                       size,
                       true /* init_to_zero */,
                       desc, &image_handle, &byte_count);
   result->SetHostResource(instance, resource);
   if (resource) {
     *result_image_handle = image_handle;
   } else {
     *result_image_handle = PlatformImageData::NullHandle();
   }
 }
 
 void PPB_ImageData_Proxy::OnHostMsgCreateSimple(
     PP_Instance instance,
     int32_t format,
     const PP_Size& size,
     PP_Bool init_to_zero,
     HostResource* result,
     PP_ImageDataDesc* desc,
     ppapi::proxy::SerializedHandle* result_image_handle) {
   // Clear |desc| so we don't send unitialized memory to the plugin.
   // https://crbug.com/391023.
   *desc = PP_ImageDataDesc();
-  IPC::PlatformFileForTransit image_handle;
+  base::SharedMemoryHandle image_handle;
   uint32_t byte_count;
   PP_Resource resource =
       CreateImageData(instance,
                       PPB_ImageData_Shared::SIMPLE,
                       static_cast<PP_ImageDataFormat>(format),
                       size,
                       true /* init_to_zero */,
                       desc, &image_handle, &byte_count);
 
   result->SetHostResource(instance, resource);
@@ skipping 22 matching lines @@
   // still cached in our process, the proxy still holds a reference so we can
   // remove the one the renderer just sent is. If the proxy no longer holds a
   // reference, we released everything and we should also release the one the
   // renderer just sent us.
   dispatcher()->Send(new PpapiHostMsg_PPBCore_ReleaseResource(
       API_ID_PPB_CORE, old_image_data));
 }
 
 }  // namespace proxy
 }  // namespace ppapi