Update from https://crrev.com/309415

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 25 matching lines @@
 #include "ui/gfx/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
 
 #if defined(OS_ANDROID)
 #include "gpu/command_buffer/service/stream_texture_manager_in_process_android.h"
 #include "ui/gl/android/surface_texture.h"
 #endif
 
+#if defined(OS_WIN)
+#include <windows.h>
+#include "base/process/process_handle.h"
+#endif
+
 namespace gpu {
 
 namespace {
 
 template <typename T>
 static void RunTaskWithResult(base::Callback<T(void)> task,
                               T* result,
                               base::WaitableEvent* completion) {
   *result = task.Run();
   completion->Signal();
@@ skipping 117 matching lines @@
 void SyncPointManager::WaitSyncPoint(uint32 sync_point) {
   base::AutoLock lock(lock_);
   while (pending_sync_points_.count(sync_point)) {
     cond_var_.Wait();
   }
 }
 
 base::LazyInstance<SyncPointManager> g_sync_point_manager =
     LAZY_INSTANCE_INITIALIZER;
 
+base::SharedMemoryHandle ShareToGpuThread(
+    base::SharedMemoryHandle source_handle) {
+#if defined(OS_WIN)
+  // Windows needs to explicitly duplicate the handle to current process.
+  base::SharedMemoryHandle target_handle;
+  if (!DuplicateHandle(GetCurrentProcess(),
+                       source_handle,
+                       GetCurrentProcess(),
+                       &target_handle,
+                       FILE_GENERIC_READ | FILE_GENERIC_WRITE,
+                       FALSE,
+                       0)) {
+    return base::SharedMemory::NULLHandle();
+  }
+
+  return target_handle;
+#else
+  int duped_handle = HANDLE_EINTR(dup(source_handle.fd));
+  if (duped_handle < 0)
+    return base::SharedMemory::NULLHandle();
+
+  return base::FileDescriptor(duped_handle, true);
+#endif
+}
+
+gfx::GpuMemoryBufferHandle ShareGpuMemoryBufferToGpuThread(
+    const gfx::GpuMemoryBufferHandle& source_handle,
+    bool* requires_sync_point) {
+  switch (source_handle.type) {
+    case gfx::SHARED_MEMORY_BUFFER: {
+      gfx::GpuMemoryBufferHandle handle;
+      handle.type = gfx::SHARED_MEMORY_BUFFER;
+      handle.handle = ShareToGpuThread(source_handle.handle);
+      *requires_sync_point = false;
+      return handle;
+    }
+    case gfx::IO_SURFACE_BUFFER:
+    case gfx::SURFACE_TEXTURE_BUFFER:
+    case gfx::OZONE_NATIVE_BUFFER:
+      *requires_sync_point = true;
+      return source_handle;
+    default:
+      NOTREACHED();
+      return gfx::GpuMemoryBufferHandle();
+  }
+}
+
 }  // anonyous namespace
 
 InProcessCommandBuffer::Service::Service() {}
 
 InProcessCommandBuffer::Service::~Service() {}
 
 scoped_refptr<gles2::MailboxManager>
 InProcessCommandBuffer::Service::mailbox_manager() {
   if (!mailbox_manager_.get()) {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 442 matching lines @@
 
   DCHECK(gpu_memory_buffer_manager_);
   gfx::GpuMemoryBuffer* gpu_memory_buffer =
       gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffer);
   DCHECK(gpu_memory_buffer);
 
   int32 new_id = next_image_id_.GetNext();
 
   DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
+
+  // This handle is owned by the GPU thread and must be passed to it or it
+  // will leak. In otherwords, do not early out on error between here and the
+  // queuing of the CreateImage task below.
+  bool requires_sync_point = false;
+  gfx::GpuMemoryBufferHandle handle =
+      ShareGpuMemoryBufferToGpuThread(gpu_memory_buffer->GetHandle(),
+                                      &requires_sync_point);
+
   QueueTask(base::Bind(&InProcessCommandBuffer::CreateImageOnGpuThread,
                        base::Unretained(this),
                        new_id,
-                       gpu_memory_buffer->GetHandle(),
+                       handle,
                        gfx::Size(width, height),
                        gpu_memory_buffer->GetFormat(),
                        internalformat));
+
+  if (requires_sync_point) {
+    gpu_memory_buffer_manager_->SetDestructionSyncPoint(gpu_memory_buffer,
+                                                        InsertSyncPoint());
+  }
+
   return new_id;
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
     int32 id,
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::GpuMemoryBuffer::Format format,
     uint32 internalformat) {
   if (!decoder_)
@@ skipping 216 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu