Update pepper to not assume that SharedMemoryHandle is an int.

content/renderer/pepper/ppb_image_data_impl.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 "content/renderer/pepper/ppb_image_data_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
@@ skipping 87 matching lines @@
   desc->size.width = width_;
   desc->size.height = height_;
   desc->stride = width_ * 4;
   return PP_TRUE;
 }
 
 void* PPB_ImageData_Impl::Map() { return backend_->Map(); }
 
 void PPB_ImageData_Impl::Unmap() { backend_->Unmap(); }
 
-int32_t PPB_ImageData_Impl::GetSharedMemory(int* handle, uint32_t* byte_count) {
+int32_t PPB_ImageData_Impl::GetSharedMemory(base::SharedMemoryHandle* handle,
+                                            uint32_t* byte_count) {
   return backend_->GetSharedMemory(handle, byte_count);
 }
 
 skia::PlatformCanvas* PPB_ImageData_Impl::GetPlatformCanvas() {
   return backend_->GetPlatformCanvas();
 }
 
 SkCanvas* PPB_ImageData_Impl::GetCanvas() { return backend_->GetCanvas(); }
 
 void PPB_ImageData_Impl::SetIsCandidateForReuse() {
@@ skipping 61 matching lines @@
   return bitmap.getAddr32(0, 0);
 }
 
 void ImageDataPlatformBackend::Unmap() {
   // This is currently unimplemented, which is OK. The data will just always
   // be around once it's mapped. Chrome's TransportDIB isn't currently
   // unmappable without freeing it, but this may be something we want to support
   // in the future to save some memory.
 }
 
-int32_t ImageDataPlatformBackend::GetSharedMemory(int* handle,
-                                                  uint32_t* byte_count) {
+int32_t ImageDataPlatformBackend::GetSharedMemory(
+    base::SharedMemoryHandle* handle,
+    uint32_t* byte_count) {
   *byte_count = dib_->size();
-  *handle = reinterpret_cast<int>(PlatformFileFromSharedMemoryHandle(
-      dib_->handle()));
+  *handle = dib_->handle();
   return PP_OK;
 }
 
 skia::PlatformCanvas* ImageDataPlatformBackend::GetPlatformCanvas() {
   return mapped_canvas_.get();
 }
 
 SkCanvas* ImageDataPlatformBackend::GetCanvas() { return mapped_canvas_.get(); }
 
 const SkBitmap* ImageDataPlatformBackend::GetMappedBitmap() const {
@@ skipping 37 matching lines @@
     return skia_bitmap_.getAddr32(0, 0);
   }
   return shared_memory_->memory();
 }
 
 void ImageDataSimpleBackend::Unmap() {
   if (--map_count_ == 0)
     shared_memory_->Unmap();
 }
 
-int32_t ImageDataSimpleBackend::GetSharedMemory(int* handle,
-                                                uint32_t* byte_count) {
+int32_t ImageDataSimpleBackend::GetSharedMemory(
+    base::SharedMemoryHandle* handle,
+    uint32_t* byte_count) {
   *byte_count = skia_bitmap_.getSize();
-  *handle = reinterpret_cast<int>(PlatformFileFromSharedMemoryHandle(
-      shared_memory_->handle()));
+  *handle = shared_memory_->handle();
   return PP_OK;
 }
 
 skia::PlatformCanvas* ImageDataSimpleBackend::GetPlatformCanvas() {
   return NULL;
 }
 
 SkCanvas* ImageDataSimpleBackend::GetCanvas() {
   if (!IsMapped())
     return NULL;
   return skia_canvas_.get();
 }
 
 const SkBitmap* ImageDataSimpleBackend::GetMappedBitmap() const {
   if (!IsMapped())
     return NULL;
   return &skia_bitmap_;
 }
 
 }  // namespace content