Update pepper to not assume that SharedMemoryHandle is an int.

ppapi/proxy/ppb_audio_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_audio_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/threading/simple_thread.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio.h"
@@ skipping 32 matching lines @@
   // Resource overrides.
   PPB_Audio_API* AsPPB_Audio_API() override;
 
   // PPB_Audio_API implementation.
   PP_Resource GetCurrentConfig() override;
   PP_Bool StartPlayback() override;
   PP_Bool StopPlayback() override;
   int32_t Open(PP_Resource config_id,
                scoped_refptr<TrackedCallback> create_callback) override;
   int32_t GetSyncSocket(int* sync_socket) override;
-  int32_t GetSharedMemory(int* shm_handle, uint32_t* shm_size) override;
+  int32_t GetSharedMemory(base::SharedMemory* shm, uint32_t* shm_size) override;
 
  private:
   // Owning reference to the current config object. This isn't actually used,
   // we just dish it out as requested by the plugin.
   PP_Resource config_;
 
   DISALLOW_COPY_AND_ASSIGN(Audio);
 };
 
 Audio::Audio(const HostResource& audio_id,
@@ skipping 51 matching lines @@
 
 int32_t Audio::Open(PP_Resource config_id,
                     scoped_refptr<TrackedCallback> create_callback) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
 int32_t Audio::GetSyncSocket(int* sync_socket) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
-int32_t Audio::GetSharedMemory(int* shm_handle, uint32_t* shm_size) {
+int32_t Audio::GetSharedMemory(base::SharedMemory* shm, uint32_t* shm_size) {
   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 }
 
 PPB_Audio_Proxy::PPB_Audio_Proxy(Dispatcher* dispatcher)
     : InterfaceProxy(dispatcher),
       callback_factory_(this) {
 }
 
 PPB_Audio_Proxy::~PPB_Audio_Proxy() {
 }
@@ skipping 103 matching lines @@
     enter.object()->StartPlayback();
   else
     enter.object()->StopPlayback();
 }
 
 void PPB_Audio_Proxy::AudioChannelConnected(
     int32_t result,
     const HostResource& resource) {
   IPC::PlatformFileForTransit socket_handle =
       IPC::InvalidPlatformFileForTransit();
-  base::SharedMemoryHandle shared_memory = IPC::InvalidPlatformFileForTransit();
+  base::SharedMemoryHandle shared_memory = base::SharedMemory::NULLHandle();
   uint32_t audio_buffer_length = 0;
 
   int32_t result_code = result;
   if (result_code == PP_OK) {
     result_code = GetAudioConnectedHandles(resource, &socket_handle,
                                            &shared_memory,
                                            &audio_buffer_length);
   }
 
   // Send all the values, even on error. This simplifies some of our cleanup
@@ skipping 23 matching lines @@
   if (result != PP_OK)
     return result;
 
   // socket_handle doesn't belong to us: don't close it.
   *foreign_socket_handle = dispatcher()->ShareHandleWithRemote(
       IntToPlatformFile(socket_handle), false);
   if (*foreign_socket_handle == IPC::InvalidPlatformFileForTransit())
     return PP_ERROR_FAILED;
 
   // Get the shared memory for the buffer.
-  int shared_memory_handle;
-  result = enter.object()->GetSharedMemory(&shared_memory_handle,
-                                           shared_memory_length);
+  base::SharedMemory shared_memory;
+  result =
+      enter.object()->GetSharedMemory(&shared_memory, shared_memory_length);
   if (result != PP_OK)
     return result;
 
   // shared_memory_handle doesn't belong to us: don't close it.
-  *foreign_shared_memory_handle = dispatcher()->ShareHandleWithRemote(
-      IntToPlatformFile(shared_memory_handle), false);
-  if (*foreign_shared_memory_handle == IPC::InvalidPlatformFileForTransit())
+  *foreign_shared_memory_handle =
+      dispatcher()->ShareSharedMemoryHandleWithRemote(shared_memory.handle());
+  if (!base::SharedMemory::IsHandleValid(*foreign_shared_memory_handle))
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 #endif  // !defined(OS_NACL)
 
 // Processed in the plugin (message from host).
 void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
     const HostResource& audio_id,
     int32_t result_code,
@@ skipping 15 matching lines @@
     static_cast<Audio*>(enter.object())->SetStreamInfo(
         enter.resource()->pp_instance(), handle.shmem(), handle.size(),
         IPC::PlatformFileForTransitToPlatformFile(socket_handle.descriptor()),
         config.object()->GetSampleRate(),
         config.object()->GetSampleFrameCount());
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi