Add GpuMemoryBuffer support for DXGI handles.

ui/gfx/mojo/buffer_types_struct_traits.cc

Index: ui/gfx/mojo/buffer_types_struct_traits.cc
diff --git a/ui/gfx/mojo/buffer_types_struct_traits.cc b/ui/gfx/mojo/buffer_types_struct_traits.cc
index 6eb14953be589bc056068fcc2cdf7ae44014d092..1f5be8dc3a586a1dca27cfb5436b7e698fa9deba 100644
--- a/ui/gfx/mojo/buffer_types_struct_traits.cc
+++ b/ui/gfx/mojo/buffer_types_struct_traits.cc
@@ -70,6 +70,30 @@ StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
                                       false);
 }
 
+mojo::ScopedHandle StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
+                                gfx::GpuMemoryBufferHandle>::
+    win32_handle(const gfx::GpuMemoryBufferHandle& handle) {
+  if (handle.type != gfx::DXGI_HANDLE)
+    return mojo::ScopedHandle();
+
+#if defined(OS_WIN)
+  DCHECK(handle.handle.OwnershipPassesToIPC());
+  MojoPlatformHandle mojo_platform_handle;
+  mojo_platform_handle.struct_size = sizeof(mojo_platform_handle);
+  mojo_platform_handle.type = MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE;
+  mojo_platform_handle.value =
+      reinterpret_cast<uint64_t>(handle.handle.GetHandle());
+  mojo::Handle mojo_handle;
+  MojoResult result = MojoWrapPlatformHandle(&mojo_platform_handle,
+                                             mojo_handle.mutable_value());
+  if (result != MOJO_RESULT_OK)
+    return mojo::ScopedHandle();
+  return mojo::MakeScopedHandle(mojo_handle);

[dcheng, 2017/07/12 08:46:19]

Maybe this can just use WrapSharedMemoryHandle?

One thing I'm not sure about though... it's not clear to me if this is safe. The
documentation for ScopedHandle says it takes ownership, and it certainly /looks/
like ownership is transferred here. However, Mojo currently calls each
serializer 2x (this is https://crbug.com/681080) and it's not clear to me what
happens if we transfer ownership twice...

That being said, the input parameter is const T& which would imply that
ownership is not actually transferred... so I'm wondering how this actually
works.

(there is some other code that seems to have this issue: for example,
https://cs.chromium.org/chromium/src/media/gpu/mojo/jpeg_decoder_typemap_trai...)

[dcheng, 2017/07/12 21:58:46]

OK I asked rockot@ and it turns out that Mojo special-cases handle serializers
to only be invoked once.

Meh.

[yzshen1, 2017/07/12 23:38:49]

Sorry I didn't see this comment earlier.
Yes, getters of object types (struct/union/map/string/array) are called twice
because their size needs to be calculated. Primitive types / handles are only
called once.

Btw, Ken and I chatted about the calculate-before-allocate v.s.
grow-if-necessary issue again. We both think it is good to try out the
grow-if-necessary approach. (All credits go to Ken because he plans to do the
work). If that finally happens, we could make sure each getter is called once,
and a lot of custom context usage could be removed.

+#else
+  return mojo::ScopedHandle();
+#endif
+}
+
 const gfx::NativePixmapHandle&
 StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
              gfx::GpuMemoryBufferHandle>::
@@ -128,6 +152,26 @@ bool StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
     out->mach_port.reset(mach_port);
   }
 #endif
+#if defined(OS_WIN)
+  if (out->type == gfx::DXGI_HANDLE) {
+    mojo::ScopedHandle handle = data.TakeWin32Handle();
+    if (handle.is_valid()) {
+      MojoPlatformHandle platform_handle;
+      platform_handle.struct_size = sizeof(platform_handle);
+      MojoResult unwrap_result =
+          MojoUnwrapPlatformHandle(handle.release().value(), &platform_handle);
+
+      if (unwrap_result != MOJO_RESULT_OK)
+        return false;
+      DCHECK_EQ(platform_handle.type, MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE);
+      out->handle = base::SharedMemoryHandle(
+          reinterpret_cast<HANDLE>(platform_handle.value), 0,
+          base::UnguessableToken::Create());
+    }
+
+    out->array_level = data.array_level();
+  }
+#endif
   return true;
 }