gfx: Convert gfx::GpuMemoryBufferHandle to the new shared memory API.

This CL replaces the deprecated base::SharedMemoryHandle in
gfx::GpuMemoryBufferHandle with the base::UnsafeSharedMemoryRegion.

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I527a84876f8b87ddc652cf2f780a2893cb419c46
Bug: 854594, 863011
Reviewed-on: https://chromium-review.googlesource.com/c/1106340
Commit-Queue: Alexandr Ilin <alexilin@chromium.org>
Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600693}

cc/test/test_image_factory.cc

@@ -26,7 +26,7 @@ scoped_refptr<gl::GLImage> TestImageFactory::CreateImageForGpuMemoryBuffer(
 
   scoped_refptr<gl::GLImageSharedMemory> image(
       new gl::GLImageSharedMemory(size, internalformat));
-  if (!image->Initialize(handle.handle, handle.id, format, handle.offset,
+  if (!image->Initialize(handle.region, handle.id, format, handle.offset,
                          base::checked_cast<size_t>(handle.stride)))
     return nullptr;
 

components/exo/display.cc

@@ -67,14 +67,14 @@ std::unique_ptr<Surface> Display::CreateSurface() {
 }
 
 std::unique_ptr<SharedMemory> Display::CreateSharedMemory(
-    const base::SharedMemoryHandle& handle,
-    size_t size) {
-  TRACE_EVENT1("exo", "Display::CreateSharedMemory", "size", size);
+    base::UnsafeSharedMemoryRegion shared_memory_region) {
+  TRACE_EVENT1("exo", "Display::CreateSharedMemory", "size",
+               shared_memory_region.GetSize());
 
-  if (!base::SharedMemory::IsHandleValid(handle))
+  if (!shared_memory_region.IsValid())
     return nullptr;
 
-  return std::make_unique<SharedMemory>(handle);
+  return std::make_unique<SharedMemory>(std::move(shared_memory_region));
 }
 
 #if defined(USE_OZONE)

components/exo/display.h

@@ -11,7 +11,7 @@
 #include <string>
 
 #include "base/macros.h"
-#include "base/memory/shared_memory_handle.h"
+#include "base/memory/unsafe_shared_memory_region.h"
 #include "components/exo/seat.h"
 
 #if defined(USE_OZONE)
@@ -58,11 +58,10 @@ class Display {
   // Creates a new surface.
   std::unique_ptr<Surface> CreateSurface();
 
-  // Creates a shared memory segment from |handle| of |size| with the
-  // given |id|. This function takes ownership of |handle|.
+  // Creates a shared memory segment from |shared_memory_region|. This function
+  // takes ownership of the region.
   std::unique_ptr<SharedMemory> CreateSharedMemory(
-      const base::SharedMemoryHandle& handle,
-      size_t size);
+      base::UnsafeSharedMemoryRegion shared_memory_region);
 
 #if defined(USE_OZONE)
   // Creates a buffer for a Linux DMA-buf file descriptor.

components/exo/display_unittest.cc

@@ -39,22 +39,18 @@ TEST_F(DisplayTest, CreateSharedMemory) {
   std::unique_ptr<Display> display(new Display);
 
   int shm_size = 8192;
-  std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
-  bool rv = shared_memory->CreateAnonymous(shm_size);
-  ASSERT_TRUE(rv);
+  base::UnsafeSharedMemoryRegion shared_memory =
+      base::UnsafeSharedMemoryRegion::Create(shm_size);
+  ASSERT_TRUE(shared_memory.IsValid());
 
-  base::SharedMemoryHandle handle =
-      base::SharedMemory::DuplicateHandle(shared_memory->handle());
-  ASSERT_TRUE(base::SharedMemory::IsHandleValid(handle));
-
-  // Creating a shared memory instance from a valid handle should succeed.
+  // Creating a shared memory instance from a valid region should succeed.
   std::unique_ptr<SharedMemory> shm1 =
-      display->CreateSharedMemory(handle, shm_size);
+      display->CreateSharedMemory(std::move(shared_memory));
   EXPECT_TRUE(shm1);
 
-  // Creating a shared memory instance from a invalid handle should fail.
+  // Creating a shared memory instance from a invalid region should fail.
   std::unique_ptr<SharedMemory> shm2 =
-      display->CreateSharedMemory(base::SharedMemoryHandle(), shm_size);
+      display->CreateSharedMemory(base::UnsafeSharedMemoryRegion());
   EXPECT_FALSE(shm2);
 }
 

components/exo/shared_memory.cc

@@ -34,8 +34,8 @@ bool IsSupportedFormat(gfx::BufferFormat format) {
 ////////////////////////////////////////////////////////////////////////////////
 // SharedMemory, public:
 
-SharedMemory::SharedMemory(const base::SharedMemoryHandle& handle)
-    : shared_memory_(handle, true /* read-only */) {}
+SharedMemory::SharedMemory(base::UnsafeSharedMemoryRegion shared_memory_region)
+    : shared_memory_region_(std::move(shared_memory_region)) {}
 
 SharedMemory::~SharedMemory() {}
 
@@ -63,7 +63,7 @@ std::unique_ptr<Buffer> SharedMemory::CreateBuffer(const gfx::Size& size,
 
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
-  handle.handle = base::SharedMemory::DuplicateHandle(shared_memory_.handle());
+  handle.region = shared_memory_region_.Duplicate();
   handle.offset = offset;
   handle.stride = stride;
 

components/exo/shared_memory.h

@@ -8,18 +8,19 @@
 #include <memory>
 
 #include "base/macros.h"
-#include "base/memory/shared_memory.h"
+#include "base/memory/unsafe_shared_memory_region.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace exo {
 class Buffer;
 
-// Shared memory abstraction. Provides a wrapper around base::SharedMemory
-// with functionality to create buffers from the memory to use for display.
+// Shared memory abstraction. Provides a wrapper around
+// base::UnsafeSharedMemoryRegion with functionality to create buffers from the
+// memory to use for display.
 class SharedMemory {
  public:
-  explicit SharedMemory(const base::SharedMemoryHandle& handle);
+  explicit SharedMemory(base::UnsafeSharedMemoryRegion shared_memory_region);
   ~SharedMemory();
 
   // Creates a buffer from the shared memory. The buffer is created offset bytes
@@ -33,7 +34,7 @@ class SharedMemory {
                                        int stride);
 
  private:
-  base::SharedMemory shared_memory_;
+  base::UnsafeSharedMemoryRegion shared_memory_region_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemory);
 };

components/exo/shared_memory_unittest.cc

@@ -17,13 +17,10 @@ namespace {
 using SharedMemoryTest = test::ExoTestBase;
 
 std::unique_ptr<SharedMemory> CreateSharedMemory(size_t size) {
-  std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
-  bool rv = shared_memory->CreateAnonymous(size);
-  DCHECK(rv);
-  base::SharedMemoryHandle handle =
-      base::SharedMemory::DuplicateHandle(shared_memory->handle());
-  DCHECK(base::SharedMemory::IsHandleValid(handle));
-  return std::make_unique<SharedMemory>(handle);
+  base::UnsafeSharedMemoryRegion shared_memory =
+      base::UnsafeSharedMemoryRegion::Create(size);
+  DCHECK(shared_memory.IsValid());
+  return std::make_unique<SharedMemory>(std::move(shared_memory));
 }
 
 TEST_F(SharedMemoryTest, CreateBuffer) {

components/exo/wayland/server.cc

@@ -712,9 +712,17 @@ void shm_create_pool(wl_client* client,
                      uint32_t id,
                      int fd,
                      int32_t size) {
+  static const auto kMode =
+      base::subtle::PlatformSharedMemoryRegion::Mode::kUnsafe;
+  auto fd_pair = base::subtle::ScopedFDPair(base::ScopedFD(fd),
+                                            base::ScopedFD() /* readonly_fd */);
+  auto guid = base::UnguessableToken::Create();
+  auto platform_shared_memory = base::subtle::PlatformSharedMemoryRegion::Take(
+      std::move(fd_pair), kMode, size, guid);
   std::unique_ptr<SharedMemory> shared_memory =
       GetUserDataAs<Display>(resource)->CreateSharedMemory(
-          base::SharedMemoryHandle::ImportHandle(fd, size), size);
+          base::UnsafeSharedMemoryRegion::Deserialize(
+              std::move(platform_shared_memory)));
   if (!shared_memory) {
     wl_resource_post_no_memory(resource);
     return;

components/viz/host/host_gpu_memory_buffer_manager.cc

@@ -156,7 +156,7 @@ void HostGpuMemoryBufferManager::AllocateGpuMemoryBuffer(
     buffer_info.type = gfx::SHARED_MEMORY_BUFFER;
     buffer_info.buffer_size_in_bytes =
         gfx::BufferSizeForBufferFormat(size, format);
-    buffer_info.shared_memory_guid = buffer_handle.handle.GetGUID();
+    buffer_info.shared_memory_guid = buffer_handle.region.GetGUID();
     allocated_buffers_[client_id].insert(
         std::make_pair(buffer_handle.id, buffer_info));
   }

components/viz/test/test_gpu_memory_buffer_manager.cc

@@ -21,14 +21,14 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
                       int id,
                       const gfx::Size& size,
                       gfx::BufferFormat format,
-                      std::unique_ptr<base::SharedMemory> shared_memory,
+                      base::UnsafeSharedMemoryRegion shared_memory_region,
                       size_t offset,
                       size_t stride)
       : manager_(manager),
         id_(id),
         size_(size),
         format_(format),
-        shared_memory_(std::move(shared_memory)),
+        region_(std::move(shared_memory_region)),
         offset_(offset),
         stride_(stride),
         mapped_(false) {}
@@ -39,8 +39,9 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   bool Map() override {
     DCHECK(!mapped_);
     DCHECK_EQ(stride_, gfx::RowSizeForBufferFormat(size_.width(), format_, 0));
-    if (!shared_memory_->Map(offset_ +
-                             gfx::BufferSizeForBufferFormat(size_, format_)))
+    mapping_ = region_.MapAt(
+        0, offset_ + gfx::BufferSizeForBufferFormat(size_, format_));
+    if (!mapping_.IsValid())
       return false;
     mapped_ = true;
     return true;
@@ -48,12 +49,12 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   void* memory(size_t plane) override {
     DCHECK(mapped_);
     DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
-    return reinterpret_cast<uint8_t*>(shared_memory_->memory()) + offset_ +
+    return reinterpret_cast<uint8_t*>(mapping_.memory()) + offset_ +
            gfx::BufferOffsetForBufferFormat(size_, format_, plane);
   }
   void Unmap() override {
     DCHECK(mapped_);
-    shared_memory_->Unmap();
+    mapping_ = base::WritableSharedMemoryMapping();
     mapped_ = false;
   }
   gfx::Size GetSize() const override { return size_; }
@@ -70,8 +71,7 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   gfx::GpuMemoryBufferHandle CloneHandle() const override {
     gfx::GpuMemoryBufferHandle handle;
     handle.type = gfx::SHARED_MEMORY_BUFFER;
-    handle.handle =
-        base::SharedMemory::DuplicateHandle(shared_memory_->handle());
+    handle.region = region_.Duplicate();
     handle.offset = base::checked_cast<uint32_t>(offset_);
     handle.stride = base::checked_cast<int32_t>(stride_);
     return handle;
@@ -90,7 +90,8 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   gfx::GpuMemoryBufferId id_;
   const gfx::Size size_;
   gfx::BufferFormat format_;
-  std::unique_ptr<base::SharedMemory> shared_memory_;
+  base::UnsafeSharedMemoryRegion region_;
+  base::WritableSharedMemoryMapping mapping_;
   size_t offset_;
   size_t stride_;
   bool mapped_;
@@ -177,15 +178,16 @@ TestGpuMemoryBufferManager::CreateGpuMemoryBuffer(
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gpu::SurfaceHandle surface_handle) {
-  std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
   const size_t buffer_size = gfx::BufferSizeForBufferFormat(size, format);
-  if (!shared_memory->CreateAnonymous(buffer_size))
+  base::UnsafeSharedMemoryRegion shared_memory_region =
+      base::UnsafeSharedMemoryRegion::Create(buffer_size);
+  if (!shared_memory_region.IsValid())
     return nullptr;
 
   last_gpu_memory_buffer_id_ += 1;
   std::unique_ptr<gfx::GpuMemoryBuffer> result(new GpuMemoryBufferImpl(
-      this, last_gpu_memory_buffer_id_, size, format, std::move(shared_memory),
-      0,
+      this, last_gpu_memory_buffer_id_, size, format,
+      std::move(shared_memory_region), 0,
       base::checked_cast<int>(
           gfx::RowSizeForBufferFormat(size.width(), format, 0))));
   base::AutoLock hold(buffers_lock_);

gpu/ipc/common/gpu_memory_buffer_impl_shared_memory.cc

@@ -27,11 +27,13 @@ GpuMemoryBufferImplSharedMemory::GpuMemoryBufferImplSharedMemory(
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     const DestructionCallback& callback,
-    std::unique_ptr<base::SharedMemory> shared_memory,
+    base::UnsafeSharedMemoryRegion shared_memory_region,
+    base::WritableSharedMemoryMapping shared_memory_mapping,
     size_t offset,
     int stride)
     : GpuMemoryBufferImpl(id, size, format, callback),
-      shared_memory_(std::move(shared_memory)),
+      shared_memory_region_(std::move(shared_memory_region)),
+      shared_memory_mapping_(std::move(shared_memory_mapping)),
       offset_(offset),
       stride_(stride) {
   DCHECK(IsUsageSupported(usage));
@@ -53,12 +55,15 @@ GpuMemoryBufferImplSharedMemory::Create(gfx::GpuMemoryBufferId id,
   if (!gfx::BufferSizeForBufferFormatChecked(size, format, &buffer_size))
     return nullptr;
 
-  std::unique_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
-  if (!shared_memory->CreateAndMapAnonymous(buffer_size))
+  auto shared_memory_region =
+      base::UnsafeSharedMemoryRegion::Create(buffer_size);
+  auto shared_memory_mapping = shared_memory_region.Map();
+  if (!shared_memory_region.IsValid() || !shared_memory_mapping.IsValid())
     return nullptr;
 
   return base::WrapUnique(new GpuMemoryBufferImplSharedMemory(
-      id, size, format, usage, callback, std::move(shared_memory), 0,
+      id, size, format, usage, callback, std::move(shared_memory_region),
+      std::move(shared_memory_mapping), 0,
       gfx::RowSizeForBufferFormat(size.width(), format, 0)));
 }
 
@@ -75,8 +80,9 @@ GpuMemoryBufferImplSharedMemory::CreateGpuMemoryBuffer(
   if (!gfx::BufferSizeForBufferFormatChecked(size, format, &buffer_size))
     return gfx::GpuMemoryBufferHandle();
 
-  base::SharedMemory shared_memory;
-  if (!shared_memory.CreateAnonymous(buffer_size))
+  auto shared_memory_region =
+      base::UnsafeSharedMemoryRegion::Create(buffer_size);
+  if (!shared_memory_region.IsValid())
     return gfx::GpuMemoryBufferHandle();
 
   gfx::GpuMemoryBufferHandle handle;
@@ -85,7 +91,7 @@ GpuMemoryBufferImplSharedMemory::CreateGpuMemoryBuffer(
   handle.offset = 0;
   handle.stride = static_cast<int32_t>(
       gfx::RowSizeForBufferFormat(size.width(), format, 0));
-  handle.handle = shared_memory.TakeHandle();
+  handle.region = std::move(shared_memory_region);
   return handle;
 }
 
@@ -97,12 +103,11 @@ GpuMemoryBufferImplSharedMemory::CreateFromHandle(
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     const DestructionCallback& callback) {
-  DCHECK(base::SharedMemory::IsHandleValid(handle.handle));
+  DCHECK(handle.region.IsValid());
 
   return base::WrapUnique(new GpuMemoryBufferImplSharedMemory(
-      handle.id, size, format, usage, callback,
-      std::make_unique<base::SharedMemory>(handle.handle, false), handle.offset,
-      handle.stride));
+      handle.id, size, format, usage, callback, std::move(handle.region),
+      base::WritableSharedMemoryMapping(), handle.offset, handle.stride));
 }
 
 // static
@@ -181,14 +186,15 @@ bool GpuMemoryBufferImplSharedMemory::Map() {
 
   // Map the buffer first time Map() is called then keep it mapped for the
   // lifetime of the buffer. This avoids mapping the buffer unless necessary.
-  if (!shared_memory_->memory()) {
+  if (!shared_memory_mapping_.IsValid()) {
     DCHECK_EQ(static_cast<size_t>(stride_),
               gfx::RowSizeForBufferFormat(size_.width(), format_, 0));
     size_t buffer_size = gfx::BufferSizeForBufferFormat(size_, format_);
     // Note: offset_ != 0 is not common use-case. To keep it simple we
     // map offset + buffer_size here but this can be avoided using MapAt().
     size_t map_size = offset_ + buffer_size;
-    if (!shared_memory_->Map(map_size))
+    shared_memory_mapping_ = shared_memory_region_.MapAt(0, map_size);
+    if (!shared_memory_mapping_.IsValid())
       base::TerminateBecauseOutOfMemory(map_size);
   }
   mapped_ = true;
@@ -198,7 +204,7 @@ bool GpuMemoryBufferImplSharedMemory::Map() {
 void* GpuMemoryBufferImplSharedMemory::memory(size_t plane) {
   DCHECK(mapped_);
   DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
-  return static_cast<uint8_t*>(shared_memory_->memory()) + offset_ +
+  return static_cast<uint8_t*>(shared_memory_mapping_.memory()) + offset_ +
          gfx::BufferOffsetForBufferFormat(size_, format_, plane);
 }
 
@@ -223,7 +229,7 @@ gfx::GpuMemoryBufferHandle GpuMemoryBufferImplSharedMemory::CloneHandle()
   handle.id = id_;
   handle.offset = offset_;
   handle.stride = stride_;
-  handle.handle = base::SharedMemory::DuplicateHandle(shared_memory_->handle());
+  handle.region = shared_memory_region_.Duplicate();
   return handle;
 }
 
@@ -238,7 +244,7 @@ void GpuMemoryBufferImplSharedMemory::OnMemoryDump(
 
 base::UnguessableToken GpuMemoryBufferImplSharedMemory::GetSharedMemoryGUID()
     const {
-  return shared_memory_->mapped_id();
+  return shared_memory_region_.GetGUID();
 }
 
 }  // namespace gpu

gpu/ipc/common/gpu_memory_buffer_impl_shared_memory.h

@@ -77,11 +77,13 @@ class GPU_EXPORT GpuMemoryBufferImplSharedMemory : public GpuMemoryBufferImpl {
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
       const DestructionCallback& callback,
-      std::unique_ptr<base::SharedMemory> shared_memory,
+      base::UnsafeSharedMemoryRegion shared_memory_region,
+      base::WritableSharedMemoryMapping shared_memory_mapping,
       size_t offset,
       int stride);
 
-  std::unique_ptr<base::SharedMemory> shared_memory_;
+  base::UnsafeSharedMemoryRegion shared_memory_region_;
+  base::WritableSharedMemoryMapping shared_memory_mapping_;
   size_t offset_;
   int stride_;
 

gpu/ipc/in_process_command_buffer.cc

@@ -1063,7 +1063,7 @@ void InProcessCommandBuffer::CreateImageOnGpuThread(
       }
       scoped_refptr<gl::GLImageSharedMemory> image(
           new gl::GLImageSharedMemory(size, internalformat));
-      if (!image->Initialize(handle.handle, handle.id, format, handle.offset,
+      if (!image->Initialize(handle.region, handle.id, format, handle.offset,
                              handle.stride)) {
         LOG(ERROR) << "Failed to initialize image.";
         return;

gpu/ipc/service/gpu_channel.cc

@@ -719,7 +719,7 @@ scoped_refptr<gl::GLImage> GpuChannel::CreateImageForGpuMemoryBuffer(
         return nullptr;
       scoped_refptr<gl::GLImageSharedMemory> image(
           new gl::GLImageSharedMemory(size, internalformat));
-      if (!image->Initialize(handle.handle, handle.id, format, handle.offset,
+      if (!image->Initialize(handle.region, handle.id, format, handle.offset,
                              handle.stride)) {
         return nullptr;
       }

ui/gfx/gpu_memory_buffer.h

@@ -9,6 +9,7 @@
 #include <stdint.h>
 
 #include "base/memory/shared_memory.h"
+#include "base/memory/unsafe_shared_memory_region.h"
 #include "build/build_config.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/generic_shared_memory_id.h"
@@ -61,8 +62,7 @@ struct GFX_EXPORT GpuMemoryBufferHandle {
   bool is_null() const { return type == EMPTY_BUFFER; }
   GpuMemoryBufferType type;
   GpuMemoryBufferId id;
-  // TODO(crbug.com/863011): convert this to a scoped handle.
-  base::SharedMemoryHandle handle;
+  base::UnsafeSharedMemoryRegion region;
   uint32_t offset;
   int32_t stride;
 #if defined(OS_LINUX)

ui/gfx/ipc/gfx_param_traits_macros.h

@@ -48,7 +48,7 @@ IPC_STRUCT_TRAITS_END()
 IPC_STRUCT_TRAITS_BEGIN(gfx::GpuMemoryBufferHandle)
   IPC_STRUCT_TRAITS_MEMBER(id)
   IPC_STRUCT_TRAITS_MEMBER(type)
-  IPC_STRUCT_TRAITS_MEMBER(handle)
+  IPC_STRUCT_TRAITS_MEMBER(region)
   IPC_STRUCT_TRAITS_MEMBER(offset)
   IPC_STRUCT_TRAITS_MEMBER(stride)
 #if defined(OS_LINUX)

ui/gfx/mojo/buffer_types.mojom

@@ -4,6 +4,8 @@
 
 module gfx.mojom;
 
+import "mojo/public/mojom/base/shared_memory.mojom";
+
 // gfx::BufferFormat
 enum BufferFormat {
   R_8,
@@ -95,7 +97,7 @@ struct GpuMemoryBufferHandle {
   // desired platform.
   GpuMemoryBufferType type;
   GpuMemoryBufferId id;
-  handle<shared_buffer>? shared_memory_handle;
+  mojo_base.mojom.UnsafeSharedMemoryRegion? shared_memory_handle;
   uint32 offset;
   uint32 stride;
   NativePixmapHandle? native_pixmap_handle;

ui/gfx/mojo/buffer_types_struct_traits.cc

@@ -5,6 +5,7 @@
 #include "ui/gfx/mojo/buffer_types_struct_traits.h"
 
 #include "build/build_config.h"
+#include "mojo/public/cpp/base/shared_memory_mojom_traits.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 
 #if defined(OS_ANDROID)
@@ -60,15 +61,13 @@ bool StructTraits<
 #endif
 }
 
-mojo::ScopedSharedBufferHandle
+base::UnsafeSharedMemoryRegion
 StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
              gfx::GpuMemoryBufferHandle>::
-    shared_memory_handle(const gfx::GpuMemoryBufferHandle& handle) {
+    shared_memory_handle(gfx::GpuMemoryBufferHandle& handle) {
   if (handle.type != gfx::SHARED_MEMORY_BUFFER)
-    return mojo::ScopedSharedBufferHandle();
-  return mojo::WrapSharedMemoryHandle(
-      handle.handle, handle.handle.GetSize(),
-      mojo::UnwrappedSharedMemoryHandleProtection::kReadWrite);
+    return base::UnsafeSharedMemoryRegion();
+  return std::move(handle.region);
 }
 
 const gfx::NativePixmapHandle&
@@ -143,13 +142,8 @@ bool StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
     return false;
 
   if (out->type == gfx::SHARED_MEMORY_BUFFER) {
-    mojo::ScopedSharedBufferHandle handle = data.TakeSharedMemoryHandle();
-    if (handle.is_valid()) {
-      MojoResult unwrap_result = mojo::UnwrapSharedMemoryHandle(
-          std::move(handle), &out->handle, nullptr, nullptr);
-      if (unwrap_result != MOJO_RESULT_OK)
-        return false;
-    }
+    if (!data.ReadSharedMemoryHandle(&out->region))
+      return false;
 
     out->offset = data.offset();
     out->stride = data.stride();

ui/gfx/mojo/buffer_types_struct_traits.h

@@ -295,8 +295,8 @@ struct StructTraits<gfx::mojom::GpuMemoryBufferHandleDataView,
   static gfx::GpuMemoryBufferId id(const gfx::GpuMemoryBufferHandle& handle) {
     return handle.id;
   }
-  static mojo::ScopedSharedBufferHandle shared_memory_handle(
-      const gfx::GpuMemoryBufferHandle& handle);
+  static base::UnsafeSharedMemoryRegion shared_memory_handle(
+      gfx::GpuMemoryBufferHandle& handle);
   static uint32_t offset(const gfx::GpuMemoryBufferHandle& handle) {
     return handle.offset;
   }

ui/gfx/mojo/struct_traits_unittest.cc

@@ -149,14 +149,15 @@ TEST_F(StructTraitsTest, GpuMemoryBufferHandle) {
   const gfx::GpuMemoryBufferId kId(99);
   const uint32_t kOffset = 126;
   const int32_t kStride = 256;
-  base::SharedMemory shared_memory;
-  ASSERT_TRUE(shared_memory.CreateAnonymous(1024));
-  ASSERT_TRUE(shared_memory.Map(1024));
+  base::UnsafeSharedMemoryRegion shared_memory_region =
+      base::UnsafeSharedMemoryRegion::Create(1024);
+  ASSERT_TRUE(shared_memory_region.IsValid());
+  ASSERT_TRUE(shared_memory_region.Map().IsValid());
 
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
   handle.id = kId;
-  handle.handle = base::SharedMemory::DuplicateHandle(shared_memory.handle());
+  handle.region = shared_memory_region.Duplicate();
   handle.offset = kOffset;
   handle.stride = kStride;
 
@@ -168,8 +169,8 @@ TEST_F(StructTraitsTest, GpuMemoryBufferHandle) {
   EXPECT_EQ(kOffset, output.offset);
   EXPECT_EQ(kStride, output.stride);
 
-  base::SharedMemory output_memory(output.handle, true);
-  EXPECT_TRUE(output_memory.Map(1024));
+  base::UnsafeSharedMemoryRegion output_memory = std::move(output.region);
+  EXPECT_TRUE(output_memory.Map().IsValid());
 
 #if defined(OS_LINUX)
   gfx::GpuMemoryBufferHandle handle2;

ui/gl/gl_image_shared_memory.cc

@@ -5,7 +5,6 @@
 #include "ui/gl/gl_image_shared_memory.h"
 
 #include "base/logging.h"
-#include "base/memory/shared_memory.h"
 #include "base/numerics/safe_math.h"
 #include "base/process/process_handle.h"
 #include "base/sys_info.h"
@@ -23,17 +22,14 @@ GLImageSharedMemory::GLImageSharedMemory(const gfx::Size& size,
 GLImageSharedMemory::~GLImageSharedMemory() {}
 
 bool GLImageSharedMemory::Initialize(
-    const base::SharedMemoryHandle& handle,
+    const base::UnsafeSharedMemoryRegion& region,
     gfx::GenericSharedMemoryId shared_memory_id,
     gfx::BufferFormat format,
     size_t offset,
     size_t stride) {
-  if (!base::SharedMemory::IsHandleValid(handle))
+  if (!region.IsValid())
     return false;
 
-  std::unique_ptr<base::SharedMemory> shared_memory(
-      new base::SharedMemory(handle, true));
-
   if (NumberOfPlanesForBufferFormat(format) != 1)
     return false;
 
@@ -52,20 +48,21 @@ bool GLImageSharedMemory::Initialize(
   if (!checked_size.IsValid())
     return false;
 
-  if (!shared_memory->MapAt(static_cast<off_t>(map_offset),
-                            checked_size.ValueOrDie())) {
+  auto shared_memory_mapping =
+      region.MapAt(static_cast<off_t>(map_offset), checked_size.ValueOrDie());
+  if (!shared_memory_mapping.IsValid()) {
     DVLOG(0) << "Failed to map shared memory.";
     return false;
   }
 
   if (!GLImageMemory::Initialize(
-          static_cast<uint8_t*>(shared_memory->memory()) + memory_offset,
+          static_cast<uint8_t*>(shared_memory_mapping.memory()) + memory_offset,
           format, stride)) {
     return false;
   }
 
-  DCHECK(!shared_memory_);
-  shared_memory_ = std::move(shared_memory);
+  DCHECK(!shared_memory_mapping_.IsValid());
+  shared_memory_mapping_ = std::move(shared_memory_mapping);
   shared_memory_id_ = shared_memory_id;
   return true;
 }
@@ -86,7 +83,7 @@ void GLImageSharedMemory::OnMemoryDump(
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                   static_cast<uint64_t>(size_in_bytes));
 
-  auto shared_memory_guid = shared_memory_->mapped_id();
+  auto shared_memory_guid = shared_memory_mapping_.guid();
   if (!shared_memory_guid.is_empty()) {
     pmd->CreateSharedMemoryOwnershipEdge(dump->guid(), shared_memory_guid,
                                          0 /* importance */);

ui/gl/gl_image_shared_memory.h

@@ -11,22 +11,18 @@
 #include <memory>
 
 #include "base/macros.h"
-#include "base/memory/shared_memory_handle.h"
+#include "base/memory/unsafe_shared_memory_region.h"
 #include "ui/gfx/generic_shared_memory_id.h"
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_image_memory.h"
 
-namespace base {
-class SharedMemory;
-}
-
 namespace gl {
 
 class GL_EXPORT GLImageSharedMemory : public GLImageMemory {
  public:
   GLImageSharedMemory(const gfx::Size& size, unsigned internalformat);
 
-  bool Initialize(const base::SharedMemoryHandle& handle,
+  bool Initialize(const base::UnsafeSharedMemoryRegion& shared_memory_region,
                   gfx::GenericSharedMemoryId shared_memory_id,
                   gfx::BufferFormat format,
                   size_t offset,
@@ -41,7 +37,7 @@ class GL_EXPORT GLImageSharedMemory : public GLImageMemory {
   ~GLImageSharedMemory() override;
 
  private:
-  std::unique_ptr<base::SharedMemory> shared_memory_;
+  base::WritableSharedMemoryMapping shared_memory_mapping_;
   gfx::GenericSharedMemoryId shared_memory_id_;
 
   DISALLOW_COPY_AND_ASSIGN(GLImageSharedMemory);

ui/gl/gl_image_shared_memory_unittest.cc

@@ -5,7 +5,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include "base/memory/shared_memory.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -23,19 +22,21 @@ class GLImageSharedMemoryTestDelegate : public GLImageTestDelegateBase {
   scoped_refptr<GLImage> CreateSolidColorImage(const gfx::Size& size,
                                                const uint8_t color[4]) const {
     DCHECK_EQ(NumberOfPlanesForBufferFormat(format), 1u);
-    base::SharedMemory shared_memory;
-    bool rv = shared_memory.CreateAndMapAnonymous(
-        gfx::BufferSizeForBufferFormat(size, format));
-    DCHECK(rv);
+    base::UnsafeSharedMemoryRegion shared_memory_region =
+        base::UnsafeSharedMemoryRegion::Create(
+            gfx::BufferSizeForBufferFormat(size, format));
+    base::WritableSharedMemoryMapping shared_memory_mapping =
+        shared_memory_region.Map();
+    DCHECK(shared_memory_mapping.IsValid());
+
     GLImageTestSupport::SetBufferDataToColor(
         size.width(), size.height(),
         static_cast<int>(RowSizeForBufferFormat(size.width(), format, 0)), 0,
-        format, color, static_cast<uint8_t*>(shared_memory.memory()));
+        format, color, static_cast<uint8_t*>(shared_memory_mapping.memory()));
     scoped_refptr<GLImageSharedMemory> image(new GLImageSharedMemory(
         size, GLImageMemory::GetInternalFormatForTesting(format)));
-    rv = image->Initialize(
-        base::SharedMemory::DuplicateHandle(shared_memory.handle()),
-        gfx::GenericSharedMemoryId(0), format, 0,
+    bool rv = image->Initialize(
+        shared_memory_region, gfx::GenericSharedMemoryId(0), format, 0,
         gfx::RowSizeForBufferFormat(size.width(), format, 0));
     EXPECT_TRUE(rv);
     return image;
@@ -87,23 +88,24 @@ class GLImageSharedMemoryPoolTestDelegate : public GLImageTestDelegateBase {
                     2;
     size_t pool_size =
         stride * size.height() + base::SysInfo::VMAllocationGranularity() * 3;
-    base::SharedMemory shared_memory;
-    bool rv = shared_memory.CreateAndMapAnonymous(pool_size);
-    DCHECK(rv);
+    base::UnsafeSharedMemoryRegion shared_memory_region =
+        base::UnsafeSharedMemoryRegion::Create(pool_size);
+    base::WritableSharedMemoryMapping shared_memory_mapping =
+        shared_memory_region.Map();
+    DCHECK(shared_memory_mapping.IsValid());
     // Initialize memory to a value that is easy to recognize if test fails.
-    memset(shared_memory.memory(), 0x55, pool_size);
+    memset(shared_memory_mapping.memory(), 0x55, pool_size);
     // Place buffer at a non-zero non-page-aligned offset in shared memory.
     size_t buffer_offset = 3 * base::SysInfo::VMAllocationGranularity() / 2;
     GLImageTestSupport::SetBufferDataToColor(
         size.width(), size.height(), static_cast<int>(stride), 0,
         gfx::BufferFormat::RGBA_8888, color,
-        static_cast<uint8_t*>(shared_memory.memory()) + buffer_offset);
+        static_cast<uint8_t*>(shared_memory_mapping.memory()) + buffer_offset);
     scoped_refptr<GLImageSharedMemory> image(
         new GLImageSharedMemory(size, GL_RGBA));
-    rv = image->Initialize(
-        base::SharedMemory::DuplicateHandle(shared_memory.handle()),
-        gfx::GenericSharedMemoryId(0), gfx::BufferFormat::RGBA_8888,
-        buffer_offset, stride);
+    bool rv =
+        image->Initialize(shared_memory_region, gfx::GenericSharedMemoryId(0),
+                          gfx::BufferFormat::RGBA_8888, buffer_offset, stride);
     EXPECT_TRUE(rv);
     return image;
   }