Revert "VulkanImage: support create from GpuMemoryBufferHandle on Android"

This reverts commit 838eb034.

Reason for revert: Build failure on android-archive-rel:
https://ci.chromium.org/p/chromium/builders/ci/android-archive-rel/10360

Original change's description:
> VulkanImage: support create from GpuMemoryBufferHandle on Android
> 
> VulkanImage::CreateFromGpuMemoryBufferHandle() is added to replace
> VulkanImplementation::CreateVkImageAndImportAHB(), and will replace
> VulkanImplementation::CreateImageFromGpuMemoryHandle() as well.
> 
> Bug: None
> Change-Id: I7c6e3cea685f1ec305790f4a6d7bb66164f26e55
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2114587
> Commit-Queue: Peng Huang <penghuang@chromium.org>
> Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
> Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#753394}

TBR=penghuang@chromium.org,rjkroege@chromium.org,vasilyt@chromium.org

Change-Id: I08dcc519da5e693fc08e0323036dc691b6eaff7d
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: None
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2121418Reviewed-by: Thomas Anderson <thomasanderson@chromium.org>
Commit-Queue: Thomas Anderson <thomasanderson@chromium.org>
Cr-Commit-Position: refs/heads/master@{#753429}

android_webview/browser/gfx/aw_draw_fn_impl.cc

@@ -19,7 +19,6 @@
 #include "gpu/ipc/common/android/android_image_reader_utils.h"
 #include "gpu/vulkan/vulkan_fence_helper.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
-#include "gpu/vulkan/vulkan_image.h"
 #include "gpu/vulkan/vulkan_implementation.h"
 #include "third_party/skia/include/gpu/GrBackendSemaphore.h"
 #include "third_party/skia/include/gpu/GrContext.h"
@@ -27,7 +26,6 @@
 #include "third_party/skia/include/gpu/vk/GrVkExtensions.h"
 #include "third_party/skia/src/gpu/vk/GrVkSecondaryCBDrawContext.h"
 #include "ui/gfx/color_space.h"
-#include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context_egl.h"
 #include "ui/gl/gl_image_ahardwarebuffer.h"
@@ -464,29 +462,32 @@ void AwDrawFnImpl::DrawVkInterop(AwDrawFn_DrawVkParams* params) {
   }
 
   // Create a VkImage and import AHB.
-  if (!pending_draw->vulkan_image) {
-    auto handle = base::android::ScopedHardwareBufferHandle::Create(
-        pending_draw->ahb_image->GetAHardwareBuffer()->buffer());
-    gfx::GpuMemoryBufferHandle gmb_handle(std::move(handle));
-    auto* device_queue = vulkan_context_provider_->GetDeviceQueue();
-    auto vulkan_image = gpu::VulkanImage::CreateFromGpuMemoryBufferHandle(
-        device_queue, std::move(gmb_handle),
-        gfx::Size(params->width, params->height), VK_FORMAT_R8G8B8A8_UNORM,
-        0 /* usage */);
-    if (!vulkan_image) {
+  if (!pending_draw->image_info.fImage) {
+    VkImage vk_image;
+    VkImageCreateInfo vk_image_info;
+    VkDeviceMemory vk_device_memory;
+    VkDeviceSize mem_allocation_size;
+    if (!vulkan_context_provider_->implementation()->CreateVkImageAndImportAHB(
+            vulkan_context_provider_->device(),
+            vulkan_context_provider_->physical_device(),
+            gfx::Size(params->width, params->height),
+            base::android::ScopedHardwareBufferHandle::Create(
+                pending_draw->ahb_image->GetAHardwareBuffer()->buffer()),
+            &vk_image, &vk_image_info, &vk_device_memory,
+            &mem_allocation_size)) {
       LOG(ERROR) << "Could not create VkImage from AHB.";
       return;
     }
 
     // Create backend texture from the VkImage.
-    GrVkAlloc alloc(vulkan_image->device_memory(), 0 /* offset */,
-                    vulkan_image->device_size(), 0 /* flags */);
-    pending_draw->image_info = GrVkImageInfo(
-        vulkan_image->image(), alloc, vulkan_image->image_tiling(),
-        VK_IMAGE_LAYOUT_UNDEFINED, vulkan_image->format(), 1 /* levelCount */,
-        VK_QUEUE_FAMILY_EXTERNAL);
-
-    pending_draw->vulkan_image = std::move(vulkan_image);
+    GrVkAlloc alloc = {vk_device_memory, 0, mem_allocation_size, 0};
+    pending_draw->image_info = {vk_image,
+                                alloc,
+                                vk_image_info.tiling,
+                                vk_image_info.initialLayout,
+                                vk_image_info.format,
+                                vk_image_info.mipLevels,
+                                VK_QUEUE_FAMILY_EXTERNAL};
   }
 
   // Create an SkImage from AHB.
@@ -654,10 +655,11 @@ AwDrawFnImpl::InFlightInteropDraw::~InFlightInteropDraw() {
     glDeleteTextures(1, &texture_id);
   if (framebuffer_id)
     glDeleteFramebuffersEXT(1, &framebuffer_id);
-  if (vulkan_image) {
+  if (image_info.fImage != VK_NULL_HANDLE) {
     vk_context_provider->GetDeviceQueue()
         ->GetFenceHelper()
-        ->EnqueueVulkanObjectCleanupForSubmittedWork(std::move(vulkan_image));
+        ->EnqueueImageCleanupForSubmittedWork(image_info.fImage,
+                                              image_info.fAlloc.fMemory);
   }
 }
 

android_webview/browser/gfx/aw_draw_fn_impl.h

@@ -25,10 +25,6 @@ namespace gl {
 class GLImageAHardwareBuffer;
 }
 
-namespace gpu {
-class VulkanImage;
-}
-
 namespace android_webview {
 class GLNonOwnedCompatibilityContext;
 
@@ -78,7 +74,6 @@ class AwDrawFnImpl {
     sk_sp<SkImage> ahb_skimage;
     uint32_t texture_id = 0;
     uint32_t framebuffer_id = 0;
-    std::unique_ptr<gpu::VulkanImage> vulkan_image;
     GrVkImageInfo image_info;
 
     // Used to clean up Vulkan objects.

gpu/command_buffer/service/shared_image_backing_factory_ahardwarebuffer.cc

@@ -38,7 +38,6 @@
 #include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_fence_helper.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
-#include "gpu/vulkan/vulkan_image.h"
 #include "gpu/vulkan/vulkan_implementation.h"
 #include "gpu/vulkan/vulkan_util.h"
 #include "third_party/skia/include/core/SkPromiseImageTexture.h"
@@ -57,6 +56,66 @@
 namespace gpu {
 namespace {
 
+sk_sp<SkPromiseImageTexture> CreatePromiseTextureAHB(
+    viz::VulkanContextProvider* context_provider,
+    base::android::ScopedHardwareBufferHandle ahb_handle,
+    gfx::Size size,
+    viz::ResourceFormat format) {
+  VulkanImplementation* vk_implementation =
+      context_provider->GetVulkanImplementation();
+  VkDevice vk_device = context_provider->GetDeviceQueue()->GetVulkanDevice();
+  VkPhysicalDevice vk_physical_device =
+      context_provider->GetDeviceQueue()->GetVulkanPhysicalDevice();
+
+  // Create a VkImage and import AHB.
+  VkImage vk_image;
+  VkImageCreateInfo vk_image_info;
+  VkDeviceMemory vk_device_memory;
+  VkDeviceSize mem_allocation_size;
+  if (!vk_implementation->CreateVkImageAndImportAHB(
+          vk_device, vk_physical_device, size, std::move(ahb_handle), &vk_image,
+          &vk_image_info, &vk_device_memory, &mem_allocation_size)) {
+    return nullptr;
+  }
+
+  // Create backend texture from the VkImage.
+  GrVkAlloc alloc = {vk_device_memory, 0, mem_allocation_size, 0};
+  GrVkImageInfo vk_info = {vk_image,
+                           alloc,
+                           vk_image_info.tiling,
+                           vk_image_info.initialLayout,
+                           vk_image_info.format,
+                           vk_image_info.mipLevels,
+                           VK_QUEUE_FAMILY_EXTERNAL};
+  // TODO(bsalomon): Determine whether it makes sense to attempt to reuse this
+  // if the vk_info stays the same on subsequent calls.
+  auto promise_texture = SkPromiseImageTexture::Make(
+      GrBackendTexture(size.width(), size.height(), vk_info));
+  if (!promise_texture) {
+    vkDestroyImage(vk_device, vk_image, nullptr);
+    vkFreeMemory(vk_device, vk_device_memory, nullptr);
+    return nullptr;
+  }
+
+  return promise_texture;
+}
+
+void DestroyVkPromiseTextureAHB(viz::VulkanContextProvider* context_provider,
+                                sk_sp<SkPromiseImageTexture> promise_texture) {
+  DCHECK(promise_texture);
+  DCHECK(promise_texture->unique());
+
+  GrVkImageInfo vk_image_info;
+  bool result =
+      promise_texture->backendTexture().getVkImageInfo(&vk_image_info);
+  DCHECK(result);
+
+  VulkanFenceHelper* fence_helper =
+      context_provider->GetDeviceQueue()->GetFenceHelper();
+  fence_helper->EnqueueImageCleanupForSubmittedWork(
+      vk_image_info.fImage, vk_image_info.fAlloc.fMemory);
+}
+
 class OverlayImage final : public gl::GLImage {
  public:
   explicit OverlayImage(AHardwareBuffer* buffer)
@@ -269,38 +328,21 @@ class SharedImageRepresentationSkiaVkAHB
       SharedImageManager* manager,
       SharedImageBacking* backing,
       scoped_refptr<SharedContextState> context_state,
-      std::unique_ptr<VulkanImage> vulkan_image,
+      sk_sp<SkPromiseImageTexture> promise_texture,
       MemoryTypeTracker* tracker)
       : SharedImageRepresentationSkia(manager, backing, tracker),
-        vulkan_image_(std::move(vulkan_image)),
+        promise_texture_(std::move(promise_texture)),
         context_state_(std::move(context_state)) {
-    DCHECK(vulkan_image_);
+    DCHECK(promise_texture_);
     DCHECK(context_state_);
     DCHECK(context_state_->vk_context_provider());
-    // Create backend texture from the VkImage.
-    GrVkAlloc alloc(vulkan_image_->device_memory(), 0 /* offset */,
-                    vulkan_image_->device_size(), 0 /* flags */);
-    GrVkImageInfo vk_info(vulkan_image_->image(), alloc,
-                          vulkan_image_->image_tiling(),
-                          VK_IMAGE_LAYOUT_UNDEFINED, vulkan_image_->format(),
-                          1 /* levelCount */, VK_QUEUE_FAMILY_EXTERNAL);
-
-    // TODO(bsalomon): Determine whether it makes sense to attempt to reuse this
-    // if the vk_info stays the same on subsequent calls.
-    promise_texture_ = SkPromiseImageTexture::Make(
-        GrBackendTexture(size().width(), size().height(), vk_info));
-    DCHECK(promise_texture_);
   }
 
   ~SharedImageRepresentationSkiaVkAHB() override {
+    DestroyVkPromiseTextureAHB(context_state_->vk_context_provider(),
+                               std::move(promise_texture_));
     DCHECK_EQ(mode_, RepresentationAccessMode::kNone);
     DCHECK(!surface_);
-    DCHECK(vulkan_image_);
-    VulkanFenceHelper* fence_helper = context_state_->vk_context_provider()
-                                          ->GetDeviceQueue()
-                                          ->GetFenceHelper();
-    fence_helper->EnqueueVulkanObjectCleanupForSubmittedWork(
-        std::move(vulkan_image_));
   }
 
   sk_sp<SkSurface> BeginWriteAccess(
@@ -453,7 +495,6 @@ class SharedImageRepresentationSkiaVkAHB
     mode_ = RepresentationAccessMode::kNone;
   }
 
-  std::unique_ptr<VulkanImage> vulkan_image_;
   sk_sp<SkPromiseImageTexture> promise_texture_;
   RepresentationAccessMode mode_ = RepresentationAccessMode::kNone;
   SkSurface* surface_ = nullptr;
@@ -609,16 +650,12 @@ SharedImageBackingAHB::ProduceSkia(
   // Check whether we are in Vulkan mode OR GL mode and accordingly create
   // Skia representation.
   if (context_state->GrContextIsVulkan()) {
-    auto* device_queue = context_state->vk_context_provider()->GetDeviceQueue();
-    gfx::GpuMemoryBufferHandle gmb_handle(GetAhbHandle());
-    auto vulkan_image = VulkanImage::CreateFromGpuMemoryBufferHandle(
-        device_queue, std::move(gmb_handle), size(), ToVkFormat(format()),
-        0 /* usage */);
-    if (!vulkan_image)
+    sk_sp<SkPromiseImageTexture> promise_texture = CreatePromiseTextureAHB(
+        context_state->vk_context_provider(), GetAhbHandle(), size(), format());
+    if (!promise_texture)
       return nullptr;
-
     return std::make_unique<SharedImageRepresentationSkiaVkAHB>(
-        manager, this, std::move(context_state), std::move(vulkan_image),
+        manager, this, std::move(context_state), std::move(promise_texture),
         tracker);
   }
   DCHECK(context_state->GrContextIsGL());

gpu/command_buffer/service/shared_image_video.cc

@@ -24,7 +24,6 @@
 #include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_fence_helper.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
-#include "gpu/vulkan/vulkan_image.h"
 #include "gpu/vulkan/vulkan_implementation.h"
 #include "gpu/vulkan/vulkan_util.h"
 #include "third_party/skia/include/core/SkPromiseImageTexture.h"
@@ -33,6 +32,88 @@
 
 namespace gpu {
 
+namespace {
+sk_sp<SkPromiseImageTexture> CreatePromiseTextureVideo(
+    viz::VulkanContextProvider* context_provider,
+    base::android::ScopedHardwareBufferHandle ahb_handle,
+    gfx::Size size,
+    viz::ResourceFormat format) {
+  VulkanImplementation* vk_implementation =
+      context_provider->GetVulkanImplementation();
+  VkDevice vk_device = context_provider->GetDeviceQueue()->GetVulkanDevice();
+  VkPhysicalDevice vk_physical_device =
+      context_provider->GetDeviceQueue()->GetVulkanPhysicalDevice();
+
+  // Create a VkImage and import AHB.
+  VkImage vk_image;
+  VkImageCreateInfo vk_image_info;
+  VkDeviceMemory vk_device_memory;
+  VkDeviceSize mem_allocation_size;
+  VulkanYCbCrInfo ycbcr_info;
+  if (!vk_implementation->CreateVkImageAndImportAHB(
+          vk_device, vk_physical_device, size, std::move(ahb_handle), &vk_image,
+          &vk_image_info, &vk_device_memory, &mem_allocation_size,
+          &ycbcr_info)) {
+    return nullptr;
+  }
+
+  // We always use VK_IMAGE_TILING_OPTIMAL while creating the vk image in
+  // VulkanImplementationAndroid::CreateVkImageAndImportAHB. Hence pass the
+  // tiling parameter as VK_IMAGE_TILING_OPTIMAL to below call rather than
+  // passing |vk_image_info.tiling|. This is also to ensure that the promise
+  // image created here at [1] as well the fullfil image created via the current
+  // function call are consistent and both are using VK_IMAGE_TILING_OPTIMAL.
+  // [1] -
+  // https://cs.chromium.org/chromium/src/components/viz/service/display_embedder/skia_output_surface_impl.cc?rcl=db5ffd448ba5d66d9d3c5c099754e5067c752465&l=789.
+  DCHECK_EQ(static_cast<int32_t>(vk_image_info.tiling),
+            static_cast<int32_t>(VK_IMAGE_TILING_OPTIMAL));
+  GrVkYcbcrConversionInfo gr_ycbcr_info = CreateGrVkYcbcrConversionInfo(
+      vk_physical_device, VK_IMAGE_TILING_OPTIMAL, ycbcr_info);
+
+  // Create backend texture from the VkImage.
+  GrVkAlloc alloc = {vk_device_memory, 0, mem_allocation_size, 0};
+  GrVkImageInfo vk_info = {vk_image,
+                           alloc,
+                           vk_image_info.tiling,
+                           vk_image_info.initialLayout,
+                           vk_image_info.format,
+                           vk_image_info.mipLevels,
+                           VK_QUEUE_FAMILY_EXTERNAL,
+                           GrProtected::kNo,
+                           gr_ycbcr_info};
+
+  // TODO(bsalomon): Determine whether it makes sense to attempt to reuse this
+  // if the vk_info stays the same on subsequent calls.
+  auto promise_texture = SkPromiseImageTexture::Make(
+      GrBackendTexture(size.width(), size.height(), vk_info));
+  if (!promise_texture) {
+    vkDestroyImage(vk_device, vk_image, nullptr);
+    vkFreeMemory(vk_device, vk_device_memory, nullptr);
+    return nullptr;
+  }
+
+  return promise_texture;
+}
+
+void DestroyVkPromiseTextureVideo(
+    viz::VulkanContextProvider* context_provider,
+    sk_sp<SkPromiseImageTexture> promise_texture) {
+  DCHECK(promise_texture);
+  DCHECK(promise_texture->unique());
+
+  GrVkImageInfo vk_image_info;
+  bool result =
+      promise_texture->backendTexture().getVkImageInfo(&vk_image_info);
+  DCHECK(result);
+
+  VulkanFenceHelper* fence_helper =
+      context_provider->GetDeviceQueue()->GetFenceHelper();
+  fence_helper->EnqueueImageCleanupForSubmittedWork(
+      vk_image_info.fImage, vk_image_info.fAlloc.fMemory);
+}
+
+}  // namespace
+
 SharedImageVideo::SharedImageVideo(
     const Mailbox& mailbox,
     const gfx::Size& size,
@@ -218,13 +299,10 @@ class SharedImageRepresentationVideoSkiaVk
     DCHECK(end_access_semaphore_ == VK_NULL_HANDLE);
 
     // |promise_texture_| could be null if we never being read.
-    if (!vulkan_image_)
+    if (!promise_texture_)
       return;
-    VulkanFenceHelper* fence_helper = context_state_->vk_context_provider()
-                                          ->GetDeviceQueue()
-                                          ->GetFenceHelper();
-    fence_helper->EnqueueVulkanObjectCleanupForSubmittedWork(
-        std::move(vulkan_image_));
+    DestroyVkPromiseTextureVideo(context_state_->vk_context_provider(),
+                                 std::move(promise_texture_));
   }
 
   sk_sp<SkSurface> BeginWriteAccess(
@@ -264,46 +342,11 @@ class SharedImageRepresentationVideoSkiaVk
       return nullptr;
     }
 
-    if (!vulkan_image_) {
-      DCHECK(!promise_texture_);
-      gfx::GpuMemoryBufferHandle gmb_handle(
-          scoped_hardware_buffer_->TakeBuffer());
-      auto* device_queue =
-          context_state_->vk_context_provider()->GetDeviceQueue();
-      vulkan_image_ = VulkanImage::CreateFromGpuMemoryBufferHandle(
-          device_queue, std::move(gmb_handle), size(), ToVkFormat(format()),
-          0 /* usage */);
-      if (!vulkan_image_)
-        return nullptr;
-
-      // We always use VK_IMAGE_TILING_OPTIMAL while creating the vk image in
-      // VulkanImplementationAndroid::CreateVkImageAndImportAHB. Hence pass the
-      // tiling parameter as VK_IMAGE_TILING_OPTIMAL to below call rather than
-      // passing |vk_image_info.tiling|. This is also to ensure that the promise
-      // image created here at [1] as well the fullfil image created via the
-      // current function call are consistent and both are using
-      // VK_IMAGE_TILING_OPTIMAL. [1] -
-      // https://cs.chromium.org/chromium/src/components/viz/service/display_embedder/skia_output_surface_impl.cc?rcl=db5ffd448ba5d66d9d3c5c099754e5067c752465&l=789.
-      DCHECK_EQ(static_cast<int32_t>(vulkan_image_->image_tiling()),
-                static_cast<int32_t>(VK_IMAGE_TILING_OPTIMAL));
-
-      GrVkYcbcrConversionInfo gr_ycbcr_info = CreateGrVkYcbcrConversionInfo(
-          device_queue->GetVulkanPhysicalDevice(), VK_IMAGE_TILING_OPTIMAL,
-          vulkan_image_->ycbcr_info());
-      // Create backend texture from the VkImage.
-      GrVkAlloc alloc(vulkan_image_->device_memory(), 0 /* offset */,
-                      vulkan_image_->device_size(), 0 /* flags */);
-      GrVkImageInfo vk_info(vulkan_image_->image(), alloc,
-                            vulkan_image_->image_tiling(),
-                            VK_IMAGE_LAYOUT_UNDEFINED, vulkan_image_->format(),
-                            1 /* levelCount */, VK_QUEUE_FAMILY_EXTERNAL,
-                            GrProtected::kNo, gr_ycbcr_info);
-
-      // TODO(bsalomon): Determine whether it makes sense to attempt to reuse
-      // this if the vk_info stays the same on subsequent calls.
-      promise_texture_ = SkPromiseImageTexture::Make(
-          GrBackendTexture(size().width(), size().height(), vk_info));
-      DCHECK(promise_texture_);
+    if (!promise_texture_) {
+      // Create the promise texture.
+      promise_texture_ = CreatePromiseTextureVideo(
+          context_state_->vk_context_provider(),
+          scoped_hardware_buffer_->TakeBuffer(), size(), format());
     }
     return promise_texture_;
   }
@@ -384,7 +427,6 @@ class SharedImageRepresentationVideoSkiaVk
         ->GetFenceHelper();
   }
 
-  std::unique_ptr<VulkanImage> vulkan_image_;
   sk_sp<SkPromiseImageTexture> promise_texture_;
   scoped_refptr<SharedContextState> context_state_;
   std::unique_ptr<base::android::ScopedHardwareBufferFenceSync>

gpu/vulkan/android/vulkan_android_unittests.cc

@@ -9,7 +9,6 @@
 #include "components/viz/common/gpu/vulkan_in_process_context_provider.h"
 #include "gpu/vulkan/android/vulkan_implementation_android.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
-#include "gpu/vulkan/vulkan_image.h"
 #include "gpu/vulkan/vulkan_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -128,15 +127,18 @@ TEST_F(VulkanImplementationAndroidTest, CreateVkImageFromAHB) {
 
   // Create a vkimage and import the AHB into it.
   const gfx::Size size(hwb_desc.width, hwb_desc.height);
-  auto* device_queue = vk_context_provider_->GetDeviceQueue();
-  auto handle = base::android::ScopedHardwareBufferHandle::Adopt(buffer);
-  gfx::GpuMemoryBufferHandle gmp_handle(std::move(handle));
-  auto vulkan_image = VulkanImage::CreateFromGpuMemoryBufferHandle(
-      device_queue, std::move(gmb_handle), size, VK_FORMAT_R8G8B8A8_UNORM,
-      0 /* usage */);
-
-  EXPECT_TRUE(vulkan_image);
-  vulkan_image->Destroy();
+  VkImage vk_image;
+  VkImageCreateInfo vk_image_info;
+  VkDeviceMemory vk_device_memory;
+  VkDeviceSize mem_allocation_size;
+  EXPECT_TRUE(vk_implementation_->CreateVkImageAndImportAHB(
+      vk_device_, vk_phy_device_, size,
+      base::android::ScopedHardwareBufferHandle::Adopt(buffer), &vk_image,
+      &vk_image_info, &vk_device_memory, &mem_allocation_size));
+
+  // Free up resources.
+  vkDestroyImage(vk_device_, vk_image, nullptr);
+  vkFreeMemory(vk_device_, vk_device_memory, nullptr);
 }
 
 }  // namespace gpu

gpu/vulkan/android/vulkan_implementation_android.h

@@ -49,6 +49,16 @@ class COMPONENT_EXPORT(VULKAN_ANDROID) VulkanImplementationAndroid
       gfx::GpuMemoryBufferHandle gmb_handle,
       gfx::Size size,
       VkFormat vk_formae) override;
+  bool CreateVkImageAndImportAHB(
+      const VkDevice& vk_device,
+      const VkPhysicalDevice& vk_physical_device,
+      const gfx::Size& size,
+      base::android::ScopedHardwareBufferHandle ahb_handle,
+      VkImage* vk_image,
+      VkImageCreateInfo* vk_image_info,
+      VkDeviceMemory* vk_device_memory,
+      VkDeviceSize* mem_allocation_size,
+      VulkanYCbCrInfo* ycbcr_info) override;
   bool GetSamplerYcbcrConversionInfo(
       const VkDevice& vk_device,
       base::android::ScopedHardwareBufferHandle ahb_handle,

gpu/vulkan/vulkan_image.cc

@@ -19,23 +19,19 @@
 #include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h"
 #endif
 
-#if defined(OS_ANDROID)
-#include "base/android/android_hardware_buffer_compat.h"
-#endif
-
 namespace gpu {
 
 namespace {
 
 base::Optional<uint32_t> FindMemoryTypeIndex(
     VkPhysicalDevice physical_device,
-    const VkMemoryRequirements* requirements,
+    const VkMemoryRequirements& requirements,
     VkMemoryPropertyFlags flags) {
   VkPhysicalDeviceMemoryProperties properties;
   vkGetPhysicalDeviceMemoryProperties(physical_device, &properties);
   constexpr uint32_t kMaxIndex = 31;
   for (uint32_t i = 0; i <= kMaxIndex; i++) {
-    if (((1u << i) & requirements->memoryTypeBits) == 0)
+    if (((1u << i) & requirements.memoryTypeBits) == 0)
       continue;
     if ((properties.memoryTypes[i].propertyFlags & flags) != flags)
       continue;
@@ -60,8 +56,7 @@ std::unique_ptr<VulkanImage> VulkanImage::Create(
   auto image = std::make_unique<VulkanImage>(util::PassKey<VulkanImage>());
   if (!image->Initialize(device_queue, size, format, usage, flags, image_tiling,
                          vk_image_create_info_next,
-                         vk_memory_allocation_info_next,
-                         nullptr /* requirements */)) {
+                         vk_memory_allocation_info_next)) {
     return nullptr;
   }
   return image;
@@ -83,24 +78,6 @@ std::unique_ptr<VulkanImage> VulkanImage::CreateWithExternalMemory(
   return image;
 }
 
-// static
-std::unique_ptr<VulkanImage> VulkanImage::CreateFromGpuMemoryBufferHandle(
-    VulkanDeviceQueue* device_queue,
-    gfx::GpuMemoryBufferHandle gmb_handle,
-    const gfx::Size& size,
-    VkFormat format,
-    VkImageUsageFlags usage,
-    VkImageCreateFlags flags,
-    VkImageTiling image_tiling) {
-  auto image = std::make_unique<VulkanImage>(util::PassKey<VulkanImage>());
-  if (!image->InitializeFromGpuMemoryBufferHandle(
-          device_queue, std::move(gmb_handle), size, format, usage, flags,
-          image_tiling)) {
-    return nullptr;
-  }
-  return image;
-}
-
 // static
 std::unique_ptr<VulkanImage> VulkanImage::Create(
     VulkanDeviceQueue* device_queue,
@@ -200,8 +177,7 @@ bool VulkanImage::Initialize(VulkanDeviceQueue* device_queue,
                              VkImageCreateFlags flags,
                              VkImageTiling image_tiling,
                              void* vk_image_create_info_next,
-                             void* vk_memory_allocation_info_next,
-                             const VkMemoryRequirements* requirements) {
+                             void* vk_memory_allocation_info_next) {
   DCHECK(!device_queue_);
   DCHECK(image_ == VK_NULL_HANDLE);
   DCHECK(device_memory_ == VK_NULL_HANDLE);
@@ -237,18 +213,15 @@ bool VulkanImage::Initialize(VulkanDeviceQueue* device_queue,
     return false;
   }
 
-  VkMemoryRequirements tmp_requirements;
-  if (!requirements) {
-    vkGetImageMemoryRequirements(vk_device, image_, &tmp_requirements);
-    if (!tmp_requirements.memoryTypeBits) {
-      DLOG(ERROR) << "vkGetImageMemoryRequirements failed";
-      Destroy();
-      return false;
-    }
-    requirements = &tmp_requirements;
+  VkMemoryRequirements requirements;
+  vkGetImageMemoryRequirements(vk_device, image_, &requirements);
+  if (!requirements.memoryTypeBits) {
+    DLOG(ERROR) << "vkGetImageMemoryRequirements failed";
+    Destroy();
+    return false;
   }
 
-  device_size_ = requirements->size;
+  device_size_ = requirements.size;
 
   // Some vulkan implementations require dedicated memory for sharing memory
   // object between vulkan instances.
@@ -363,139 +336,8 @@ bool VulkanImage::InitializeWithExternalMemory(VulkanDeviceQueue* device_queue,
   };
 
   return Initialize(device_queue, size, format, usage, flags, image_tiling,
-                    &external_image_create_info, &external_memory_allocate_info,
-                    nullptr /* requirements */);
-}
-
-bool VulkanImage::InitializeFromGpuMemoryBufferHandle(
-    VulkanDeviceQueue* device_queue,
-    gfx::GpuMemoryBufferHandle gmb_handle,
-    const gfx::Size& size,
-    VkFormat format,
-    VkImageUsageFlags usage,
-    VkImageCreateFlags flags,
-    VkImageTiling image_tiling) {
-#if !defined(OS_ANDROID)
-  NOTIMPLEMENTED();
-  return false;
-#else
-  // TODO(penghuang): Move this method to vulkan_image_android.cc when more
-  // platforms are supported.
-  if (gmb_handle.type != gfx::GpuMemoryBufferType::ANDROID_HARDWARE_BUFFER) {
-    DLOG(ERROR) << "gmb_handle.type is not supported. type:" << gmb_handle.type;
-    return false;
-  }
-  DCHECK(gmb_handle.android_hardware_buffer.is_valid());
-  auto& ahb_handle = gmb_handle.android_hardware_buffer;
-
-  // To obtain format properties of an Android hardware buffer, include an
-  // instance of VkAndroidHardwareBufferFormatPropertiesANDROID in the pNext
-  // chain of the VkAndroidHardwareBufferPropertiesANDROID instance passed to
-  // vkGetAndroidHardwareBufferPropertiesANDROID.
-  VkAndroidHardwareBufferFormatPropertiesANDROID ahb_format_props = {
-      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
-  };
-  VkAndroidHardwareBufferPropertiesANDROID ahb_props = {
-      .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
-      .pNext = &ahb_format_props,
-  };
-
-  VkDevice vk_device = device_queue->GetVulkanDevice();
-  VkResult result = vkGetAndroidHardwareBufferPropertiesANDROID(
-      vk_device, ahb_handle.get(), &ahb_props);
-  if (result != VK_SUCCESS) {
-    LOG(ERROR)
-        << "GetAhbProps: vkGetAndroidHardwareBufferPropertiesANDROID failed : "
-        << result;
-    return false;
-  }
-
-  // To create an image with an external format, include an instance of
-  // VkExternalFormatANDROID in the pNext chain of VkImageCreateInfo.
-  VkExternalFormatANDROID external_format = {
-      .sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
-      // If externalFormat is zero, the effect is as if the
-      // VkExternalFormatANDROID structure was not present. Otherwise, the image
-      // will have the specified external format.
-      .externalFormat = 0,
-  };
-
-  // If image has an external format, format must be VK_FORMAT_UNDEFINED.
-  if (ahb_format_props.format == VK_FORMAT_UNDEFINED) {
-    // externalFormat must be 0 or a value returned in the externalFormat member
-    // of VkAndroidHardwareBufferFormatPropertiesANDROID by an earlier call to
-    // vkGetAndroidHardwareBufferPropertiesANDROID.
-    external_format.externalFormat = ahb_format_props.externalFormat;
-  }
-
-  // To define a set of external memory handle types that may be used as backing
-  // store for an image, add a VkExternalMemoryImageCreateInfo structure to the
-  // pNext chain of the VkImageCreateInfo structure.
-  VkExternalMemoryImageCreateInfo external_memory_image_info = {
-      .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
-      .pNext = &external_format,
-      .handleTypes =
-          VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
-  };
-
-  // Get the AHB description.
-  AHardwareBuffer_Desc ahb_desc = {};
-  base::AndroidHardwareBufferCompat::GetInstance().Describe(ahb_handle.get(),
-                                                            &ahb_desc);
-
-  // Intended usage of the image.
-  VkImageUsageFlags usage_flags = 0;
-  // Get Vulkan Image usage flag equivalence of AHB usage.
-  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE) {
-    usage_flags = usage_flags | VK_IMAGE_USAGE_SAMPLED_BIT |
-                  VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
-  }
-  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT) {
-    usage_flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-  }
-
-  // TODO(vikassoni) : AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP is supported from API
-  // level 28 which is not part of current android_ndk version in chromium. Add
-  // equivalent VK usage later.
-  if (!usage_flags) {
-    LOG(ERROR) << "No valid usage flags found";
-    return false;
-  }
-
-  VkImageCreateFlags create_flags = 0;
-  if (ahb_desc.usage & AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT) {
-    create_flags = VK_IMAGE_CREATE_PROTECTED_BIT;
-  }
-
-  // To import memory created outside of the current Vulkan instance from an
-  // Android hardware buffer, add a VkImportAndroidHardwareBufferInfoANDROID
-  // structure to the pNext chain of the VkMemoryAllocateInfo structure.
-  VkImportAndroidHardwareBufferInfoANDROID ahb_import_info = {
-      .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
-      .buffer = ahb_handle.get(),
-  };
-
-  VkMemoryRequirements requirements = {
-      .size = ahb_props.allocationSize,
-      .memoryTypeBits = ahb_props.memoryTypeBits,
-  };
-  if (!Initialize(device_queue, size, ahb_format_props.format, usage_flags,
-                  create_flags, VK_IMAGE_TILING_OPTIMAL,
-                  &external_memory_image_info, &ahb_import_info,
-                  &requirements)) {
-    return false;
-  }
-
-  if (ahb_format_props.format == VK_FORMAT_UNDEFINED) {
-    ycbcr_info_.emplace(VK_FORMAT_UNDEFINED, ahb_format_props.externalFormat,
-                        ahb_format_props.suggestedYcbcrModel,
-                        ahb_format_props.suggestedYcbcrRange,
-                        ahb_format_props.suggestedXChromaOffset,
-                        ahb_format_props.suggestedYChromaOffset,
-                        ahb_format_props.formatFeatures);
-  }
-  return true;
-#endif  // defined(OS_ANDROID)
-}
+                    &external_image_create_info,
+                    &external_memory_allocate_info);
+}  // namespace gpu
 
 }  // namespace gpu

gpu/vulkan/vulkan_image.h

@@ -14,7 +14,6 @@
 #include "gpu/ipc/common/vulkan_ycbcr_info.h"
 #include "gpu/vulkan/vulkan_export.h"
 #include "ui/gfx/geometry/size.h"
-#include "ui/gfx/gpu_memory_buffer.h"
 
 #if defined(OS_FUCHSIA)
 #include <lib/zx/vmo.h>
@@ -49,17 +48,8 @@ class VULKAN_EXPORT VulkanImage {
       const gfx::Size& size,
       VkFormat format,
       VkImageUsageFlags usage,
-      VkImageCreateFlags flags = 0,
-      VkImageTiling image_tiling = VK_IMAGE_TILING_OPTIMAL);
-
-  static std::unique_ptr<VulkanImage> CreateFromGpuMemoryBufferHandle(
-      VulkanDeviceQueue* device_queue,
-      gfx::GpuMemoryBufferHandle gmb_handle,
-      const gfx::Size& size,
-      VkFormat format,
-      VkImageUsageFlags usage,
-      VkImageCreateFlags flags = 0,
-      VkImageTiling image_tiling = VK_IMAGE_TILING_OPTIMAL);
+      VkImageCreateFlags flags,
+      VkImageTiling image_tiling);
 
   static std::unique_ptr<VulkanImage> Create(
       VulkanDeviceQueue* device_queue,
@@ -103,22 +93,13 @@ class VULKAN_EXPORT VulkanImage {
                   VkImageCreateFlags flags,
                   VkImageTiling image_tiling,
                   void* image_create_info_next,
-                  void* memory_allocation_info_next,
-                  const VkMemoryRequirements* requirements);
+                  void* memory_allocation_info_next);
   bool InitializeWithExternalMemory(VulkanDeviceQueue* device_queue,
                                     const gfx::Size& size,
                                     VkFormat format,
                                     VkImageUsageFlags usage,
                                     VkImageCreateFlags flags,
                                     VkImageTiling image_tiling);
-  bool InitializeFromGpuMemoryBufferHandle(
-      VulkanDeviceQueue* device_queue,
-      gfx::GpuMemoryBufferHandle gmb_handle,
-      const gfx::Size& size,
-      VkFormat format,
-      VkImageUsageFlags usage,
-      VkImageCreateFlags flags,
-      VkImageTiling image_tiling);
 
   VulkanDeviceQueue* device_queue_ = nullptr;
   gfx::Size size_;

gpu/vulkan/vulkan_implementation.h

@@ -117,6 +117,21 @@ class VULKAN_EXPORT VulkanImplementation {
       VkFormat vk_formae) = 0;
 
 #if defined(OS_ANDROID)
+  // Create a VkImage, import Android AHardwareBuffer object created outside of
+  // the Vulkan device into Vulkan memory object and bind it to the VkImage.
+  // TODO(sergeyu): Remove this method and use
+  // CreateVkImageFromGpuMemoryHandle() instead.
+  virtual bool CreateVkImageAndImportAHB(
+      const VkDevice& vk_device,
+      const VkPhysicalDevice& vk_physical_device,
+      const gfx::Size& size,
+      base::android::ScopedHardwareBufferHandle ahb_handle,
+      VkImage* vk_image,
+      VkImageCreateInfo* vk_image_info,
+      VkDeviceMemory* vk_device_memory,
+      VkDeviceSize* mem_allocation_size,
+      VulkanYCbCrInfo* ycbcr_info = nullptr) = 0;
+
   // Get the sampler ycbcr conversion information from the AHB.
   virtual bool GetSamplerYcbcrConversionInfo(
       const VkDevice& vk_device,

ui/gfx/gpu_memory_buffer.cc

@@ -8,14 +8,8 @@
 
 namespace gfx {
 
-GpuMemoryBufferHandle::GpuMemoryBufferHandle() = default;
-
-#if defined(OS_ANDROID)
-GpuMemoryBufferHandle::GpuMemoryBufferHandle(
-    base::android::ScopedHardwareBufferHandle handle)
-    : type(GpuMemoryBufferType::ANDROID_HARDWARE_BUFFER),
-      android_hardware_buffer(std::move(handle)) {}
-#endif
+GpuMemoryBufferHandle::GpuMemoryBufferHandle()
+    : type(EMPTY_BUFFER), id(0), offset(0), stride(0) {}
 
 // TODO(crbug.com/863011): Reset |type| and possibly the handles on the
 // moved-from object.

ui/gfx/gpu_memory_buffer.h

@@ -55,20 +55,16 @@ using GpuMemoryBufferId = GenericSharedMemoryId;
 // time and it corresponds to |type|.
 struct GFX_EXPORT GpuMemoryBufferHandle {
   GpuMemoryBufferHandle();
-#if defined(OS_ANDROID)
-  explicit GpuMemoryBufferHandle(
-      base::android::ScopedHardwareBufferHandle handle);
-#endif
   GpuMemoryBufferHandle(GpuMemoryBufferHandle&& other);
   GpuMemoryBufferHandle& operator=(GpuMemoryBufferHandle&& other);
   ~GpuMemoryBufferHandle();
   GpuMemoryBufferHandle Clone() const;
   bool is_null() const { return type == EMPTY_BUFFER; }
-  GpuMemoryBufferType type = GpuMemoryBufferType::EMPTY_BUFFER;
-  GpuMemoryBufferId id{0};
+  GpuMemoryBufferType type;
+  GpuMemoryBufferId id;
   base::UnsafeSharedMemoryRegion region;
-  uint32_t offset = 0;
-  int32_t stride = 0;
+  uint32_t offset;
+  int32_t stride;
 #if defined(OS_LINUX) || defined(OS_FUCHSIA)
   NativePixmapHandle native_pixmap_handle;
 #elif defined(OS_MACOSX) && !defined(OS_IOS)