[//gpu] Remove SharedImageMapping and API creating it

All clients have been converted to use MappableSharedImage via
SII::CreateSharedImageForSoftwareCompositor().

Bug: 40064122
Change-Id: I7fce0ffcc57da9eb56e2fd0b6d18cb242bf7a43d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6172458
Commit-Queue: Colin Blundell <blundell@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1407269}

cc/test/test_client_shared_image_interface.cc

@@ -39,12 +39,6 @@ gpu::SyncToken TestClientSharedImageInterface::GenVerifiedSyncToken() {
   return shared_image_interface_->GenVerifiedSyncToken();
 }
 
-gpu::SharedImageInterface::SharedImageMapping
-TestClientSharedImageInterface::CreateSharedImage(
-    const gpu::SharedImageInfo& si_info) {
-  return shared_image_interface_->CreateSharedImage(si_info);
-}
-
 scoped_refptr<gpu::ClientSharedImage>
 TestClientSharedImageInterface::CreateSharedImageForSoftwareCompositor(
     const gpu::SharedImageInfo& si_info) {

cc/test/test_client_shared_image_interface.h

@@ -27,8 +27,6 @@ class TestClientSharedImageInterface : public gpu::ClientSharedImageInterface {
       scoped_refptr<gpu::SharedImageInterface> shared_image_interface);
   gpu::SyncToken GenVerifiedSyncToken() override;
 
-  gpu::SharedImageInterface::SharedImageMapping CreateSharedImage(
-      const gpu::SharedImageInfo& si_info) override;
   scoped_refptr<gpu::ClientSharedImage> CreateSharedImageForSoftwareCompositor(
       const gpu::SharedImageInfo& si_info) override;
 

gpu/command_buffer/client/shared_image_interface.cc

@@ -191,18 +191,6 @@ void SharedImageInterface::DestroySharedImagePool(
   NOTREACHED();
 }
 
-SharedImageInterface::SharedImageMapping::SharedImageMapping() = default;
-SharedImageInterface::SharedImageMapping::SharedImageMapping(
-    SharedImageInterface::SharedImageMapping&& mapped) = default;
-SharedImageInterface::SharedImageMapping::SharedImageMapping(
-    scoped_refptr<ClientSharedImage> shared_image,
-    base::WritableSharedMemoryMapping mapping)
-    : shared_image(std::move(shared_image)), mapping(std::move(mapping)) {}
-SharedImageInterface::SharedImageMapping&
-SharedImageInterface::SharedImageMapping::operator=(
-    SharedImageInterface::SharedImageMapping&& mapped) = default;
-SharedImageInterface::SharedImageMapping::~SharedImageMapping() = default;
-
 SharedImageInterfaceHolder::SharedImageInterfaceHolder(
     SharedImageInterface* sii)
     : sii_(sii) {}

gpu/command_buffer/client/shared_image_interface.h

@@ -179,27 +179,6 @@ class GPU_EXPORT SharedImageInterface
       const SharedImageInfo& si_info,
       gfx::GpuMemoryBufferHandle buffer_handle) = 0;
 
-  struct GPU_EXPORT SharedImageMapping {
-    SharedImageMapping(SharedImageMapping& mapped) = delete;
-    SharedImageMapping& operator=(SharedImageMapping& mapped) = delete;
-    SharedImageMapping();
-    SharedImageMapping(SharedImageMapping&& mapped);
-    SharedImageMapping(scoped_refptr<ClientSharedImage> shared_image,
-                       base::WritableSharedMemoryMapping mapping);
-    SharedImageMapping& operator=(SharedImageMapping&& mapped);
-    ~SharedImageMapping();
-
-    scoped_refptr<ClientSharedImage> shared_image;
-    base::WritableSharedMemoryMapping mapping;
-  };
-
-  // Creates a shared image with the usage of
-  // gpu::SHARED_IMAGE_USAGE_CPU_WRITE_ONLY only. A shared memory buffer is
-  // created internally and a shared image is created out this buffer. This
-  // method is used by the software compositor only.
-  virtual SharedImageMapping CreateSharedImage(
-      const SharedImageInfo& si_info) = 0;
-
   // Creates a shared image with the usage of
   // gpu::SHARED_IMAGE_USAGE_CPU_WRITE_ONLY only. A shared memory buffer is
   // created internally and a shared image is created out of this buffer. This

gpu/command_buffer/client/test_shared_image_interface.cc

@@ -293,24 +293,6 @@ TestSharedImageInterface::CreateSharedImage(
       mailbox, si_info.meta, sync_token, holder_, buffer_handle.type);
 }
 
