Create a helper method to create GrVkImageInfo from gpu::VulkanImage

Bug: None
Change-Id: I34640da23483581c91c56fef4344afce106a0a78
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2122450
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#753744}

android_webview/browser/gfx/aw_draw_fn_impl.cc

@@ -16,6 +16,7 @@
 #include "base/trace_event/trace_event.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
+#include "gpu/command_buffer/service/skia_utils.h"
 #include "gpu/ipc/common/android/android_image_reader_utils.h"
 #include "gpu/vulkan/vulkan_fence_helper.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
@@ -478,14 +479,7 @@ void AwDrawFnImpl::DrawVkInterop(AwDrawFn_DrawVkParams* params) {
       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->image_info = gpu::CreateGrVkImageInfo(vulkan_image.get());
     pending_draw->vulkan_image = std::move(vulkan_image);
   }
 

gpu/command_buffer/service/external_vk_image_backing.cc

@@ -84,23 +84,6 @@ static const struct {
 static_assert(base::size(kFormatTable) == (viz::RESOURCE_FORMAT_MAX + 1),
               "kFormatTable does not handle all cases.");
 
-GrVkImageInfo CreateGrVkImageInfo(SharedContextState* context_state,
-                                  VulkanImage* image,
-                                  bool use_protected_memory) {
-  VkPhysicalDevice physical_device = context_state->vk_context_provider()
-                                         ->GetDeviceQueue()
-                                         ->GetVulkanPhysicalDevice();
-  GrVkYcbcrConversionInfo gr_ycbcr_info = CreateGrVkYcbcrConversionInfo(
-      physical_device, image->image_tiling(), image->ycbcr_info());
-  GrVkAlloc alloc(image->device_memory(), 0 /* offset */, image->device_size(),
-                  0 /* flags */);
-  return GrVkImageInfo(
-      image->image(), alloc, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_LAYOUT_UNDEFINED,
-      image->format(), 1 /* levelCount */, VK_QUEUE_FAMILY_IGNORED,
-      use_protected_memory ? GrProtected::kYes : GrProtected::kNo,
-      gr_ycbcr_info);
-}
-
 uint32_t FindMemoryTypeIndex(SharedContextState* context_state,
                              const VkMemoryRequirements& requirements,
                              VkMemoryPropertyFlags flags) {
@@ -350,12 +333,9 @@ ExternalVkImageBacking::ExternalVkImageBacking(
                                       false /* is_thread_safe */),
       context_state_(context_state),
       image_(std::move(image)),
-      backend_texture_(
-          size.width(),
-          size.height(),
-          CreateGrVkImageInfo(context_state_,
-                              image_.get(),
-                              usage & SHARED_IMAGE_USAGE_PROTECTED)),
+      backend_texture_(size.width(),
+                       size.height(),
+                       CreateGrVkImageInfo(image_.get())),
       command_pool_(command_pool) {}
 
 ExternalVkImageBacking::~ExternalVkImageBacking() {

gpu/command_buffer/service/shared_image_backing_factory_ahardwarebuffer.cc

@@ -277,18 +277,11 @@ class SharedImageRepresentationSkiaVkAHB
     DCHECK(vulkan_image_);
     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));
+        GrBackendTexture(size().width(), size().height(),
+                         CreateGrVkImageInfo(vulkan_image_.get())));
     DCHECK(promise_texture_);
   }
 

gpu/command_buffer/service/shared_image_video.cc

@@ -287,22 +287,11 @@ class SharedImageRepresentationVideoSkiaVk
       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));
+          GrBackendTexture(size().width(), size().height(),
+                           CreateGrVkImageInfo(vulkan_image_.get())));
       DCHECK(promise_texture_);
     }
     return promise_texture_;

gpu/command_buffer/service/skia_utils.cc

