For Dx12 & Vulkan info collection on GPU process

only send back collected bits rather than full GPUInfo

BUG=718215
TEST=bots, manual
R=piman@chromium.org,magchen@chromium.org,dcheng@chromium.org

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: Ib7c6107057bd39579d3bad95400599c5a84ce8b0
Reviewed-on: https://chromium-review.googlesource.com/1246689
Commit-Queue: Zhenyao Mo <zmo@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Maggie Chen <magchen@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Cr-Commit-Position: refs/heads/master@{#594561}

components/viz/service/gl/gpu_service_impl.cc

@@ -537,8 +537,9 @@ void GpuServiceImpl::GetGpuSupportedRuntimeVersion(
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   DCHECK(command_line->HasSwitch("disable-gpu-sandbox") || in_host_process());
 
-  gpu::RecordGpuSupportedRuntimeVersionHistograms(&gpu_info_);
-  std::move(callback).Run(gpu_info_);
+  gpu::RecordGpuSupportedRuntimeVersionHistograms(
+      &gpu_info_.dx12_vulkan_version_info);
+  std::move(callback).Run(gpu_info_.dx12_vulkan_version_info);
   if (!in_host_process()) {
     // The unsandboxed GPU process fulfilled its duty. Bye bye.
     ExitProcess();

content/browser/devtools/protocol/system_info_handler.cc

@@ -90,6 +90,10 @@ class AuxGPUInfoEnumerator : public gpu::GPUInfo::Enumerator {
 
   void EndOverlayCapability() override {}
 
+  void BeginDx12VulkanVersionInfo() override {}
+
+  void EndDx12VulkanVersionInfo() override {}
+
   void BeginAuxAttributes() override {
     in_aux_attributes_ = true;
   }

content/browser/gpu/gpu_data_manager_impl.cc

@@ -109,9 +109,10 @@ void GpuDataManagerImpl::UpdateDxDiagNode(
   private_->UpdateDxDiagNode(dx_diagnostics);
 }
 
-void GpuDataManagerImpl::UpdateDX12VulkanInfo(const gpu::GPUInfo& gpu_info) {
+void GpuDataManagerImpl::UpdateDx12VulkanInfo(
+    const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info) {
   base::AutoLock auto_lock(lock_);
-  private_->UpdateDX12VulkanInfo(gpu_info);
+  private_->UpdateDx12VulkanInfo(dx12_vulkan_version_info);
 }
 #endif
 

content/browser/gpu/gpu_data_manager_impl.h

@@ -78,7 +78,8 @@ class CONTENT_EXPORT GpuDataManagerImpl : public GpuDataManager {
       const gpu::GPUInfo& gpu_info,
       const base::Optional<gpu::GPUInfo>& gpu_info_for_hardware_gpu);
 #if defined(OS_WIN)
-  void UpdateDX12VulkanInfo(const gpu::GPUInfo& gpu_info);
+  void UpdateDx12VulkanInfo(
+      const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info);
   void UpdateDxDiagNode(const gpu::DxDiagNode& dx_diagnostics);
 #endif
   // Update the GPU feature info. This updates the blacklist and enabled status

content/browser/gpu/gpu_data_manager_impl_private.cc

@@ -265,17 +265,19 @@ void UpdateDxDiagNodeOnIO(const gpu::DxDiagNode& dx_diagnostics) {
           dx_diagnostics));
 }
 
-void UpdateDX12VulkanInfoOnIO(const gpu::GPUInfo& gpu_info) {
+void UpdateDx12VulkanInfoOnIO(
+    const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info) {
   // This function is called on the IO thread, but GPUInfo on GpuDataManagerImpl
   // should be updated on the UI thread since it can call into functions that
   // expect to run in the UI thread.
   base::PostTaskWithTraits(
       FROM_HERE, {BrowserThread::UI},
       base::BindOnce(
-          [](const gpu::GPUInfo& gpu_info) {
-            GpuDataManagerImpl::GetInstance()->UpdateDX12VulkanInfo(gpu_info);
+          [](const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info) {
+            GpuDataManagerImpl::GetInstance()->UpdateDx12VulkanInfo(
+                dx12_vulkan_version_info);
           },
-          gpu_info));
+          dx12_vulkan_version_info));
 }
 #endif
 }  // anonymous namespace
@@ -417,7 +419,7 @@ void GpuDataManagerImplPrivate::RequestGpuSupportedRuntimeVersion() {
     if (!host)
       return;
     host->gpu_service()->GetGpuSupportedRuntimeVersion(
-        base::BindOnce(&UpdateDX12VulkanInfoOnIO));
+        base::BindOnce(&UpdateDx12VulkanInfoOnIO));
   });
 
   base::PostDelayedTaskWithTraits(FROM_HERE, {BrowserThread::IO},
@@ -494,23 +496,18 @@ void GpuDataManagerImplPrivate::UpdateGpuInfo(
   // If GPU process crashes and launches again, GPUInfo will be sent back from
   // the new GPU process again, and may overwrite the DX12, Vulkan, DxDiagNode
   // info we already collected. This is to make sure it doesn't happen.
-  uint32_t d3d12_feature_level = gpu_info_.d3d12_feature_level;
-  uint32_t vulkan_version = gpu_info_.vulkan_version;
   gpu::DxDiagNode dx_diagnostics = gpu_info_.dx_diagnostics;
+  gpu::Dx12VulkanVersionInfo dx12_vulkan_version_info =
+      gpu_info_.dx12_vulkan_version_info;
 #endif
   gpu_info_ = gpu_info;
 #if defined(OS_WIN)
-  if (d3d12_feature_level) {
-    gpu_info_.d3d12_feature_level = d3d12_feature_level;
-    gpu_info_.supports_dx12 = true;
-  }
-  if (vulkan_version) {
-    gpu_info_.vulkan_version = vulkan_version;
-    gpu_info_.supports_vulkan = true;
-  }
   if (!dx_diagnostics.IsEmpty()) {
     gpu_info_.dx_diagnostics = dx_diagnostics;
   }
+  if (!dx12_vulkan_version_info.IsEmpty()) {
+    gpu_info_.dx12_vulkan_version_info = dx12_vulkan_version_info;
+  }
 #endif  // OS_WIN
 
   if (!gpu_info_for_hardware_gpu_.IsInitialized()) {
@@ -536,16 +533,9 @@ void GpuDataManagerImplPrivate::UpdateDxDiagNode(
   NotifyGpuInfoUpdate();
 }
 
-void GpuDataManagerImplPrivate::UpdateDX12VulkanInfo(
-    const gpu::GPUInfo& gpu_info) {
-  if (gpu_info.d3d12_feature_level) {
-    gpu_info_.d3d12_feature_level = gpu_info.d3d12_feature_level;
-    gpu_info_.supports_dx12 = true;
-  }
-  if (gpu_info.vulkan_version) {
-    gpu_info_.vulkan_version = gpu_info.vulkan_version;
-    gpu_info_.supports_vulkan = true;
-  }
+void GpuDataManagerImplPrivate::UpdateDx12VulkanInfo(
+    const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info) {
+  gpu_info_.dx12_vulkan_version_info = dx12_vulkan_version_info;
   // No need to call GetContentClient()->SetGpuInfo().
   NotifyGpuInfoUpdate();
 }

content/browser/gpu/gpu_data_manager_impl_private.h

@@ -65,7 +65,8 @@ class CONTENT_EXPORT GpuDataManagerImplPrivate {
       const base::Optional<gpu::GPUInfo>& optional_gpu_info_for_hardware_gpu);
 #if defined(OS_WIN)
   void UpdateDxDiagNode(const gpu::DxDiagNode& dx_diagnostics);
-  void UpdateDX12VulkanInfo(const gpu::GPUInfo& gpu_info);
+  void UpdateDx12VulkanInfo(
+      const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info);
 #endif
   void UpdateGpuFeatureInfo(const gpu::GpuFeatureInfo& gpu_feature_info,
                             const base::Optional<gpu::GpuFeatureInfo>&

content/browser/gpu/gpu_internals_ui.cc

@@ -213,11 +213,12 @@ std::unique_ptr<base::ListValue> BasicGpuInfoAsListValue(
 
   basic_info->Append(NewDescriptionValuePair(
       "Driver D3D12 feature level",
-      D3dFeaturelevelToString(gpu_info.d3d12_feature_level)));
+      D3dFeaturelevelToString(
+          gpu_info.dx12_vulkan_version_info.d3d12_feature_level)));
 
-  basic_info->Append(
-      NewDescriptionValuePair("Driver Vulkan API version",
-                              VulkanVersionToString(gpu_info.vulkan_version)));
+  basic_info->Append(NewDescriptionValuePair(
+      "Driver Vulkan API version",
+      VulkanVersionToString(gpu_info.dx12_vulkan_version_info.vulkan_version)));
 #endif
 
   basic_info->Append(

gpu/config/gpu_info.cc

@@ -58,6 +58,17 @@ void EnumerateOverlayCapability(const gpu::OverlayCapability& cap,
   enumerator->AddInt("isScalingSupported", cap.is_scaling_supported);
   enumerator->EndOverlayCapability();
 }
+
+void EnumerateDx12VulkanVersionInfo(const gpu::Dx12VulkanVersionInfo& info,
+                                    gpu::GPUInfo::Enumerator* enumerator) {
+  enumerator->BeginDx12VulkanVersionInfo();
+  enumerator->AddBool("supportsDx12", info.supports_dx12);
+  enumerator->AddBool("supportsVulkan", info.supports_vulkan);
+  enumerator->AddInt("dx12FeatureLevel",
+                     static_cast<int>(info.d3d12_feature_level));
+  enumerator->AddInt("vulkanVersion", static_cast<int>(info.vulkan_version));
+  enumerator->EndDx12VulkanVersionInfo();
+}
 #endif
 
 }  // namespace
@@ -179,10 +190,7 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
     bool supports_overlays;
     OverlayCapabilities overlay_capabilities;
     DxDiagNode dx_diagnostics;
-    bool supports_dx12;
-    bool supports_vulkan;
-    uint32_t d3d12_feature_level;
-    uint32_t vulkan_version;
+    Dx12VulkanVersionInfo dx12_vulkan_version_info;
 #endif
 
     VideoDecodeAcceleratorCapabilities video_decode_accelerator_capabilities;
@@ -242,10 +250,7 @@ void GPUInfo::EnumerateFields(Enumerator* enumerator) const {
   enumerator->AddBool("supportsOverlays", supports_overlays);
   for (const auto& cap : overlay_capabilities)
     EnumerateOverlayCapability(cap, enumerator);
-  enumerator->AddBool("supportsDX12", supports_dx12);
-  enumerator->AddBool("supportsVulkan", supports_vulkan);
-  enumerator->AddInt("d3dFeatureLevel", d3d12_feature_level);
-  enumerator->AddInt("vulkanVersion", vulkan_version);
+  EnumerateDx12VulkanVersionInfo(dx12_vulkan_version_info, enumerator);
 #endif
   enumerator->AddInt("videoDecodeAcceleratorFlags",
                      video_decode_accelerator_capabilities.flags);

gpu/config/gpu_info.h

@@ -104,6 +104,22 @@ struct GPU_EXPORT OverlayCapability {
 };
 using OverlayCapabilities = std::vector<OverlayCapability>;
 
+struct GPU_EXPORT Dx12VulkanVersionInfo {
+  bool IsEmpty() const { return !d3d12_feature_level && !vulkan_version; }
+
+  // True if the GPU driver supports DX12.
+  bool supports_dx12 = false;
+
+  // True if the GPU driver supports Vulkan.
+  bool supports_vulkan = false;
+
+  // The supported d3d feature level in the gpu driver;
+  uint32_t d3d12_feature_level = 0;
+
+  // The support Vulkan API version in the gpu driver;
+  uint32_t vulkan_version = 0;
+};
+
 struct GPU_EXPORT GPUInfo {
   struct GPU_EXPORT GPUDevice {
     GPUDevice();
@@ -245,17 +261,7 @@ struct GPU_EXPORT GPUInfo {
   // The information returned by the DirectX Diagnostics Tool.
   DxDiagNode dx_diagnostics;
 
-  // True if the GPU driver supports DX12.
-  bool supports_dx12 = false;
-
-  // True if the GPU driver supports Vulkan.
-  bool supports_vulkan = false;
-
-  // The supported d3d feature level in the gpu driver;
-  uint32_t d3d12_feature_level = 0;
-
-  // The support Vulkan API version in the gpu driver;
-  uint32_t vulkan_version = 0;
+  Dx12VulkanVersionInfo dx12_vulkan_version_info;
 #endif
 
   VideoDecodeAcceleratorCapabilities video_decode_accelerator_capabilities;
@@ -312,6 +318,9 @@ struct GPU_EXPORT GPUInfo {
     virtual void BeginOverlayCapability() = 0;
     virtual void EndOverlayCapability() = 0;
 
+    virtual void BeginDx12VulkanVersionInfo() = 0;
+    virtual void EndDx12VulkanVersionInfo() = 0;
+
    protected:
     virtual ~Enumerator() = default;
   };

gpu/config/gpu_info_collector.h

@@ -42,7 +42,8 @@ GPU_EXPORT bool CollectContextGraphicsInfo(
 #if defined(OS_WIN)
 // Collect the DirectX Disagnostics information about the attached displays.
 GPU_EXPORT bool GetDxDiagnostics(DxDiagNode* output);
-GPU_EXPORT void RecordGpuSupportedRuntimeVersionHistograms(GPUInfo* gpu_info);
+GPU_EXPORT void RecordGpuSupportedRuntimeVersionHistograms(
+    Dx12VulkanVersionInfo* dx12_vulkan_version_info);
 #endif  // OS_WIN
 
 // Create a GL context and collect GL strings and versions.

gpu/config/gpu_info_collector_win.cc

@@ -280,10 +280,10 @@ bool CollectDriverInfoD3D(const std::wstring& device_id, GPUInfo* gpu_info) {
 }
 
 // DirectX 12 are included with Windows 10 and Server 2016.
-void GetGpuSupportedD3D12Version(GPUInfo* gpu_info) {
+void GetGpuSupportedD3D12Version(Dx12VulkanVersionInfo* info) {
   TRACE_EVENT0("gpu", "GetGpuSupportedD3D12Version");
-  gpu_info->supports_dx12 = false;
-  gpu_info->d3d12_feature_level = 0;
+  info->supports_dx12 = false;
+  info->d3d12_feature_level = 0;
 
   base::NativeLibrary d3d12_library =
       base::LoadNativeLibrary(base::FilePath(L"d3d12.dll"), nullptr);
@@ -305,8 +305,8 @@ void GetGpuSupportedD3D12Version(GPUInfo* gpu_info) {
     for (auto level : feature_levels) {
       if (SUCCEEDED(D3D12CreateDevice(nullptr, level, _uuidof(ID3D12Device),
                                       nullptr))) {
-        gpu_info->d3d12_feature_level = level;
-        gpu_info->supports_dx12 = true;
+        info->d3d12_feature_level = level;
+        info->supports_dx12 = true;
         break;
       }
     }
@@ -315,7 +315,7 @@ void GetGpuSupportedD3D12Version(GPUInfo* gpu_info) {
   base::UnloadNativeLibrary(d3d12_library);
 }
 
-bool BadAMDVulkanDriverVersion(GPUInfo* gpu_info) {
+bool BadAMDVulkanDriverVersion() {
   // Both 32-bit and 64-bit dll are broken. If 64-bit doesn't exist,
   // 32-bit dll will be used to detect the AMD Vulkan driver.
   const base::FilePath kAmdDriver64(FILE_PATH_LITERAL("amdvlk64.dll"));
@@ -347,7 +347,7 @@ bool BadAMDVulkanDriverVersion(GPUInfo* gpu_info) {
   return false;
 }
 
-bool BadVulkanDllVersion(GPUInfo* gpu_info) {
+bool BadVulkanDllVersion() {
   std::unique_ptr<FileVersionInfoWin> file_version_info(
       static_cast<FileVersionInfoWin*>(
           FileVersionInfoWin::CreateFileVersionInfo(
@@ -437,7 +437,7 @@ bool InitVulkanInstanceProc(
 }
 
 void GetGpuSupportedVulkanVersionAndExtensions(
-    GPUInfo* gpu_info,
+    Dx12VulkanVersionInfo* info,
     const std::vector<const char*>& requested_vulkan_extensions,
     std::vector<bool>* extension_support) {
   TRACE_EVENT0("gpu", "GetGpuSupportedVulkanVersionAndExtensions");
@@ -450,18 +450,18 @@ void GetGpuSupportedVulkanVersionAndExtensions(
   PFN_vkDestroyInstance vkDestroyInstance;
   VkInstance vk_instance = VK_NULL_HANDLE;
   uint32_t physical_device_count = 0;
-  gpu_info->supports_vulkan = false;
-  gpu_info->vulkan_version = 0;
+  info->supports_vulkan = false;
+  info->vulkan_version = 0;
 
   // Skip if the system has an older AMD Vulkan driver amdvlk64.dll or
   // amdvlk32.dll which crashes when vkCreateInstance() is called. This bug has
   // been fixed in the latest AMD driver.
-  if (BadAMDVulkanDriverVersion(gpu_info)) {
+  if (BadAMDVulkanDriverVersion()) {
     return;
   }
 
   // Some early versions of vulkan-1.dll might crash
-  if (BadVulkanDllVersion(gpu_info)) {
+  if (BadVulkanDllVersion()) {
     return;
   }
 
@@ -487,8 +487,8 @@ void GetGpuSupportedVulkanVersionAndExtensions(
       result = vkEnumeratePhysicalDevices(vk_instance, &physical_device_count,
                                           nullptr);
       if (result == VK_SUCCESS && physical_device_count > 0) {
-        gpu_info->supports_vulkan = true;
-        gpu_info->vulkan_version = app_info.apiVersion;
+        info->supports_vulkan = true;
+        info->vulkan_version = app_info.apiVersion;
         break;
       } else {
         vkDestroyInstance(vk_instance, nullptr);
@@ -498,7 +498,7 @@ void GetGpuSupportedVulkanVersionAndExtensions(
   }
 
   // Check whether the requested_vulkan_extensions are supported
-  if (gpu_info->supports_vulkan) {
+  if (info->supports_vulkan) {
     std::vector<VkPhysicalDevice> physical_devices(physical_device_count);
     vkEnumeratePhysicalDevices(vk_instance, &physical_device_count,
                                physical_devices.data());
@@ -533,26 +533,26 @@ void GetGpuSupportedVulkanVersionAndExtensions(
   base::UnloadNativeLibrary(vulkan_library);
 }
 
-void RecordGpuSupportedRuntimeVersionHistograms(GPUInfo* gpu_info) {
+void RecordGpuSupportedRuntimeVersionHistograms(Dx12VulkanVersionInfo* info) {
   // D3D
-  GetGpuSupportedD3D12Version(gpu_info);
-  UMA_HISTOGRAM_BOOLEAN("GPU.SupportsDX12", gpu_info->supports_dx12);
+  GetGpuSupportedD3D12Version(info);
+  UMA_HISTOGRAM_BOOLEAN("GPU.SupportsDX12", info->supports_dx12);
   UMA_HISTOGRAM_ENUMERATION(
       "GPU.D3D12FeatureLevel",
-      ConvertToHistogramFeatureLevel(gpu_info->d3d12_feature_level));
+      ConvertToHistogramFeatureLevel(info->d3d12_feature_level));
 
   // Vulkan
   const std::vector<const char*> vulkan_extensions = {
       "VK_KHR_external_memory_win32", "VK_KHR_external_semaphore_win32",
       "VK_KHR_win32_keyed_mutex"};
   std::vector<bool> extension_support(vulkan_extensions.size(), false);
-  GetGpuSupportedVulkanVersionAndExtensions(gpu_info, vulkan_extensions,
+  GetGpuSupportedVulkanVersionAndExtensions(info, vulkan_extensions,
                                             &extension_support);
 
-  UMA_HISTOGRAM_BOOLEAN("GPU.SupportsVulkan", gpu_info->supports_vulkan);
+  UMA_HISTOGRAM_BOOLEAN("GPU.SupportsVulkan", info->supports_vulkan);
   UMA_HISTOGRAM_ENUMERATION(
       "GPU.VulkanVersion",
-      ConvertToHistogramVulkanVersion(gpu_info->vulkan_version));
+      ConvertToHistogramVulkanVersion(info->vulkan_version));
 
   for (size_t i = 0; i < vulkan_extensions.size(); ++i) {
     std::string name = "GPU.VulkanExtSupport.";

gpu/ipc/common/gpu_info.mojom

@@ -89,6 +89,14 @@ struct OverlayCapability {
   bool is_scaling_supported;
 };
 
+// gpu::Dx12VulkanVersionInfo
+struct Dx12VulkanVersionInfo {
+  bool supports_dx12;
+  bool supports_vulkan;
+  uint32 d3d12_feature_level;
+  uint32 vulkan_version;
+};
+
 // Corresponds to |gpu::GPUInfo| in gpu/config/gpu_info.h
 struct GpuInfo {
   mojo_base.mojom.TimeDelta initialization_time;
@@ -124,13 +132,7 @@ struct GpuInfo {
   [EnableIf=is_win]
   DxDiagNode dx_diagnostics;
   [EnableIf=is_win]
-  bool supports_dx12;
-  [EnableIf=is_win]
-  bool supports_vulkan;
-  [EnableIf=is_win]
-  uint32 d3d12_feature_level;
-  [EnableIf=is_win]
-  uint32 vulkan_version;
+  Dx12VulkanVersionInfo dx12_vulkan_version_info;
   VideoDecodeAcceleratorCapabilities video_decode_accelerator_capabilities;
   array<VideoEncodeAcceleratorSupportedProfile>
     video_encode_accelerator_supported_profiles;

gpu/ipc/common/gpu_info.typemap

@@ -14,6 +14,7 @@ public_deps = [
 ]
 type_mappings = [
   "gpu.mojom.CollectInfoResult=gpu::CollectInfoResult",
+  "gpu.mojom.Dx12VulkanVersionInfo=gpu::Dx12VulkanVersionInfo",
   "gpu.mojom.GpuDevice=gpu::GPUInfo::GPUDevice",
   "gpu.mojom.GpuInfo=gpu::GPUInfo",
   "gpu.mojom.VideoCodecProfile=gpu::VideoCodecProfile",

gpu/ipc/common/gpu_info_struct_traits.cc

@@ -258,6 +258,18 @@ bool StructTraits<
   out->is_scaling_supported = data.is_scaling_supported();
   return data.ReadFormat(&out->format);
 }
+
+// static
+bool StructTraits<gpu::mojom::Dx12VulkanVersionInfoDataView,
+                  gpu::Dx12VulkanVersionInfo>::
+    Read(gpu::mojom::Dx12VulkanVersionInfoDataView data,
+         gpu::Dx12VulkanVersionInfo* out) {
+  out->supports_dx12 = data.supports_dx12();
+  out->supports_vulkan = data.supports_vulkan();
+  out->d3d12_feature_level = data.d3d12_feature_level();
+  out->vulkan_version = data.vulkan_version();
+  return true;
+}
 #endif
 
 bool StructTraits<gpu::mojom::GpuInfoDataView, gpu::GPUInfo>::Read(
@@ -285,10 +297,6 @@ bool StructTraits<gpu::mojom::GpuInfoDataView, gpu::GPUInfo>::Read(
 #if defined(OS_WIN)
   out->direct_composition = data.direct_composition();
   out->supports_overlays = data.supports_overlays();
-  out->supports_dx12 = data.supports_dx12();
-  out->supports_vulkan = data.supports_vulkan();
-  out->d3d12_feature_level = data.d3d12_feature_level();
-  out->vulkan_version = data.vulkan_version();
 #endif
 
   return data.ReadInitializationTime(&out->initialization_time) &&
@@ -309,6 +317,7 @@ bool StructTraits<gpu::mojom::GpuInfoDataView, gpu::GPUInfo>::Read(
 #if defined(OS_WIN)
          data.ReadOverlayCapabilities(&out->overlay_capabilities) &&
          data.ReadDxDiagnostics(&out->dx_diagnostics) &&
+         data.ReadDx12VulkanVersionInfo(&out->dx12_vulkan_version_info) &&
 #endif
          data.ReadVideoDecodeAcceleratorCapabilities(
              &out->video_decode_accelerator_capabilities) &&

gpu/ipc/common/gpu_info_struct_traits.h

@@ -163,6 +163,29 @@ struct StructTraits<gpu::mojom::OverlayCapabilityDataView,
   }
 };
 
+template <>
+struct StructTraits<gpu::mojom::Dx12VulkanVersionInfoDataView,
+                    gpu::Dx12VulkanVersionInfo> {
+  static bool Read(gpu::mojom::Dx12VulkanVersionInfoDataView data,
+                   gpu::Dx12VulkanVersionInfo* out);
+
+  static bool supports_dx12(const gpu::Dx12VulkanVersionInfo& input) {
+    return input.supports_dx12;
+  }
+
+  static bool supports_vulkan(const gpu::Dx12VulkanVersionInfo& input) {
+    return input.supports_vulkan;
+  }
+
+  static uint32_t d3d12_feature_level(const gpu::Dx12VulkanVersionInfo& input) {
+    return input.d3d12_feature_level;
+  }
+
+  static uint32_t vulkan_version(const gpu::Dx12VulkanVersionInfo& input) {
+    return input.vulkan_version;
+  }
+};
+
 template <>
 struct StructTraits<gpu::mojom::GpuInfoDataView, gpu::GPUInfo> {
   static bool Read(gpu::mojom::GpuInfoDataView data, gpu::GPUInfo* out);
@@ -278,20 +301,9 @@ struct StructTraits<gpu::mojom::GpuInfoDataView, gpu::GPUInfo> {
     return input.dx_diagnostics;
   }
 
-  static bool supports_dx12(const gpu::GPUInfo& input) {
-    return input.supports_dx12;
-  }
-
-  static bool supports_vulkan(const gpu::GPUInfo& input) {
-    return input.supports_vulkan;
-  }
-
-  static uint32_t d3d12_feature_level(const gpu::GPUInfo& input) {
-    return input.d3d12_feature_level;
-  }
-
-  static uint32_t vulkan_version(const gpu::GPUInfo& input) {
-    return input.vulkan_version;
+  static const gpu::Dx12VulkanVersionInfo& dx12_vulkan_version_info(
+      const gpu::GPUInfo& input) {
+    return input.dx12_vulkan_version_info;
   }
 #endif
 

services/viz/privileged/interfaces/gl/gpu_service.mojom

@@ -80,7 +80,8 @@ interface GpuService {
   [EnableIf=is_win]
   RequestCompleteGpuInfo() => (gpu.mojom.DxDiagNode dx_diagnostics);
   [EnableIf=is_win]
-  GetGpuSupportedRuntimeVersion() => (gpu.mojom.GpuInfo gpu_info);
+  GetGpuSupportedRuntimeVersion()
+      => (gpu.mojom.Dx12VulkanVersionInfo dx12_vulkan_version_info);
 
   // Requests that the GPU process query system availability of HDR output and
   // return it.