-SharedImageInterface::SharedImageMapping
-TestSharedImageInterface::CreateSharedImage(
-    const SharedImageInfo& si_info) {
-  base::WritableSharedMemoryMapping mapping;
-  gfx::GpuMemoryBufferHandle handle;
-  CreateSharedMemoryRegionFromSIInfo(si_info, mapping, handle);
-
-  auto mailbox = Mailbox::Generate();
-  shared_images_.insert(mailbox);
-  most_recent_size_ = si_info.meta.size;
-
-  SharedImageInterface::SharedImageMapping shared_image_mapping;
-  shared_image_mapping.mapping = std::move(mapping);
-  shared_image_mapping.shared_image = base::MakeRefCounted<ClientSharedImage>(
-      mailbox, si_info.meta, GenUnverifiedSyncToken(), holder_, handle.type);
-  return shared_image_mapping;
-}
-
 scoped_refptr<ClientSharedImage>
 TestSharedImageInterface::CreateSharedImageForSoftwareCompositor(
     const SharedImageInfo& si_info) {

gpu/command_buffer/client/test_shared_image_interface.h

@@ -59,9 +59,6 @@ class TestSharedImageInterface : public SharedImageInterface {
       const SharedImageInfo& si_info,
       gfx::GpuMemoryBufferHandle buffer_handle) override;
 
-  SharedImageInterface::SharedImageMapping CreateSharedImage(
-      const SharedImageInfo& si_info) override;
-
   scoped_refptr<ClientSharedImage> CreateSharedImageForSoftwareCompositor(
       const SharedImageInfo& si_info) override;
 

gpu/command_buffer/service/shared_image_interface_in_process.cc

@@ -489,36 +489,6 @@ SharedImageInterfaceInProcess::CreateSharedImage(
       mailbox, si_info.meta, GenUnverifiedSyncToken(), holder_, gmb_type);
 }
 
