Vulkan: Add VulkanInfo structure for storing all vulkan related info.

In follow up CLs, this VulkanInfo will be sent from viz process to
browser process and then displayed in about:gpu page.

Bug: 887018
Change-Id: Idde45c731aed65092fc384e529e8b5028c93e545
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1845872Reviewed-by: Sergey Ulanov <sergeyu@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Commit-Queue: Peng Huang <penghuang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#703517}

components/viz/common/gpu/vulkan_in_process_context_provider.cc

@@ -45,18 +45,24 @@ VulkanInProcessContextProvider::~VulkanInProcessContextProvider() {
 
 bool VulkanInProcessContextProvider::Initialize() {
   DCHECK(!device_queue_);
-  const gfx::ExtensionSet& extensions =
-      vulkan_implementation_->GetVulkanInstance()->enabled_extensions();
-  bool support_surface =
-      gfx::HasExtension(extensions, VK_KHR_SURFACE_EXTENSION_NAME);
+
+  const auto& instance_extensions = vulkan_implementation_->GetVulkanInstance()
+                                        ->vulkan_info()
+                                        .enabled_instance_extensions;
+
   uint32_t flags = gpu::VulkanDeviceQueue::GRAPHICS_QUEUE_FLAG;
-  if (support_surface)
-    flags |= gpu::VulkanDeviceQueue::PRESENTATION_SUPPORT_QUEUE_FLAG;
-  std::unique_ptr<gpu::VulkanDeviceQueue> device_queue =
-      gpu::CreateVulkanDeviceQueue(vulkan_implementation_, flags);
-  if (!device_queue)
+  constexpr base::StringPiece surface_extension_name(
+      VK_KHR_SURFACE_EXTENSION_NAME);
+  for (const auto* extension : instance_extensions) {
+    if (surface_extension_name == extension) {
+      flags |= gpu::VulkanDeviceQueue::PRESENTATION_SUPPORT_QUEUE_FLAG;
+      break;
+    }
+  }
+
+  device_queue_ = gpu::CreateVulkanDeviceQueue(vulkan_implementation_, flags);
+  if (!device_queue_)
     return false;
-  device_queue_ = std::move(device_queue);
 
   GrVkBackendContext backend_context;
   backend_context.fInstance = device_queue_->GetVulkanInstance();
@@ -64,8 +70,9 @@ bool VulkanInProcessContextProvider::Initialize() {
   backend_context.fDevice = device_queue_->GetVulkanDevice();
   backend_context.fQueue = device_queue_->GetVulkanQueue();
   backend_context.fGraphicsQueueIndex = device_queue_->GetVulkanQueueIndex();
-  backend_context.fMaxAPIVersion =
-      vulkan_implementation_->GetVulkanInstance()->api_version();
+  backend_context.fMaxAPIVersion = vulkan_implementation_->GetVulkanInstance()
+                                       ->vulkan_info()
+                                       .used_api_version;
 
   gpu::VulkanFunctionPointers* vulkan_function_pointers =
       gpu::GetVulkanFunctionPointers();
@@ -73,11 +80,7 @@ bool VulkanInProcessContextProvider::Initialize() {
       make_unified_getter(vulkan_function_pointers->vkGetInstanceProcAddrFn,
                           vulkan_function_pointers->vkGetDeviceProcAddrFn);
 
-  std::vector<const char*> instance_extensions;
   std::vector<const char*> device_extensions;
-  instance_extensions.reserve(extensions.size());
-  for (const auto& extension : extensions)
-    instance_extensions.push_back(extension.data());
   device_extensions.reserve(device_queue_->enabled_extensions().size());
   for (const auto& extension : device_queue_->enabled_extensions())
     device_extensions.push_back(extension.data());

gpu/vulkan/BUILD.gn

@@ -43,7 +43,10 @@ if (enable_vulkan) {
       "vulkan_function_pointers.h",
       "vulkan_implementation.cc",
       "vulkan_implementation.h",
+      "vulkan_info.cc",
+      "vulkan_info.h",
       "vulkan_instance.cc",
+      "vulkan_instance.h",
       "vulkan_surface.cc",
       "vulkan_surface.h",
       "vulkan_swap_chain.cc",

gpu/vulkan/vulkan_device_queue.cc

@@ -11,6 +11,7 @@
 #include "gpu/vulkan/vulkan_command_pool.h"
 #include "gpu/vulkan/vulkan_fence_helper.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
+#include "gpu/vulkan/vulkan_info.h"
 
 namespace gpu {
 
@@ -27,7 +28,7 @@ VulkanDeviceQueue::~VulkanDeviceQueue() {
 
 bool VulkanDeviceQueue::Initialize(
     uint32_t options,
-    uint32_t max_api_version,
+    const VulkanInfo& info,
     const std::vector<const char*>& required_extensions,
     bool allow_protected_memory,
     const GetPresentationSupportCallback& get_presentation_support) {
@@ -42,60 +43,41 @@ bool VulkanDeviceQueue::Initialize(
 
   VkResult result = VK_SUCCESS;
 
-  uint32_t device_count = 0;
-  result = vkEnumeratePhysicalDevices(vk_instance_, &device_count, nullptr);
-  if (VK_SUCCESS != result || device_count == 0)
-    return false;
-
-  std::vector<VkPhysicalDevice> devices(device_count);
-  result =
-      vkEnumeratePhysicalDevices(vk_instance_, &device_count, devices.data());
-  if (VK_SUCCESS != result) {
-    DLOG(ERROR) << "vkEnumeratePhysicalDevices() failed: " << result;
-    return false;
-  }
-
   VkQueueFlags queue_flags = 0;
   if (options & DeviceQueueOption::GRAPHICS_QUEUE_FLAG)
     queue_flags |= VK_QUEUE_GRAPHICS_BIT;
 
   int device_index = -1;
   int queue_index = -1;
-  for (size_t i = 0; i < devices.size(); ++i) {
-    const VkPhysicalDevice& device = devices[i];
-    uint32_t queue_count = 0;
-    vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, nullptr);
-    if (queue_count) {
-      std::vector<VkQueueFamilyProperties> queue_properties(queue_count);
-      vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count,
-                                               queue_properties.data());
-      for (size_t n = 0; n < queue_properties.size(); ++n) {
-        if ((queue_properties[n].queueFlags & queue_flags) != queue_flags)
-          continue;
-
-        if (options & DeviceQueueOption::PRESENTATION_SUPPORT_QUEUE_FLAG &&
-            !get_presentation_support.Run(device, queue_properties, n)) {
-          continue;
-        }
-
-        queue_index = static_cast<int>(n);
-        break;
+  for (size_t i = 0; i < info.physical_devices.size(); ++i) {
+    const auto& device_info = info.physical_devices[i];
+    const VkPhysicalDevice& device = device_info.device;
+    for (size_t n = 0; n < device_info.queue_families.size(); ++n) {
+      if ((device_info.queue_families[n].queueFlags & queue_flags) !=
+          queue_flags)
+        continue;
+
+      if (options & DeviceQueueOption::PRESENTATION_SUPPORT_QUEUE_FLAG &&
+          !get_presentation_support.Run(device, device_info.queue_families,
+                                        n)) {
+        continue;
       }
 
-      if (-1 != queue_index) {
-        device_index = static_cast<int>(i);
-        break;
-      }
+      queue_index = static_cast<int>(n);
+      break;
+    }
+    if (-1 != queue_index) {
+      device_index = static_cast<int>(i);
+      break;
     }
   }
 
   if (queue_index == -1)
     return false;
 
-  vk_physical_device_ = devices[device_index];
-  vkGetPhysicalDeviceProperties(vk_physical_device_,
-                                &vk_physical_device_properties_);
-
+  const auto& physical_device_info = info.physical_devices[device_index];
+  vk_physical_device_ = physical_device_info.device;
+  vk_physical_device_properties_ = physical_device_info.properties;
   vk_queue_index_ = queue_index;
 
   float queue_priority = 0.0f;
@@ -109,29 +91,13 @@ bool VulkanDeviceQueue::Initialize(
 
   std::vector<const char*> enabled_layer_names;
 #if DCHECK_IS_ON()
-  uint32_t num_device_layers = 0;
-  result = vkEnumerateDeviceLayerProperties(vk_physical_device_,
-                                            &num_device_layers, nullptr);
-  if (VK_SUCCESS != result) {
-    DLOG(ERROR) << "vkEnumerateDeviceLayerProperties(NULL) failed: " << result;
-    return false;
-  }
-
-  std::vector<VkLayerProperties> device_layers(num_device_layers);
-  result = vkEnumerateDeviceLayerProperties(
-      vk_physical_device_, &num_device_layers, device_layers.data());
-  if (VK_SUCCESS != result) {
-    DLOG(ERROR) << "vkEnumerateDeviceLayerProperties() failed: " << result;
-    return false;
-  }
-
   std::unordered_set<std::string> desired_layers({
       "VK_LAYER_KHRONOS_validation",
   });
 
-  for (const VkLayerProperties& layer_property : device_layers) {
-    if (desired_layers.find(layer_property.layerName) != desired_layers.end())
-      enabled_layer_names.push_back(layer_property.layerName);
+  for (const auto& layer : physical_device_info.layers) {
+    if (desired_layers.find(layer.layerName) != desired_layers.end())
+      enabled_layer_names.push_back(layer.layerName);
   }
 #endif  // DCHECK_IS_ON()
 
@@ -140,30 +106,21 @@ bool VulkanDeviceQueue::Initialize(
                             std::begin(required_extensions),
                             std::end(required_extensions));
 
-  uint32_t device_api_version =
-      std::min(max_api_version, vk_physical_device_properties_.apiVersion);
+  uint32_t device_api_version = std::min(
+      info.used_api_version, vk_physical_device_properties_.apiVersion);
+
+  // Disable all physical device features by default.
+  enabled_device_features_2_ = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
 
   // 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.";
-    return false;
-  }
-
-  // Query if VkPhysicalDeviceSamplerYcbcrConversionFeatures is supported by
-  // the implementation. This extension must be supported for Android and
-  // Fuchsia.
-  sampler_ycbcr_conversion_features_.pNext = nullptr;
-  VkPhysicalDeviceFeatures2 supported_device_features_2 = {
-      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-      &sampler_ycbcr_conversion_features_};
-  vkGetPhysicalDeviceFeatures2(vk_physical_device_,
-                               &supported_device_features_2);
-  if (!sampler_ycbcr_conversion_features_.samplerYcbcrConversion) {
+  if (!physical_device_info.feature_sampler_ycbcr_conversion) {
     LOG(ERROR) << "samplerYcbcrConversion is not supported.";
     return false;
   }
+  sampler_ycbcr_conversion_features_ = {
+      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES};
+  sampler_ycbcr_conversion_features_.samplerYcbcrConversion = VK_TRUE;
 
   // Add VkPhysicalDeviceSamplerYcbcrConversionFeatures struct to pNext chain
   // of VkPhysicalDeviceFeatures2 to enable YCbCr sampler support.
@@ -172,21 +129,13 @@ bool VulkanDeviceQueue::Initialize(
 #endif  // defined(OS_ANDROID) || 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;
-    }
-
-    protected_memory_features_.pNext = nullptr;
-    VkPhysicalDeviceFeatures2 supported_device_features_2 = {
-        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
-        &protected_memory_features_};
-    vkGetPhysicalDeviceFeatures2(vk_physical_device_,
-                                 &supported_device_features_2);
-    if (!protected_memory_features_.protectedMemory) {
+    if (!physical_device_info.feature_protected_memory) {
       DLOG(ERROR) << "Protected memory is not supported";
       return false;
     }
+    protected_memory_features_ = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES};
+    protected_memory_features_.protectedMemory = VK_TRUE;
 
     // Add VkPhysicalDeviceProtectedMemoryFeatures struct to pNext chain
     // of VkPhysicalDeviceFeatures2 to enable YCbCr sampler support.
@@ -194,11 +143,8 @@ bool VulkanDeviceQueue::Initialize(
     enabled_device_features_2_.pNext = &protected_memory_features_;
   }
 
-  // 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;
+  VkDeviceCreateInfo device_create_info = {
+      VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO};
   device_create_info.pNext = enabled_device_features_2_.pNext;
   device_create_info.queueCreateInfoCount = 1;
   device_create_info.pQueueCreateInfos = &queue_create_info;

gpu/vulkan/vulkan_device_queue.h

@@ -18,8 +18,9 @@
 
 namespace gpu {
 
-class VulkanFenceHelper;
 class VulkanCommandPool;
+class VulkanFenceHelper;
+class VulkanInfo;
 
 class VULKAN_EXPORT VulkanDeviceQueue {
  public:
@@ -38,7 +39,7 @@ class VULKAN_EXPORT VulkanDeviceQueue {
                                    uint32_t queue_family_index)>;
   bool Initialize(
       uint32_t options,
-      uint32_t max_api_version,
+      const VulkanInfo& info,
       const std::vector<const char*>& required_extensions,
       bool allow_protected_memory,
       const GetPresentationSupportCallback& get_presentation_support);
@@ -103,20 +104,17 @@ 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_ = {
-      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
+  VkPhysicalDeviceFeatures2 enabled_device_features_2_;
 
   const bool enforce_protected_memory_;
   bool allow_protected_memory_ = false;
 
 #if defined(OS_ANDROID) || defined(OS_FUCHSIA)
   VkPhysicalDeviceSamplerYcbcrConversionFeatures
-      sampler_ycbcr_conversion_features_ = {
-          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES};
+      sampler_ycbcr_conversion_features_;
 #endif  // defined(OS_ANDROID) || defined(OS_FUCHSIA)
 
-  VkPhysicalDeviceProtectedMemoryFeatures protected_memory_features_ = {
-      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES};
+  VkPhysicalDeviceProtectedMemoryFeatures protected_memory_features_;
 
   DISALLOW_COPY_AND_ASSIGN(VulkanDeviceQueue);
 };

gpu/vulkan/vulkan_implementation.cc

@@ -32,7 +32,7 @@ std::unique_ptr<VulkanDeviceQueue> CreateVulkanDeviceQueue(
   std::vector<const char*> required_extensions =
       vulkan_implementation->GetRequiredDeviceExtensions();
   if (!device_queue->Initialize(
-          option, vulkan_implementation->GetVulkanInstance()->api_version(),
+          option, vulkan_implementation->GetVulkanInstance()->vulkan_info(),
           std::move(required_extensions),
           vulkan_implementation->allow_protected_memory(), callback)) {
     device_queue->Destroy();

gpu/vulkan/vulkan_info.cc

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gpu/vulkan/vulkan_info.h"
+
+namespace gpu {
+
+VulkanInfo::VulkanInfo() = default;
+VulkanInfo::~VulkanInfo() = default;
+VulkanInfo::PhysicalDeviceInfo::PhysicalDeviceInfo() = default;
+VulkanInfo::PhysicalDeviceInfo::PhysicalDeviceInfo(
+    const PhysicalDeviceInfo& other) = default;
+VulkanInfo::PhysicalDeviceInfo::~PhysicalDeviceInfo() = default;
+VulkanInfo::PhysicalDeviceInfo& VulkanInfo::PhysicalDeviceInfo::operator=(
+    const PhysicalDeviceInfo& info) = default;
+
+}  // namespace gpu

gpu/vulkan/vulkan_info.h

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GPU_VULKAN_VULKAN_INFO_H_
+#define GPU_VULKAN_VULKAN_INFO_H_
+
+#include <vulkan/vulkan.h>
+#include <vector>
+
+#include "base/macros.h"
+#include "gpu/vulkan/vulkan_export.h"
+#include "ui/gfx/extension_set.h"
+
+namespace gpu {
+
+class VULKAN_EXPORT VulkanInfo {
+ public:
+  VulkanInfo();
+  ~VulkanInfo();
+
+  class PhysicalDeviceInfo {
+   public:
+    PhysicalDeviceInfo();
+    PhysicalDeviceInfo(const PhysicalDeviceInfo& other);
+    ~PhysicalDeviceInfo();
+    PhysicalDeviceInfo& operator=(const PhysicalDeviceInfo& other);
+
+    VkPhysicalDevice device = VK_NULL_HANDLE;
+    VkPhysicalDeviceProperties properties = {};
+    std::vector<VkLayerProperties> layers;
+
+    VkPhysicalDeviceFeatures features = {};
+    // Extended physical device features:
+    bool feature_sampler_ycbcr_conversion = false;
+    bool feature_protected_memory = false;
+
+    std::vector<VkQueueFamilyProperties> queue_families;
+  };
+
+  uint32_t api_version = VK_MAKE_VERSION(1, 0, 0);
+  uint32_t used_api_version = VK_MAKE_VERSION(1, 0, 0);
+  std::vector<VkExtensionProperties> instance_extensions;
+  std::vector<const char*> enabled_instance_extensions;
+  std::vector<VkLayerProperties> instance_layers;
+  std::vector<PhysicalDeviceInfo> physical_devices;
+};
+
+}  // namespace gpu
+
+#endif  // GPU_VULKAN_VULKAN_INFO_H_

gpu/vulkan/vulkan_instance.cc

@@ -57,34 +57,33 @@ bool VulkanInstance::Initialize(
   if (!vulkan_function_pointers->BindUnassociatedFunctionPointers())
     return false;
 
-  uint32_t supported_api_version = VK_MAKE_VERSION(1, 0, 0);
   if (vulkan_function_pointers->vkEnumerateInstanceVersionFn) {
     vulkan_function_pointers->vkEnumerateInstanceVersionFn(
-        &supported_api_version);
+        &vulkan_info_.api_version);
   }
 
 #if defined(OS_ANDROID)
   // Ensure that android works only with vulkan apiVersion >= 1.1. Vulkan will
   // only be enabled for Android P+ and Android P+ requires vulkan
   // apiVersion >= 1.1.
-  if (supported_api_version < VK_MAKE_VERSION(1, 1, 0))
+  if (vulkan_info_.api_version < VK_MAKE_VERSION(1, 1, 0))
     return false;
 #endif
 
   // Use Vulkan 1.1 if it's available.
-  api_version_ = (supported_api_version >= VK_MAKE_VERSION(1, 1, 0))
-                     ? VK_MAKE_VERSION(1, 1, 0)
-                     : VK_MAKE_VERSION(1, 0, 0);
+  vulkan_info_.used_api_version =
+      (vulkan_info_.api_version >= VK_MAKE_VERSION(1, 1, 0))
+          ? VK_MAKE_VERSION(1, 1, 0)
+          : VK_MAKE_VERSION(1, 0, 0);
 
   VkResult result = VK_SUCCESS;
 
   VkApplicationInfo app_info = {};
   app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
   app_info.pApplicationName = "Chromium";
-  app_info.apiVersion = api_version_;
-
-  std::vector<const char*> enabled_extensions = required_extensions;
+  app_info.apiVersion = vulkan_info_.used_api_version;
 
+  vulkan_info_.enabled_instance_extensions = required_extensions;
   uint32_t num_instance_exts = 0;
   result = vkEnumerateInstanceExtensionProperties(nullptr, &num_instance_exts,
                                                   nullptr);
@@ -94,27 +93,31 @@ bool VulkanInstance::Initialize(
     return false;
   }
 
-  std::vector<VkExtensionProperties> instance_exts(num_instance_exts);
-  result = vkEnumerateInstanceExtensionProperties(nullptr, &num_instance_exts,
-                                                  instance_exts.data());
+  vulkan_info_.instance_extensions.resize(num_instance_exts);
+  result = vkEnumerateInstanceExtensionProperties(
+      nullptr, &num_instance_exts, vulkan_info_.instance_extensions.data());
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkEnumerateInstanceExtensionProperties() failed: "
                 << result;
     return false;
   }
 
-  for (const VkExtensionProperties& ext_property : instance_exts) {
+  for (const VkExtensionProperties& ext_property :
+       vulkan_info_.instance_extensions) {
     if (strcmp(ext_property.extensionName,
                VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
       debug_report_enabled_ = true;
-      enabled_extensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+      vulkan_info_.enabled_instance_extensions.push_back(
+          VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
     }
   }
 
 #if DCHECK_IS_ON()
-  for (const char* enabled_extension : enabled_extensions) {
+  for (const char* enabled_extension :
+       vulkan_info_.enabled_instance_extensions) {
     bool found = false;
-    for (const VkExtensionProperties& ext_property : instance_exts) {
+    for (const VkExtensionProperties& ext_property :
+         vulkan_info_.instance_extensions) {
       if (strcmp(ext_property.extensionName, enabled_extension) == 0) {
         found = true;
         break;
@@ -137,29 +140,29 @@ bool VulkanInstance::Initialize(
     return false;
   }
 
-  layer_properties_.resize(num_instance_layers);
-  result = vkEnumerateInstanceLayerProperties(&num_instance_layers,
-                                              layer_properties_.data());
+  vulkan_info_.instance_layers.resize(num_instance_layers);
+  result = vkEnumerateInstanceLayerProperties(
+      &num_instance_layers, vulkan_info_.instance_layers.data());
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkEnumerateInstanceLayerProperties() failed: " << result;
     return false;
   }
 
+  gfx::ExtensionSet enabled_extensions(
+      std::begin(vulkan_info_.enabled_instance_extensions),
+      std::end(vulkan_info_.enabled_instance_extensions));
+
 #if DCHECK_IS_ON()
   // TODO(crbug.com/843346): Make validation work in combination with
   // VK_KHR_xlib_surface or switch to VK_KHR_xcb_surface.
-  constexpr base::StringPiece xlib_surface_extension_name(
-      "VK_KHR_xlib_surface");
   bool require_xlib_surface_extension =
-      std::find_if(enabled_extensions.begin(), enabled_extensions.end(),
-                   [xlib_surface_extension_name](const char* e) {
-                     return xlib_surface_extension_name == e;
-                   }) != enabled_extensions.end();
+      gfx::HasExtension(enabled_extensions, "VK_KHR_xlib_surface");
+
   // VK_LAYER_KHRONOS_validation 1.1.106 is required to support
   // VK_KHR_xlib_surface.
   constexpr base::StringPiece standard_validation(
       "VK_LAYER_KHRONOS_validation");
-  for (const VkLayerProperties& layer_property : layer_properties_) {
+  for (const VkLayerProperties& layer_property : vulkan_info_.instance_layers) {
     if (standard_validation != layer_property.layerName)
       continue;
     if (!require_xlib_surface_extension ||
@@ -171,14 +174,15 @@ bool VulkanInstance::Initialize(
 #endif  // DCHECK_IS_ON()
 
   VkInstanceCreateInfo instance_create_info = {
-      VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,  // sType
-      nullptr,                                 // pNext
-      0,                                       // flags
-      &app_info,                               // pApplicationInfo
-      enabled_layer_names.size(),              // enableLayerCount
-      enabled_layer_names.data(),              // ppEnabledLayerNames
-      enabled_extensions.size(),               // enabledExtensionCount
-      enabled_extensions.data(),               // ppEnabledExtensionNames
+      VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,           // sType
+      nullptr,                                          // pNext
+      0,                                                // flags
+      &app_info,                                        // pApplicationInfo
+      enabled_layer_names.size(),                       // enableLayerCount
+      enabled_layer_names.data(),                       // ppEnabledLayerNames
+      vulkan_info_.enabled_instance_extensions.size(),  // enabledExtensionCount
+      vulkan_info_.enabled_instance_extensions
+          .data(),  // ppEnabledExtensionNames
   };
 
   result = vkCreateInstance(&instance_create_info, nullptr, &vk_instance_);
@@ -187,9 +191,6 @@ bool VulkanInstance::Initialize(
     return false;
   }
 
-  enabled_extensions_ = gfx::ExtensionSet(std::begin(enabled_extensions),
-                                          std::end(enabled_extensions));
-
 #if DCHECK_IS_ON()
   // Register our error logging function.
   if (debug_report_enabled_) {
@@ -225,8 +226,75 @@ bool VulkanInstance::Initialize(
   }
 #endif
 
-  return vulkan_function_pointers->BindInstanceFunctionPointers(
-      vk_instance_, api_version_, enabled_extensions_);
+  if (!vulkan_function_pointers->BindInstanceFunctionPointers(
+          vk_instance_, vulkan_info_.used_api_version, enabled_extensions)) {
+    return false;
+  }
+
+  CollectInfo();
+  return true;
+}
+
+void VulkanInstance::CollectInfo() {
+  uint32_t count = 0;
+  VkResult result = vkEnumeratePhysicalDevices(vk_instance_, &count, nullptr);
+  if (result != VK_SUCCESS) {
+    DLOG(ERROR) << "vkEnumeratePhysicalDevices failed: " << result;
+  }
+
+  std::vector<VkPhysicalDevice> physical_devices(count);
+  result =
+      vkEnumeratePhysicalDevices(vk_instance_, &count, physical_devices.data());
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkEnumeratePhysicalDevices() failed: " << result;
+    return;
+  }
+
+  vulkan_info_.physical_devices.reserve(count);
+  for (VkPhysicalDevice device : physical_devices) {
+    vulkan_info_.physical_devices.emplace_back();
+    auto& info = vulkan_info_.physical_devices.back();
+    info.device = device;
+
+    vkGetPhysicalDeviceProperties(device, &info.properties);
+
+    count = 0;
+    result = vkEnumerateDeviceLayerProperties(device, &count, nullptr);
+    DLOG_IF(ERROR, result != VK_SUCCESS)
+        << "vkEnumerateDeviceLayerProperties failed: " << result;
+
+    info.layers.resize(count);
+    result =
+        vkEnumerateDeviceLayerProperties(device, &count, info.layers.data());
+    DLOG_IF(ERROR, result != VK_SUCCESS)
+        << "vkEnumerateDeviceLayerProperties failed: " << result;
+
+    if (vkGetPhysicalDeviceFeatures2) {
+      VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcr_converson_features =
+          {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES};
+      VkPhysicalDeviceProtectedMemoryFeatures protected_memory_feature = {
+          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES};
+      VkPhysicalDeviceFeatures2 features_2 = {
+          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
+      features_2.pNext = &ycbcr_converson_features;
+      ycbcr_converson_features.pNext = &protected_memory_feature;
+
+      vkGetPhysicalDeviceFeatures2(device, &features_2);
+      info.feature_sampler_ycbcr_conversion =
+          ycbcr_converson_features.samplerYcbcrConversion;
+      info.feature_protected_memory = protected_memory_feature.protectedMemory;
+    } else {
+      vkGetPhysicalDeviceFeatures(device, &info.features);
+    }
+
+    count = 0;
+    vkGetPhysicalDeviceQueueFamilyProperties(device, &count, nullptr);
+    if (count) {
+      info.queue_families.resize(count);
+      vkGetPhysicalDeviceQueueFamilyProperties(device, &count,
+                                               info.queue_families.data());
+    }
+  }
 }
 
 void VulkanInstance::Destroy() {

gpu/vulkan/vulkan_instance.h

@@ -11,6 +11,7 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "gpu/vulkan/vulkan_export.h"
+#include "gpu/vulkan/vulkan_info.h"
 #include "ui/gfx/extension_set.h"
 
 namespace gpu {
@@ -29,27 +30,17 @@ class VULKAN_EXPORT VulkanInstance {
   bool Initialize(const std::vector<const char*>& required_extensions,
                   const std::vector<const char*>& required_layers);
 
-  // VkApplicationInfo.apiVersion value used to initialize the instance.
-  uint32_t api_version() const { return api_version_; }
-
-  const gfx::ExtensionSet& enabled_extensions() const {
-    return enabled_extensions_;
-  }
-
-  const std::vector<VkLayerProperties>& layer_properties() const {
-    return layer_properties_;
-  }
+  const VulkanInfo& vulkan_info() const { return vulkan_info_; }
 
   VkInstance vk_instance() { return vk_instance_; }
 
  private:
+  void CollectInfo();
   void Destroy();
 
-  uint32_t api_version_;
+  VulkanInfo vulkan_info_;
 
   VkInstance vk_instance_ = VK_NULL_HANDLE;
-  std::vector<VkLayerProperties> layer_properties_;
-  gfx::ExtensionSet enabled_extensions_;
   bool debug_report_enabled_ = false;
 #if DCHECK_IS_ON()
   VkDebugReportCallbackEXT error_callback_ = VK_NULL_HANDLE;

ui/ozone/platform/scenic/vulkan_implementation_scenic.cc

@@ -81,7 +81,7 @@ VulkanImplementationScenic::CreateViewSurface(gfx::AcceleratedWidget window) {
   constexpr base::StringPiece image_pipe_swapchain(
       "VK_LAYER_FUCHSIA_imagepipe_swapchain");
   for (const VkLayerProperties& layer_property :
-       vulkan_instance_.layer_properties()) {
+       vulkan_instance_.vulkan_info().instance_layers) {
     if (image_pipe_swapchain != layer_property.layerName)
       continue;
     image_pipe_swapchain_implementation_version =