@@ -20,6 +20,7 @@
 #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"
 #endif
 
 namespace gpu {
@@ -167,6 +168,20 @@ void DeleteSkSurface(SharedContextState* context_state,
 }
 
 #if BUILDFLAG(ENABLE_VULKAN)
+GrVkImageInfo CreateGrVkImageInfo(VulkanImage* image) {
+  DCHECK(image);
+  VkPhysicalDevice physical_device =
+      image->device_queue()->GetVulkanPhysicalDevice();
+  GrVkYcbcrConversionInfo gr_ycbcr_info = CreateGrVkYcbcrConversionInfo(
+      physical_device, image->image_tiling(), image->ycbcr_info());
+  GrVkAlloc alloc(image->device_memory(), /*offset=*/0, image->device_size(),
+                  /*flags=*/0);
+  bool is_protected = image->flags() & VK_IMAGE_CREATE_PROTECTED_BIT;
+  return GrVkImageInfo(
+      image->image(), alloc, image->image_tiling(), image->image_layout(),
+      image->format(), /*levelCount=*/1, image->queue_family_index(),
+      is_protected ? GrProtected::kYes : GrProtected::kNo, gr_ycbcr_info);
+}
 
 GrVkYcbcrConversionInfo CreateGrVkYcbcrConversionInfo(
     VkPhysicalDevice physical_device,

gpu/command_buffer/service/skia_utils.h

@@ -32,6 +32,10 @@ class VulkanContextProvider;
 
 namespace gpu {
 
+#if BUILDFLAG(ENABLE_VULKAN)
+class VulkanImage;
+#endif
+
 namespace gles2 {
 class FeatureInfo;
 }  // namespace gles2
@@ -74,6 +78,8 @@ GPU_GLES2_EXPORT void DeleteSkSurface(SharedContextState* context_state,
                                       sk_sp<SkSurface> sk_surface);
 
 #if BUILDFLAG(ENABLE_VULKAN)
+GPU_GLES2_EXPORT GrVkImageInfo CreateGrVkImageInfo(VulkanImage* image);
+
 GPU_GLES2_EXPORT GrVkYcbcrConversionInfo CreateGrVkYcbcrConversionInfo(
     VkPhysicalDevice physical_device,
     VkImageTiling tiling,

gpu/vulkan/vulkan_image.cc

@@ -209,12 +209,13 @@ bool VulkanImage::Initialize(VulkanDeviceQueue* device_queue,
   device_queue_ = device_queue;
   size_ = size;
   format_ = format;
+  flags_ = flags;
   image_tiling_ = image_tiling;
 
   VkImageCreateInfo create_info = {
       .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
       .pNext = vk_image_create_info_next,
-      .flags = flags,
+      .flags = flags_,
       .imageType = VK_IMAGE_TYPE_2D,
       .format = format_,
       .extent = {size.width(), size.height(), 1},
@@ -226,7 +227,7 @@ bool VulkanImage::Initialize(VulkanDeviceQueue* device_queue,
       .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
       .queueFamilyIndexCount = 0,
       .pQueueFamilyIndices = nullptr,
-      .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+      .initialLayout = image_layout_,
   };
   VkDevice vk_device = device_queue->GetVulkanDevice();
   VkResult result =
@@ -486,6 +487,9 @@ bool VulkanImage::InitializeFromGpuMemoryBufferHandle(
     return false;
   }
 
+  // VkImage is imported from external.
+  queue_family_index_ = VK_QUEUE_FAMILY_EXTERNAL;
+
   if (ahb_format_props.format == VK_FORMAT_UNDEFINED) {
     ycbcr_info_.emplace(VK_FORMAT_UNDEFINED, ahb_format_props.externalFormat,
                         ahb_format_props.suggestedYcbcrModel,
@@ -494,6 +498,7 @@ bool VulkanImage::InitializeFromGpuMemoryBufferHandle(
                         ahb_format_props.suggestedYChromaOffset,
                         ahb_format_props.formatFeatures);
   }
+
   return true;
 #endif  // defined(OS_ANDROID)
 }

gpu/vulkan/vulkan_image.h

@@ -83,11 +83,17 @@ class VULKAN_EXPORT VulkanImage {
   zx::vmo GetMemoryZirconHandle();
 #endif
 
+  VulkanDeviceQueue* device_queue() const { return device_queue_; }
   const gfx::Size& size() const { return size_; }
   VkFormat format() const { return format_; }
+  VkImageCreateFlags flags() const { return flags_; }
   VkDeviceSize device_size() const { return device_size_; }
   uint32_t memory_type_index() const { return memory_type_index_; }
   VkImageTiling image_tiling() const { return image_tiling_; }
+  VkImageLayout image_layout() const { return image_layout_; }
+  void set_image_layout(VkImageLayout layout) { image_layout_ = layout; }
+  uint32_t queue_family_index() const { return queue_family_index_; }
+  void set_queue_family_index(uint32_t index) { queue_family_index_ = index; }
   const base::Optional<VulkanYCbCrInfo>& ycbcr_info() const {
     return ycbcr_info_;
   }
@@ -123,9 +129,12 @@ class VULKAN_EXPORT VulkanImage {
   VulkanDeviceQueue* device_queue_ = nullptr;
   gfx::Size size_;
   VkFormat format_ = VK_FORMAT_UNDEFINED;
+  VkImageCreateFlags flags_ = 0;
   VkDeviceSize device_size_ = 0;
   uint32_t memory_type_index_ = 0;
   VkImageTiling image_tiling_ = VK_IMAGE_TILING_OPTIMAL;
+  VkImageLayout image_layout_ = VK_IMAGE_LAYOUT_UNDEFINED;
+  uint32_t queue_family_index_ = VK_QUEUE_FAMILY_IGNORED;
   base::Optional<VulkanYCbCrInfo> ycbcr_info_;
   VkImage image_ = VK_NULL_HANDLE;
   VkDeviceMemory device_memory_ = VK_NULL_HANDLE;