-SharedImageInterface::SharedImageMapping
-SharedImageInterfaceInProcess::CreateSharedImage(
-    const SharedImageInfo& si_info) {
-  base::WritableSharedMemoryMapping mapping;
-  gfx::GpuMemoryBufferHandle handle;
-  CreateSharedMemoryRegionFromSIInfo(si_info, mapping, handle);
-
-  auto mailbox = Mailbox::Generate();
-  {
-    base::AutoLock lock(lock_);
-    SyncToken sync_token = MakeSyncToken(next_fence_sync_release_++);
-    // Note: we enqueue the task under the lock to guarantee monotonicity of
-    // the release ids as seen by the service. Unretained is safe because
-    // InProcessCommandBuffer synchronizes with the GPU thread at destruction
-    // time, cancelling tasks, before |this| is destroyed.
-    ScheduleGpuTask(base::BindOnce(&SharedImageInterfaceInProcess::
-                                       CreateSharedImageWithBufferOnGpuThread,
-                                   base::Unretained(this), mailbox, si_info,
-                                   std::move(handle)),
-                    /*sync_token_fences=*/{}, sync_token);
-  }
-  SharedImageInterface::SharedImageMapping shared_image_mapping;
-  shared_image_mapping.mapping = std::move(mapping);
-  shared_image_mapping.shared_image = base::MakeRefCounted<ClientSharedImage>(
-      mailbox, si_info.meta, GenUnverifiedSyncToken(), holder_,
-      gfx::SHARED_MEMORY_BUFFER);
-
-  return shared_image_mapping;
-}
-
 scoped_refptr<ClientSharedImage>
 SharedImageInterfaceInProcess::CreateSharedImageForSoftwareCompositor(
     const SharedImageInfo& si_info) {

gpu/command_buffer/service/shared_image_interface_in_process.h

@@ -94,8 +94,6 @@ class GPU_GLES2_EXPORT SharedImageInterfaceInProcess
   scoped_refptr<ClientSharedImage> CreateSharedImage(
       const SharedImageInfo& si_info,
       gfx::GpuMemoryBufferHandle buffer_handle) override;
-  SharedImageInterface::SharedImageMapping CreateSharedImage(
-      const SharedImageInfo& si_info) override;
   scoped_refptr<ClientSharedImage> CreateSharedImageForSoftwareCompositor(
       const SharedImageInfo& si_info) override;
   void UpdateSharedImage(const SyncToken& sync_token,

gpu/ipc/client/client_shared_image_interface.cc

@@ -205,23 +205,6 @@ scoped_refptr<ClientSharedImage> ClientSharedImageInterface::CreateSharedImage(
       buffer_handle_type);
 }
 
-SharedImageInterface::SharedImageMapping
-ClientSharedImageInterface::CreateSharedImage(const SharedImageInfo& si_info) {
-  base::WritableSharedMemoryMapping mapping;
-  gfx::GpuMemoryBufferHandle handle;
-  CreateSharedMemoryRegionFromSIInfo(si_info, mapping, handle);
-
-  auto mailbox = proxy_->CreateSharedImage(si_info, std::move(handle));
-
-  SharedImageInterface::SharedImageMapping shared_image_mapping;
-  shared_image_mapping.mapping = std::move(mapping);
-  shared_image_mapping.shared_image = base::MakeRefCounted<ClientSharedImage>(
-      AddMailbox(mailbox), si_info.meta, GenUnverifiedSyncToken(), holder_,
-      gfx::SHARED_MEMORY_BUFFER);
-
-  return shared_image_mapping;
-}
-
 scoped_refptr<ClientSharedImage>
 ClientSharedImageInterface::CreateSharedImageForSoftwareCompositor(
     const SharedImageInfo& si_info) {

gpu/ipc/client/client_shared_image_interface.h

@@ -74,8 +74,6 @@ class GPU_EXPORT ClientSharedImageInterface : public SharedImageInterface {
   // Used by the software compositor only. |usage| must be
   // gpu::SHARED_IMAGE_USAGE_CPU_WRITE_ONLY. Call client_shared_image->Map()
   // later to get the shared memory mapping.
-  SharedImageInterface::SharedImageMapping CreateSharedImage(
-      const SharedImageInfo& si_info) override;
   scoped_refptr<ClientSharedImage> CreateSharedImageForSoftwareCompositor(
       const SharedImageInfo& si_info) override;
   void CopyToGpuMemoryBuffer(const SyncToken& sync_token,

gpu/ipc/service/gpu_channel_shared_image_interface.cc

@@ -382,30 +382,6 @@ GpuChannelSharedImageInterface::CreateSharedImage(
   return base::MakeRefCounted<ClientSharedImage>(
       mailbox, si_info.meta, GenVerifiedSyncToken(), holder_, gmb_type);
 }
-SharedImageInterface::SharedImageMapping
-GpuChannelSharedImageInterface::CreateSharedImage(
-    const SharedImageInfo& si_info) {
-  base::WritableSharedMemoryMapping mapping;
-  gfx::GpuMemoryBufferHandle handle;
-  CreateSharedMemoryRegionFromSIInfo(si_info, mapping, handle);
-
-  auto mailbox = Mailbox::Generate();
-  {
-    base::AutoLock lock(lock_);
-    ScheduleGpuTask(base::BindOnce(&GpuChannelSharedImageInterface::
-                                       CreateSharedImageWithBufferOnGpuThread,
-                                   this, mailbox, si_info, std::move(handle)),
-                    /*sync_token_fences=*/{},
-                    MakeSyncToken(next_fence_sync_release_++));
-  }
-  SharedImageInterface::SharedImageMapping shared_image_mapping;
-  shared_image_mapping.mapping = std::move(mapping);
-  shared_image_mapping.shared_image = base::MakeRefCounted<ClientSharedImage>(
-      mailbox, si_info.meta, GenVerifiedSyncToken(), holder_,
-      gfx::SHARED_MEMORY_BUFFER);
-
-  return shared_image_mapping;
-}
 
 scoped_refptr<ClientSharedImage>
 GpuChannelSharedImageInterface::CreateSharedImageForSoftwareCompositor(

gpu/ipc/service/gpu_channel_shared_image_interface.h

@@ -69,8 +69,6 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelSharedImageInterface
   scoped_refptr<ClientSharedImage> CreateSharedImage(
       const SharedImageInfo& si_info,
       gfx::GpuMemoryBufferHandle buffer_handle) override;
-  SharedImageInterface::SharedImageMapping CreateSharedImage(
-      const SharedImageInfo& si_info) override;
   scoped_refptr<ClientSharedImage> CreateSharedImageForSoftwareCompositor(
       const SharedImageInfo& si_info) override;
   void UpdateSharedImage(const SyncToken& sync_token,

media/mojo/clients/mojo_stable_video_decoder_unittest.cc

@@ -353,8 +353,6 @@ class MockSharedImageInterface : public gpu::SharedImageInterface {
                scoped_refptr<gpu::ClientSharedImage>(
                    const gpu::SharedImageInfo& si_info,
                    gfx::GpuMemoryBufferHandle buffer_handle));
-  MOCK_METHOD1(CreateSharedImage,
-               SharedImageMapping(const gpu::SharedImageInfo& si_info));
   MOCK_METHOD1(CreateSharedImageForSoftwareCompositor,
                scoped_refptr<gpu::ClientSharedImage>(
                    const gpu::SharedImageInfo& si_info));