[Fuchsia] Enable YCbCr samplers support

Previously compositor supported YCbCr samplers only on Android and only
for external Vulkan images. On Fuchsia sysmem APIs use Vulkan I420
formats to return decoded images and so YCbCr samplers have to be used
to render them on the screen. In this CL:
 1. Updated VulkanImplementation::CreateImageFromGpuMemoryHandle() to
    make it possible to return YCbCr info.
 2. Added image_format in gpu::VulkanYCbCrInfo to remove the
    assumption YCbCr images are always external.
 3. ExternalVkImageBacking now bundles returned YCbCr info in
    GrVkImageInfo when wrapping in GrBackendTexture.
 4. SkiaOutputSurfaceImpl now passes image format when initializing
    GrVkYcbcrConversionInfo.
 5. Updated VulkanDeviceQueue and VulkanImplementationScenic to
    enable YCbCr sampler extension on Fuchsia.

Bug: 981022
Change-Id: I477ebf698d098bafefaadbf77dfa8d373f9ae076
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1730311
Commit-Queue: Sergey Ulanov <sergeyu@chromium.org>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Reviewed-by: Michael Spang <spang@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#686649}

components/viz/common/resources/resource_format_utils.cc

@@ -450,9 +450,11 @@ VkFormat ToVkFormat(ResourceFormat format) {
       return VK_FORMAT_R8_UNORM;
     case LUMINANCE_8:
       return VK_FORMAT_R8_UNORM;
-    case LUMINANCE_F16:
     case YVU_420:
+      return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
     case YUV_420_BIPLANAR:
+      return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
+    case LUMINANCE_F16:
     case UYVY_422:
     case ETC1:
     case P010:

components/viz/service/display_embedder/skia_output_surface_impl.cc

@@ -649,7 +649,10 @@ GrBackendFormat SkiaOutputSurfaceImpl::GetGrBackendFormatForTexture(
     if (!ycbcr_info)
       return GrBackendFormat::MakeVk(ToVkFormat(resource_format));
 
-    GrVkYcbcrConversionInfo fYcbcrConversionInfo(
+    VkFormat format = ycbcr_info->external_format ? VK_FORMAT_UNDEFINED
+                                                  : ToVkFormat(resource_format);
+    GrVkYcbcrConversionInfo gr_ycbcr_info(
+        format, ycbcr_info->external_format,
         static_cast<VkSamplerYcbcrModelConversion>(
             ycbcr_info->suggested_ycbcr_model),
         static_cast<VkSamplerYcbcrRange>(ycbcr_info->suggested_ycbcr_range),
@@ -657,9 +660,8 @@ GrBackendFormat SkiaOutputSurfaceImpl::GetGrBackendFormatForTexture(
         static_cast<VkChromaLocation>(ycbcr_info->suggested_ychroma_offset),
         VK_FILTER_LINEAR,  // VkFilter
         0,                 // VkBool32 forceExplicitReconstruction,
-        ycbcr_info->external_format,
         static_cast<VkFormatFeatureFlags>(ycbcr_info->format_features));
-    return GrBackendFormat::MakeVk(fYcbcrConversionInfo);
+    return GrBackendFormat::MakeVk(gr_ycbcr_info);
 #else
     NOTREACHED();
     return GrBackendFormat();

gpu/command_buffer/service/BUILD.gn

@@ -307,6 +307,7 @@ target(link_target_type, "gles2_sources") {
     "//gpu/command_buffer/common:gles2_utils",
     "//gpu/config",
     "//gpu/ipc/common:surface_handle_type",
+    "//gpu/ipc/common:vulkan_ycbcr_info",
     "//gpu/vulkan:buildflags",
     "//third_party/angle:angle_image_util",
     "//third_party/angle:commit_id",

gpu/command_buffer/service/external_vk_image_backing.cc

@@ -14,6 +14,7 @@
 #include "components/viz/common/resources/resource_sizes.h"
 #include "gpu/command_buffer/service/external_vk_image_gl_representation.h"
 #include "gpu/command_buffer/service/external_vk_image_skia_representation.h"
+#include "gpu/ipc/common/vulkan_ycbcr_info.h"
 #include "gpu/vulkan/vulkan_command_buffer.h"
 #include "gpu/vulkan/vulkan_command_pool.h"
 #include "gpu/vulkan/vulkan_fence_helper.h"
@@ -37,12 +38,28 @@ GrVkImageInfo CreateGrVkImageInfo(VkImage image,
                                   VkFormat vk_format,
                                   VkDeviceMemory memory,
                                   size_t memory_size,
-                                  bool use_protected_memory) {
+                                  bool use_protected_memory,
+                                  base::Optional<VulkanYCbCrInfo> ycbcr_info) {
+  GrVkYcbcrConversionInfo gr_ycbcr_info{};
+  if (ycbcr_info) {
+    gr_ycbcr_info = GrVkYcbcrConversionInfo(
+        static_cast<VkFormat>(ycbcr_info->image_format),
+        ycbcr_info->external_format,
+        static_cast<VkSamplerYcbcrModelConversion>(
+            ycbcr_info->suggested_ycbcr_model),
+        static_cast<VkSamplerYcbcrRange>(ycbcr_info->suggested_ycbcr_range),
+        static_cast<VkChromaLocation>(ycbcr_info->suggested_xchroma_offset),
+        static_cast<VkChromaLocation>(ycbcr_info->suggested_ychroma_offset),
+        static_cast<VkFilter>(VK_FILTER_LINEAR),
+        /*forceExplicitReconstruction=*/false,
+        static_cast<VkFormatFeatureFlags>(ycbcr_info->format_features));
+  }
   GrVkAlloc alloc(memory, 0 /* offset */, memory_size, 0 /* flags */);
   return GrVkImageInfo(
       image, alloc, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_LAYOUT_UNDEFINED,
       vk_format, 1 /* levelCount */, VK_QUEUE_FAMILY_IGNORED,
-      use_protected_memory ? GrProtected::kYes : GrProtected::kNo);
+      use_protected_memory ? GrProtected::kYes : GrProtected::kNo,
+      gr_ycbcr_info);
 }
 
 VkResult CreateVkImage(SharedContextState* context_state,
@@ -140,7 +157,8 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::Create(
     const gfx::ColorSpace& color_space,
     uint32_t usage,
     base::span<const uint8_t> pixel_data,
-    bool using_gmb) {
+    bool using_gmb,
+    base::Optional<VulkanYCbCrInfo> ycbcr_info) {
   VkDevice device =
       context_state->vk_context_provider()->GetDeviceQueue()->GetVulkanDevice();
   VkFormat vk_format = ToVkFormat(format);
@@ -206,7 +224,7 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::Create(
 
   auto backing = base::WrapUnique(new ExternalVkImageBacking(
       mailbox, format, size, color_space, usage, context_state, image, memory,
-      requirements.size, vk_format, command_pool));
+      requirements.size, vk_format, command_pool, ycbcr_info));
 
   if (!pixel_data.empty()) {
     backing->WritePixels(
@@ -229,11 +247,6 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::CreateFromGMB(
     const gfx::Size& size,
     const gfx::ColorSpace& color_space,
     uint32_t usage) {
-  if (gfx::NumberOfPlanesForLinearBufferFormat(buffer_format) != 1) {
-    DLOG(ERROR) << "Invalid image format.";
-    return nullptr;
-  }
-
   if (!gpu::IsImageSizeValidForGpuMemoryBufferFormat(size, buffer_format)) {
     DLOG(ERROR) << "Invalid image size for format.";
     return nullptr;
@@ -250,17 +263,18 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::CreateFromGMB(
     VkImageCreateInfo vk_image_info = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
     VkDeviceMemory vk_device_memory = VK_NULL_HANDLE;
     VkDeviceSize memory_size = 0;
+    base::Optional<gpu::VulkanYCbCrInfo> ycbcr_info;
 
     if (!vulkan_implementation->CreateImageFromGpuMemoryHandle(
             vk_device, std::move(handle), size, &vk_image, &vk_image_info,
-            &vk_device_memory, &memory_size)) {
+            &vk_device_memory, &memory_size, &ycbcr_info)) {
       DLOG(ERROR) << "Failed to create VkImage from GpuMemoryHandle.";
       return nullptr;
     }
 
     VkFormat expected_format = ToVkFormat(resource_format);
     if (expected_format != vk_image_info.format) {
-      DLOG(ERROR) << "BufferFormat doesn't match the buffer";
+      DLOG(ERROR) << "BufferFormat doesn't match the buffer ";
       vkFreeMemory(vk_device, vk_device_memory, nullptr);
       vkDestroyImage(vk_device, vk_image, nullptr);
       return nullptr;
@@ -269,7 +283,12 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::CreateFromGMB(
     return base::WrapUnique(new ExternalVkImageBacking(
         mailbox, viz::GetResourceFormat(buffer_format), size, color_space,
         usage, context_state, vk_image, vk_device_memory, memory_size,
-        vk_image_info.format, command_pool));
+        vk_image_info.format, command_pool, ycbcr_info));
+  }
+
+  if (gfx::NumberOfPlanesForLinearBufferFormat(buffer_format) != 1) {
+    DLOG(ERROR) << "Invalid image format.";
+    return nullptr;
   }
 
   DCHECK_EQ(handle.type, gfx::SHARED_MEMORY_BUFFER);
@@ -363,7 +382,8 @@ ExternalVkImageBacking::ExternalVkImageBacking(
     VkDeviceMemory memory,
     size_t memory_size,
     VkFormat vk_format,
-    VulkanCommandPool* command_pool)
+    VulkanCommandPool* command_pool,
+    base::Optional<VulkanYCbCrInfo> ycbcr_info)
     : SharedImageBacking(mailbox,
                          format,
                          size,
@@ -372,14 +392,14 @@ ExternalVkImageBacking::ExternalVkImageBacking(
                          memory_size,
                          false /* is_thread_safe */),
       context_state_(context_state),
-      backend_texture_(
-          size.width(),
-          size.height(),
-          CreateGrVkImageInfo(image,
-                              vk_format,
-                              memory,
-                              memory_size,
-                              usage & SHARED_IMAGE_USAGE_PROTECTED)),
+      backend_texture_(size.width(),
+                       size.height(),
+                       CreateGrVkImageInfo(image,
+                                           vk_format,
+                                           memory,
+                                           memory_size,
+                                           usage & SHARED_IMAGE_USAGE_PROTECTED,
+                                           ycbcr_info)),
       command_pool_(command_pool) {}
 
 ExternalVkImageBacking::~ExternalVkImageBacking() {

gpu/command_buffer/service/external_vk_image_backing.h

@@ -10,11 +10,13 @@
 
 #include "base/memory/scoped_refptr.h"
 #include "base/memory/shared_memory_mapping.h"
+#include "base/optional.h"
 #include "components/viz/common/gpu/vulkan_context_provider.h"
 #include "gpu/command_buffer/common/shared_image_usage.h"
 #include "gpu/command_buffer/service/shared_context_state.h"
 #include "gpu/command_buffer/service/shared_image_backing.h"
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "gpu/ipc/common/vulkan_ycbcr_info.h"
 #include "gpu/vulkan/semaphore_handle.h"
 #include "gpu/vulkan/vulkan_device_queue.h"
 #include "ui/gfx/gpu_memory_buffer.h"
@@ -34,7 +36,8 @@ class ExternalVkImageBacking : public SharedImageBacking {
       const gfx::ColorSpace& color_space,
       uint32_t usage,
       base::span<const uint8_t> pixel_data,
-      bool using_gmb = false);
+      bool using_gmb = false,
+      base::Optional<VulkanYCbCrInfo> ycbcr_info = base::nullopt);
 
   static std::unique_ptr<ExternalVkImageBacking> CreateFromGMB(
       SharedContextState* context_state,
@@ -116,7 +119,8 @@ class ExternalVkImageBacking : public SharedImageBacking {
                          VkDeviceMemory memory,
                          size_t memory_size,
                          VkFormat vk_format,
-                         VulkanCommandPool* command_pool);
+                         VulkanCommandPool* command_pool,
+                         base::Optional<VulkanYCbCrInfo> ycbcr_info);
 
   // Install a shared memory GMB to the backing.
   void InstallSharedMemory(

gpu/ipc/common/BUILD.gn

@@ -83,8 +83,6 @@ source_set("ipc_common_sources") {
     "gpu_watchdog_timeout.h",
     "memory_stats.cc",
     "memory_stats.h",
-    "vulkan_ycbcr_info.cc",
-    "vulkan_ycbcr_info.h",
   ]
 
   if (is_mac) {
@@ -122,6 +120,7 @@ source_set("ipc_common_sources") {
   public_deps = [
     ":command_buffer_traits_sources",
     ":surface_handle_type",
+    ":vulkan_ycbcr_info",
     "//ipc",
     "//url/ipc:url_ipc",
   ]
@@ -190,6 +189,16 @@ source_set("surface_handle_type") {
   ]
 }
 
+source_set("vulkan_ycbcr_info") {
+  sources = [
+    "vulkan_ycbcr_info.cc",
+    "vulkan_ycbcr_info.h",
+  ]
+  deps = [
+    "//base",
+  ]
+}
+
 mojom("interfaces") {
   sources = [
     "capabilities.mojom",
@@ -254,6 +263,7 @@ source_set("mojom_traits") {
   deps = [
     ":interfaces_shared_cpp_sources",
     ":surface_handle_type",
+    ":vulkan_ycbcr_info",
     "//gpu/command_buffer/common",
     "//gpu/ipc/common",
     "//mojo/public/cpp/bindings:bindings",

gpu/ipc/common/vulkan_ycbcr_info.cc

@@ -4,21 +4,28 @@
 
 #include "gpu/ipc/common/vulkan_ycbcr_info.h"
 
+#include "base/logging.h"
+
 namespace gpu {
 
 VulkanYCbCrInfo::VulkanYCbCrInfo() = default;
 
-VulkanYCbCrInfo::VulkanYCbCrInfo(uint32_t suggested_ycbcr_model,
+VulkanYCbCrInfo::VulkanYCbCrInfo(uint32_t image_format,
+                                 uint64_t external_format,
+                                 uint32_t suggested_ycbcr_model,
                                  uint32_t suggested_ycbcr_range,
                                  uint32_t suggested_xchroma_offset,
                                  uint32_t suggested_ychroma_offset,
-                                 uint64_t external_format,
                                  uint32_t format_features)
-    : suggested_ycbcr_model(suggested_ycbcr_model),
+    : image_format(image_format),
+      external_format(external_format),
+      suggested_ycbcr_model(suggested_ycbcr_model),
       suggested_ycbcr_range(suggested_ycbcr_range),
       suggested_xchroma_offset(suggested_xchroma_offset),
       suggested_ychroma_offset(suggested_ychroma_offset),
-      external_format(external_format),
-      format_features(format_features) {}
+      format_features(format_features) {
+  // One and only one of the format fields must be non-zero.
+  DCHECK((image_format == 0) ^ (external_format == 0));
+}
 
 }  // namespace gpu

gpu/ipc/common/vulkan_ycbcr_info.h

@@ -7,20 +7,28 @@
 
 #include <stdint.h>
 
-#include "gpu/gpu_export.h"
-
 namespace gpu {
 
 // Sampler Ycbcr conversion information.
-struct GPU_EXPORT VulkanYCbCrInfo {
+struct VulkanYCbCrInfo {
   VulkanYCbCrInfo();
-  VulkanYCbCrInfo(uint32_t suggested_ycbcr_model,
+  VulkanYCbCrInfo(uint32_t image_format,
+                  uint64_t external_format,
+                  uint32_t suggested_ycbcr_model,
                   uint32_t suggested_ycbcr_range,
                   uint32_t suggested_xchroma_offset,
                   uint32_t suggested_ychroma_offset,
-                  uint64_t external_format,
                   uint32_t format_features);
 
+  // Source image format.
+  // Corresponds to vulkan type: VkFormat.
+  uint32_t image_format;
+
+  // Implementation-defined external format identifier for use with
+  // VkExternalFormatANDROID.
+  // This property is driver specific.
+  uint64_t external_format;
+
   // Describes the color matrix for conversion between color models.
   // Corresponds to vulkan type: VkSamplerYcbcrModelConversion.
   uint32_t suggested_ycbcr_model;
@@ -42,14 +50,9 @@ struct GPU_EXPORT VulkanYCbCrInfo {
   // Corresponds to vulkan type: VkChromaLocation.
   uint32_t suggested_ychroma_offset;
 
-  // Implementation-defined external format identifier for use with
-  // VkExternalFormatANDROID.
-  // This property is driver specific.
-  uint64_t external_format;
-
-  // Describes the capabilities of the external format when used with an image
-  // bound to memory imported from buffer.
-  // Corresponds to vulkan type: VkFormatFeatureFlags.
+  // Describes the capabilities of the format when used with an image bound to
+  // memory imported from buffer. Corresponds to vulkan type:
+  // VkFormatFeatureFlags.
   uint32_t format_features;
 };
 

gpu/ipc/common/vulkan_ycbcr_info.mojom

@@ -10,10 +10,11 @@ module gpu.mojom;
 // in chrome.
 // See gpu/ipc/common/vulkan_ycbcr_info.h.
 struct VulkanYCbCrInfo {
+  uint32 image_format;
+  uint64 external_format;
   uint32 suggested_ycbcr_model;
   uint32 suggested_ycbcr_range;
   uint32 suggested_xchroma_offset;
   uint32 suggested_ychroma_offset;
-  uint64 external_format;
   uint32 format_features;
 };

gpu/ipc/common/vulkan_ycbcr_info_mojom_traits.h

@@ -12,6 +12,14 @@ namespace mojo {
 
 template <>
 struct StructTraits<gpu::mojom::VulkanYCbCrInfoDataView, gpu::VulkanYCbCrInfo> {
+  static uint32_t image_format(const gpu::VulkanYCbCrInfo& info) {
+    return info.image_format;
+  }
+
+  static uint64_t external_format(const gpu::VulkanYCbCrInfo& info) {
+    return info.external_format;
+  }
+
   static uint32_t suggested_ycbcr_model(const gpu::VulkanYCbCrInfo& info) {
     return info.suggested_ycbcr_model;
   }
@@ -28,21 +36,18 @@ struct StructTraits<gpu::mojom::VulkanYCbCrInfoDataView, gpu::VulkanYCbCrInfo> {
     return info.suggested_ychroma_offset;
   }
 
-  static uint64_t external_format(const gpu::VulkanYCbCrInfo& info) {
-    return info.external_format;
-  }
-
   static uint32_t format_features(const gpu::VulkanYCbCrInfo& info) {
     return info.format_features;
   }
 
   static bool Read(gpu::mojom::VulkanYCbCrInfoDataView data,
                    gpu::VulkanYCbCrInfo* out) {
+    out->image_format = data.image_format();
+    out->external_format = data.external_format();
     out->suggested_ycbcr_model = data.suggested_ycbcr_model();
     out->suggested_ycbcr_range = data.suggested_ycbcr_range();
     out->suggested_xchroma_offset = data.suggested_xchroma_offset();
     out->suggested_ychroma_offset = data.suggested_ychroma_offset();
-    out->external_format = data.external_format();
     out->format_features = data.format_features();
     return true;
   }

gpu/vulkan/android/BUILD.gn

@@ -24,7 +24,8 @@ component("android") {
   defines = [ "IS_VULKAN_ANDROID_IMPL" ]
 
   deps = [
-    "//gpu/ipc/common:common",
+    "//gpu/ipc/common",
+    "//gpu/ipc/common:vulkan_ycbcr_info",
     "//ui/gfx",
   ]
 

gpu/vulkan/android/vulkan_implementation_android.cc

@@ -52,19 +52,14 @@ bool GetAhbProps(
   return true;
 }
 
-void PopulateYcbcrInfo(
-    const VkAndroidHardwareBufferFormatPropertiesANDROID& ahb_format_props,
-    VulkanYCbCrInfo* ycbcr_info) {
-  DCHECK(ycbcr_info);
-
-  ycbcr_info->suggested_ycbcr_model = ahb_format_props.suggestedYcbcrModel;
-  ycbcr_info->suggested_ycbcr_range = ahb_format_props.suggestedYcbcrRange;
-  ycbcr_info->suggested_xchroma_offset =
-      ahb_format_props.suggestedXChromaOffset;
-  ycbcr_info->suggested_ychroma_offset =
-      ahb_format_props.suggestedYChromaOffset;
-  ycbcr_info->external_format = ahb_format_props.externalFormat;
-  ycbcr_info->format_features = ahb_format_props.formatFeatures;
+VulkanYCbCrInfo GetYcbcrInfoFromBufferProps(
+    const VkAndroidHardwareBufferFormatPropertiesANDROID& ahb_format_props) {
+  return VulkanYCbCrInfo(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);
 }
 
 }  // namespace
@@ -189,7 +184,8 @@ bool VulkanImplementationAndroid::CreateImageFromGpuMemoryHandle(
     VkImage* vk_image,
     VkImageCreateInfo* vk_image_info,
     VkDeviceMemory* vk_device_memory,
-    VkDeviceSize* mem_allocation_size) {
+    VkDeviceSize* mem_allocation_size,
+    base::Optional<VulkanYCbCrInfo>* ycbcr_info) {
   // TODO(sergeyu): Move code from CreateVkImageAndImportAHB() here and remove
   // CreateVkImageAndImportAHB().
   NOTIMPLEMENTED();
@@ -371,7 +367,7 @@ bool VulkanImplementationAndroid::CreateVkImageAndImportAHB(
 
   *mem_allocation_size = mem_alloc_info.allocationSize;
   if (ycbcr_info)
-    PopulateYcbcrInfo(ahb_format_props, ycbcr_info);
+    *ycbcr_info = GetYcbcrInfoFromBufferProps(ahb_format_props);
   return true;
 }
 
@@ -387,7 +383,7 @@ bool VulkanImplementationAndroid::GetSamplerYcbcrConversionInfo(
   if (!GetAhbProps(vk_device, ahb_handle.get(), &ahb_format_props, &ahb_props))
     return false;
 
-  PopulateYcbcrInfo(ahb_format_props, ycbcr_info);
+  *ycbcr_info = GetYcbcrInfoFromBufferProps(ahb_format_props);
   return true;
 }
 

gpu/vulkan/android/vulkan_implementation_android.h

@@ -50,7 +50,8 @@ class COMPONENT_EXPORT(VULKAN_ANDROID) VulkanImplementationAndroid
       VkImage* vk_image,
       VkImageCreateInfo* vk_image_info,
       VkDeviceMemory* vk_device_memory,
-      VkDeviceSize* mem_allocation_size) override;
+      VkDeviceSize* mem_allocation_size,
+      base::Optional<VulkanYCbCrInfo>* ycbcr_info) override;
   bool CreateVkImageAndImportAHB(
       const VkDevice& vk_device,
       const VkPhysicalDevice& vk_physical_device,

gpu/vulkan/vulkan_device_queue.cc

@@ -133,7 +133,7 @@ bool VulkanDeviceQueue::Initialize(
     if (desired_layers.find(layer_property.layerName) != desired_layers.end())
       enabled_layer_names.push_back(layer_property.layerName);
   }
-#endif
+#endif  // DCHECK_IS_ON()
 
   std::vector<const char*> enabled_extensions;
   enabled_extensions.insert(std::end(enabled_extensions),
@@ -143,7 +143,8 @@ bool VulkanDeviceQueue::Initialize(
   uint32_t device_api_version =
       std::min(max_api_version, vk_physical_device_properties_.apiVersion);
 
-#if defined(OS_ANDROID)
+  // Android and Fuchsia need YCbCr sampler support.
+#if defined(OS_ANDROID) || defined(OS_FUCHSIA)
   if (!vkGetPhysicalDeviceFeatures2) {
     DLOG(ERROR) << "Vulkan 1.1 or VK_KHR_get_physical_device_properties2 "
                    "extension is required.";
@@ -151,54 +152,52 @@ bool VulkanDeviceQueue::Initialize(
   }
 
   // Query if VkPhysicalDeviceSamplerYcbcrConversionFeatures is supported by
-  // the implementation. This extension must be supported for android.
-  sampler_ycbcr_conversion_features_.sType =
-      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+  // the implementation. This extension must be supported for Android and
+  // Fuchsia.
   sampler_ycbcr_conversion_features_.pNext = nullptr;
-
-  // Add VkPhysicalDeviceSamplerYcbcrConversionFeatures struct to pNext chain
-  // of VkPhysicalDeviceFeatures2.
-  enabled_device_features_2_.sType =
-      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-  enabled_device_features_2_.pNext = &sampler_ycbcr_conversion_features_;
+  VkPhysicalDeviceFeatures2 supported_device_features_2 = {
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
+      &sampler_ycbcr_conversion_features_};
   vkGetPhysicalDeviceFeatures2(vk_physical_device_,
-                               &enabled_device_features_2_);
+                               &supported_device_features_2);
   if (!sampler_ycbcr_conversion_features_.samplerYcbcrConversion) {
-    LOG(ERROR) << "samplerYcbcrConversion is not supported";
+    LOG(ERROR) << "samplerYcbcrConversion is not supported.";
     return false;
   }
 
-  // Disable all physical device features by default.
-  memset(&enabled_device_features_2_.features, 0,
-         sizeof(enabled_device_features_2_.features));
-#elif defined(OS_FUCHSIA)
-  // Used to Query if VkPhysicalDeviceProtectedMemoryFeatures is supported by
-  // the implementation on fuchsia.
-  VkPhysicalDeviceProtectedMemoryFeatures protected_memory_features = {
-      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES};
-  protected_memory_features.protectedMemory = VK_TRUE;
+  // Add VkPhysicalDeviceSamplerYcbcrConversionFeatures struct to pNext chain
+  // of VkPhysicalDeviceFeatures2 to enable YCbCr sampler support.
+  sampler_ycbcr_conversion_features_.pNext = enabled_device_features_2_.pNext;
+  enabled_device_features_2_.pNext = &sampler_ycbcr_conversion_features_;
+#endif  // defined(OS_ANDROID) || defined(OS_FUCHSIA)
 
+#if defined(OS_FUCHSIA)
   if (allow_protected_memory) {
     if (device_api_version < VK_MAKE_VERSION(1, 1, 0)) {
       DLOG(ERROR) << "Vulkan 1.1 is required for protected memory";
       return false;
     }
 
-    enabled_device_features_2_.sType =
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-    enabled_device_features_2_.pNext = &protected_memory_features;
+    protected_memory_features_.pNext = nullptr;
+    VkPhysicalDeviceFeatures2 supported_device_features_2 = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
+        &protected_memory_features_};
     vkGetPhysicalDeviceFeatures2(vk_physical_device_,
-                                 &enabled_device_features_2_);
-    if (!protected_memory_features.protectedMemory) {
+                                 &supported_device_features_2);
+    if (!protected_memory_features_.protectedMemory) {
       DLOG(ERROR) << "Protected memory is not supported";
       return false;
     }
 
-    // Disable all physical device features by default.
-    memset(&enabled_device_features_2_.features, 0,
-           sizeof(enabled_device_features_2_.features));
+    // Add VkPhysicalDeviceProtectedMemoryFeatures struct to pNext chain
+    // of VkPhysicalDeviceFeatures2 to enable YCbCr sampler support.
+    protected_memory_features_.pNext = enabled_device_features_2_.pNext;
+    enabled_device_features_2_.pNext = &protected_memory_features_;
   }
-#endif
+#endif  // defined(OS_FUCHSIA)
+
+  // Disable all physical device features by default.
+  enabled_device_features_2_.features = {};
 
   VkDeviceCreateInfo device_create_info = {};
   device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

gpu/vulkan/vulkan_device_queue.h

@@ -103,14 +103,22 @@ class VULKAN_EXPORT VulkanDeviceQueue {
   uint32_t vk_queue_index_ = 0;
   const VkInstance vk_instance_;
   std::unique_ptr<VulkanFenceHelper> cleanup_helper_;
-  VkPhysicalDeviceFeatures2 enabled_device_features_2_ = {};
+  VkPhysicalDeviceFeatures2 enabled_device_features_2_ = {
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
+
   const bool enforce_protected_memory_;
   bool allow_protected_memory_ = false;
 
-#if defined(OS_ANDROID)
+#if defined(OS_ANDROID) || defined(OS_FUCHSIA)
   VkPhysicalDeviceSamplerYcbcrConversionFeatures
-      sampler_ycbcr_conversion_features_ = {};
-#endif
+      sampler_ycbcr_conversion_features_ = {
+          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES};
+#endif  // defined(OS_ANDROID) || defined(OS_FUCHSIA)
+
+#if defined(OS_FUCHSIA)
+  VkPhysicalDeviceProtectedMemoryFeatures protected_memory_features_ = {
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES};
+#endif  // defined(OS_FUCHSIA)
 
   DISALLOW_COPY_AND_ASSIGN(VulkanDeviceQueue);
 };

gpu/vulkan/vulkan_implementation.h

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "base/optional.h"
 #include "build/build_config.h"
 #include "gpu/vulkan/semaphore_handle.h"
 #include "gpu/vulkan/vulkan_export.h"
@@ -107,7 +108,8 @@ class VULKAN_EXPORT VulkanImplementation {
       VkImage* vk_image,
       VkImageCreateInfo* vk_image_info,
       VkDeviceMemory* vk_device_memory,
-      VkDeviceSize* mem_allocation_size) = 0;
+      VkDeviceSize* mem_allocation_size,
+      base::Optional<VulkanYCbCrInfo>* ycbcr_info) = 0;
 
 #if defined(OS_ANDROID)
   // Create a VkImage, import Android AHardwareBuffer object created outside of

gpu/vulkan/win32/vulkan_implementation_win32.cc

@@ -142,7 +142,8 @@ bool VulkanImplementationWin32::CreateImageFromGpuMemoryHandle(
     VkImage* vk_image,
     VkImageCreateInfo* vk_image_info,
     VkDeviceMemory* vk_device_memory,
-    VkDeviceSize* mem_allocation_size) {
+    VkDeviceSize* mem_allocation_size,
+    base::Optional<VulkanYCbCrInfo>* ycbcr_info) {
   NOTIMPLEMENTED();
   return false;
 }

gpu/vulkan/win32/vulkan_implementation_win32.h

@@ -48,7 +48,8 @@ class COMPONENT_EXPORT(VULKAN_WIN32) VulkanImplementationWin32
       VkImage* vk_image,
       VkImageCreateInfo* vk_image_info,
       VkDeviceMemory* vk_device_memory,
-      VkDeviceSize* mem_allocation_size) override;
+      VkDeviceSize* mem_allocation_size,
+      base::Optional<VulkanYCbCrInfo>* ycbcr_info) override;
 
  private:
   VulkanInstance vulkan_instance_;

gpu/vulkan/x/vulkan_implementation_x11.cc

@@ -170,7 +170,8 @@ bool VulkanImplementationX11::CreateImageFromGpuMemoryHandle(
     VkImage* vk_image,
     VkImageCreateInfo* vk_image_info,
     VkDeviceMemory* vk_device_memory,
-    VkDeviceSize* mem_allocation_size) {
+    VkDeviceSize* mem_allocation_size,
+    base::Optional<VulkanYCbCrInfo>* ycbcr_info) {
   NOTIMPLEMENTED();
   return false;
 }

gpu/vulkan/x/vulkan_implementation_x11.h

@@ -49,7 +49,8 @@ class COMPONENT_EXPORT(VULKAN_X11) VulkanImplementationX11
       VkImage* vk_image,
       VkImageCreateInfo* vk_image_info,
       VkDeviceMemory* vk_device_memory,
-      VkDeviceSize* mem_allocation_size) override;
+      VkDeviceSize* mem_allocation_size,
+      base::Optional<VulkanYCbCrInfo>* ycbcr_info) override;
 
  private:
   bool using_surface_ = true;

ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.cc

@@ -169,7 +169,8 @@ bool VulkanImplementationGbm::CreateImageFromGpuMemoryHandle(
     VkImage* vk_image,
     VkImageCreateInfo* vk_image_info,
     VkDeviceMemory* vk_device_memory,
-    VkDeviceSize* mem_allocation_size) {
+    VkDeviceSize* mem_allocation_size,
+    base::Optional<gpu::VulkanYCbCrInfo>* ycbcr_info) {
   NOTIMPLEMENTED();
   return false;
 }

ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.h

@@ -46,7 +46,8 @@ class VulkanImplementationGbm : public gpu::VulkanImplementation {
       VkImage* vk_image,
       VkImageCreateInfo* vk_image_info,
       VkDeviceMemory* vk_device_memory,
-      VkDeviceSize* mem_allocation_size) override;
+      VkDeviceSize* mem_allocation_size,
+      base::Optional<gpu::VulkanYCbCrInfo>* ycbcr_info) override;
 
  private:
   gpu::VulkanInstance vulkan_instance_;

ui/ozone/platform/scenic/BUILD.gn

@@ -71,6 +71,7 @@ source_set("scenic") {
       "vulkan_implementation_scenic.h",
     ]
     defines += [ "VK_USE_PLATFORM_MAGMA_KHR" ]
+    deps += [ "//gpu/ipc/common:vulkan_ycbcr_info" ]
     data_deps += [
       "//third_party/angle:libEGL",
       "//third_party/angle:libGLESv2",

ui/ozone/platform/scenic/DEPS

 include_rules = [
   "+mojo/public",
   "+third_party/skia/include",
+  "+gpu/ipc/common",
 ]

ui/ozone/platform/scenic/vulkan_implementation_scenic.cc

@@ -15,6 +15,7 @@
 #include "base/fuchsia/fuchsia_logging.h"
 #include "base/macros.h"
 #include "base/native_library.h"
+#include "gpu/ipc/common/vulkan_ycbcr_info.h"
 #include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
 #include "gpu/vulkan/vulkan_instance.h"
@@ -60,6 +61,7 @@ bool VulkanImplementationScenic::InitializeVulkanInstance(bool using_surface) {
   std::vector<const char*> required_extensions = {
       VK_KHR_SURFACE_EXTENSION_NAME,
       VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME,
+      VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
   };
   std::vector<const char*> required_layers = {
       "VK_LAYER_FUCHSIA_imagepipe_swapchain",
@@ -124,8 +126,12 @@ VulkanImplementationScenic::GetRequiredDeviceExtensions() {
       VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME,
       VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME,
       VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
+      VK_KHR_BIND_MEMORY_2_EXTENSION_NAME,
       VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
       VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
+      VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
+      VK_KHR_MAINTENANCE1_EXTENSION_NAME,
+      VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
       VK_KHR_SWAPCHAIN_EXTENSION_NAME,
   };
 }
@@ -227,7 +233,8 @@ bool VulkanImplementationScenic::CreateImageFromGpuMemoryHandle(
     VkImage* vk_image,
     VkImageCreateInfo* vk_image_info,
     VkDeviceMemory* vk_device_memory,
-    VkDeviceSize* mem_allocation_size) {
+    VkDeviceSize* mem_allocation_size,
+    base::Optional<gpu::VulkanYCbCrInfo>* ycbcr_info) {
   if (gmb_handle.type != gfx::NATIVE_PIXMAP)
     return false;
 
@@ -251,6 +258,9 @@ bool VulkanImplementationScenic::CreateImageFromGpuMemoryHandle(
     return false;
   }
 
+  // TODO(crbug.com/981022): Initialize VulkanYCbCrInfo from the collection.
+  *ycbcr_info = base::nullopt;
+
   return collection->CreateVkImage(gmb_handle.native_pixmap_handle.buffer_index,
                                    vk_device, vk_image, vk_image_info,
                                    vk_device_memory, mem_allocation_size);

ui/ozone/platform/scenic/vulkan_implementation_scenic.h

@@ -54,7 +54,8 @@ class VulkanImplementationScenic : public gpu::VulkanImplementation {
       VkImage* vk_image,
       VkImageCreateInfo* vk_image_info,
       VkDeviceMemory* vk_device_memory,
-      VkDeviceSize* mem_allocation_size) override;
+      VkDeviceSize* mem_allocation_size,
+      base::Optional<gpu::VulkanYCbCrInfo>* ycbcr_info) override;
 
  private:
   ScenicSurfaceFactory* const scenic_surface_factory_;