ozone: demo: Fix build after vulkan bindings change

The method of calling functions now uses a macro to hide the
gpu::VulkanFunctionPointers. Fix the ozone_demo build after
this change.

Bug: none
Test: compile
Change-Id: Ia5aa9666eb3925135f89ece810862492b305c403
Reviewed-on: https://chromium-review.googlesource.com/1124991Reviewed-by: Chris Blume <cblume@chromium.org>
Commit-Queue: Michael Spang <spang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572368}

ui/ozone/demo/vulkan_overlay_renderer.cc

@@ -43,7 +43,6 @@ VulkanOverlayRenderer::VulkanOverlayRenderer(
     : RendererBase(widget, size),
       surface_factory_ozone_(surface_factory_ozone),
       vulkan_implementation_(vulkan_implementation),
-      vulkan_function_pointers_(gpu::GetVulkanFunctionPointers()),
       overlay_surface_(std::move(overlay_surface)),
       weak_ptr_factory_(this) {}
 
@@ -98,9 +97,8 @@ bool VulkanOverlayRenderer::Initialize() {
       .dependencyCount = 0,
   };
 
-  CHECK_EQ(vulkan_function_pointers_->vkCreateRenderPass(
-               device_queue_->GetVulkanDevice(), &render_pass_create_info,
-               nullptr, &render_pass_),
+  CHECK_EQ(vkCreateRenderPass(device_queue_->GetVulkanDevice(),
+                              &render_pass_create_info, nullptr, &render_pass_),
            VK_SUCCESS);
 
   command_pool_ = std::make_unique<gpu::VulkanCommandPool>(device_queue_.get());
@@ -122,14 +120,10 @@ void VulkanOverlayRenderer::DestroyBuffers() {
   for (std::unique_ptr<Buffer>& buffer : buffers_) {
     if (!buffer)
       continue;
-    vulkan_function_pointers_->vkDestroyFramebuffer(
-        vk_device, buffer->vk_framebuffer(), nullptr);
-    vulkan_function_pointers_->vkDestroyImageView(
-        vk_device, buffer->vk_image_view(), nullptr);
-    vulkan_function_pointers_->vkDestroyImage(vk_device, buffer->vk_image(),
-                                              nullptr);
-    vulkan_function_pointers_->vkFreeMemory(
-        vk_device, buffer->vk_device_memory(), nullptr);
+    vkDestroyFramebuffer(vk_device, buffer->vk_framebuffer(), nullptr);
+    vkDestroyImageView(vk_device, buffer->vk_image_view(), nullptr);
+    vkDestroyImage(vk_device, buffer->vk_image(), nullptr);
+    vkFreeMemory(vk_device, buffer->vk_device_memory(), nullptr);
     buffer.reset();
   }
 }
@@ -140,9 +134,9 @@ void VulkanOverlayRenderer::RecreateBuffers() {
   DestroyBuffers();
 
   for (auto& buffer : buffers_) {
-    buffer = Buffer::Create(surface_factory_ozone_, vulkan_function_pointers_,
-                            device_queue_->GetVulkanDevice(), render_pass_,
-                            widget_, size_);
+    buffer =
+        Buffer::Create(surface_factory_ozone_, device_queue_->GetVulkanDevice(),
+                       render_pass_, widget_, size_);
     CHECK(buffer);
   }
 }
@@ -171,18 +165,18 @@ void VulkanOverlayRenderer::RenderFrame() {
     begin_info.clearValueCount = 1;
     begin_info.pClearValues = &clear_value;
 
-    vulkan_function_pointers_->vkCmdBeginRenderPass(
-        recorder.handle(), &begin_info, VK_SUBPASS_CONTENTS_INLINE);
+    vkCmdBeginRenderPass(recorder.handle(), &begin_info,
+                         VK_SUBPASS_CONTENTS_INLINE);
 
-    vulkan_function_pointers_->vkCmdEndRenderPass(recorder.handle());
+    vkCmdEndRenderPass(recorder.handle());
   }
 
   VkSemaphoreCreateInfo sem_create_info = {
       .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
   };
   VkSemaphore semaphore;
-  vulkan_function_pointers_->vkCreateSemaphore(
-      device_queue_->GetVulkanDevice(), &sem_create_info, NULL, &semaphore);
+  vkCreateSemaphore(device_queue_->GetVulkanDevice(), &sem_create_info, NULL,
+                    &semaphore);
 
   command_buffer_->Submit(1, &semaphore, 0, nullptr);
 
@@ -264,7 +258,6 @@ VulkanOverlayRenderer::Buffer::~Buffer() {}
 std::unique_ptr<VulkanOverlayRenderer::Buffer>
 VulkanOverlayRenderer::Buffer::Create(
     SurfaceFactoryOzone* surface_factory_ozone,
-    const gpu::VulkanFunctionPointers* vulkan_function_pointers,
     VkDevice vk_device,
     VkRenderPass vk_render_pass,
     gfx::AcceleratedWidget widget,
@@ -275,8 +268,8 @@ VulkanOverlayRenderer::Buffer::Create(
   VkDeviceMemory vk_device_memory = VK_NULL_HANDLE;
   scoped_refptr<gfx::NativePixmap> native_pixmap =
       surface_factory_ozone->CreateNativePixmapForVulkan(
-          widget, size, format, gfx::BufferUsage::SCANOUT,
-          vulkan_function_pointers, vk_device, &vk_device_memory, &vk_image);
+          widget, size, format, gfx::BufferUsage::SCANOUT, vk_device,
+          &vk_device_memory, &vk_image);
   if (!native_pixmap) {
     LOG(FATAL)
         << "Failed to create a presentable buffer for rendering with vulkan";
@@ -306,8 +299,8 @@ VulkanOverlayRenderer::Buffer::Create(
 
   VkResult result;
   VkImageView vk_image_view = VK_NULL_HANDLE;
-  result = vulkan_function_pointers->vkCreateImageView(
-      vk_device, &vk_image_view_create_info, nullptr, &vk_image_view);
+  result = vkCreateImageView(vk_device, &vk_image_view_create_info, nullptr,
+                             &vk_image_view);
   if (result != VK_SUCCESS) {
     LOG(FATAL) << "Failed to create a Vulkan image view.";
   }
@@ -322,8 +315,8 @@ VulkanOverlayRenderer::Buffer::Create(
   };
 
   VkFramebuffer vk_framebuffer = VK_NULL_HANDLE;
-  result = vulkan_function_pointers->vkCreateFramebuffer(
-      vk_device, &vk_framebuffer_create_info, nullptr, &vk_framebuffer);
+  result = vkCreateFramebuffer(vk_device, &vk_framebuffer_create_info, nullptr,
+                               &vk_framebuffer);
   if (result != VK_SUCCESS) {
     LOG(FATAL) << "Failed to create a Vulkan framebuffer.";
   }

ui/ozone/demo/vulkan_overlay_renderer.h

@@ -10,7 +10,6 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "gpu/vulkan/vulkan_function_pointers.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/presentation_feedback.h"
 #include "ui/gfx/swap_result.h"
@@ -65,7 +64,6 @@ class VulkanOverlayRenderer : public RendererBase {
 
     static std::unique_ptr<Buffer> Create(
         SurfaceFactoryOzone* surface_factory_ozone,
-        const gpu::VulkanFunctionPointers* vulkan_function_pointers,
         VkDevice vk_device,
         VkRenderPass vk_render_pass,
         gfx::AcceleratedWidget widget,
@@ -96,7 +94,6 @@ class VulkanOverlayRenderer : public RendererBase {
 
   SurfaceFactoryOzone* const surface_factory_ozone_;
   gpu::VulkanImplementation* const vulkan_implementation_;
-  const gpu::VulkanFunctionPointers* const vulkan_function_pointers_;
   std::unique_ptr<gpu::VulkanDeviceQueue> device_queue_;
   std::unique_ptr<gpu::VulkanCommandPool> command_pool_;
   std::unique_ptr<gpu::VulkanCommandBuffer> command_buffer_;

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

@@ -145,7 +145,6 @@ scoped_refptr<gfx::NativePixmap> GbmSurfaceFactory::CreateNativePixmapForVulkan(
     gfx::Size size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
-    const gpu::VulkanFunctionPointers* vulkan_function_pointers,
     VkDevice vk_device,
     VkDeviceMemory* vk_device_memory,
     VkImage* vk_image) {
@@ -157,8 +156,7 @@ scoped_refptr<gfx::NativePixmap> GbmSurfaceFactory::CreateNativePixmapForVulkan(
 
   PFN_vkCreateDmaBufImageINTEL create_dma_buf_image_intel =
       reinterpret_cast<PFN_vkCreateDmaBufImageINTEL>(
-          vulkan_function_pointers->vkGetDeviceProcAddr(
-              vk_device, "vkCreateDmaBufImageINTEL"));
+          vkGetDeviceProcAddr(vk_device, "vkCreateDmaBufImageINTEL"));
   if (!create_dma_buf_image_intel) {
     LOG(ERROR) << "Scanout buffers can only be imported into vulkan when "
                   "vkCreateDmaBufImageINTEL is available.";

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

@@ -46,7 +46,6 @@ class GbmSurfaceFactory : public SurfaceFactoryOzone {
       gfx::Size size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
-      const gpu::VulkanFunctionPointers* vulkan_function_pointers,
       VkDevice vk_device,
       VkDeviceMemory* vk_device_memory,
       VkImage* vk_image) override;

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

@@ -38,7 +38,7 @@ bool VulkanImplementationGbm::InitializeVulkanInstance() {
 
   vkGetPhysicalDeviceExternalFencePropertiesKHR_ =
       reinterpret_cast<PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR>(
-          vulkan_function_pointers->vkGetInstanceProcAddr(
+          vkGetInstanceProcAddr(
               vulkan_instance_.vk_instance(),
               "vkGetPhysicalDeviceExternalFencePropertiesKHR"));
   if (!vkGetPhysicalDeviceExternalFencePropertiesKHR_) {
@@ -47,8 +47,7 @@ bool VulkanImplementationGbm::InitializeVulkanInstance() {
   }
 
   vkGetFenceFdKHR_ = reinterpret_cast<PFN_vkGetFenceFdKHR>(
-      vulkan_function_pointers->vkGetInstanceProcAddr(
-          vulkan_instance_.vk_instance(), "vkGetFenceFdKHR"));
+      vkGetInstanceProcAddr(vulkan_instance_.vk_instance(), "vkGetFenceFdKHR"));
   if (!vkGetFenceFdKHR_) {
     vulkan_instance_.Destroy();
     return false;
@@ -101,8 +100,8 @@ VkFence VulkanImplementationGbm::CreateVkFenceForGpuFence(VkDevice vk_device) {
       VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
 
   VkFence fence;
-  VkResult result = gpu::GetVulkanFunctionPointers()->vkCreateFence(
-      vk_device, &fence_create_info, nullptr, &fence);
+  VkResult result =
+      vkCreateFence(vk_device, &fence_create_info, nullptr, &fence);
   if (result != VK_SUCCESS) {
     DLOG(ERROR) << "vkCreateFence failed: " << result;
     return VK_NULL_HANDLE;

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

@@ -28,7 +28,7 @@ class VulkanImplementationGbm : public gpu::VulkanImplementation {
       uint32_t queue_family_index) override;
   std::vector<const char*> GetRequiredDeviceExtensions() override;
   VkFence CreateVkFenceForGpuFence(VkDevice vk_device) override;
-  virtual std::unique_ptr<gfx::GpuFence> ExportVkFenceToGpuFence(
+  std::unique_ptr<gfx::GpuFence> ExportVkFenceToGpuFence(
       VkDevice vk_device,
       VkFence vk_fence) override;
 

ui/ozone/public/surface_factory_ozone.cc

@@ -43,7 +43,6 @@ SurfaceFactoryOzone::CreateNativePixmapForVulkan(
     gfx::Size size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
-    const gpu::VulkanFunctionPointers* vulkan_function_pointers,
     VkDevice vk_device,
     VkDeviceMemory* vk_device_memory,
     VkImage* vk_image) {

ui/ozone/public/surface_factory_ozone.h

@@ -32,10 +32,6 @@ namespace gfx {
 class NativePixmap;
 }
 
-namespace gpu {
-struct VulkanFunctionPointers;
-}
-
 namespace ui {
 
 class SurfaceOzoneCanvas;
@@ -93,7 +89,6 @@ class OZONE_BASE_EXPORT SurfaceFactoryOzone {
       gfx::Size size,
       gfx::BufferFormat format,
       gfx::BufferUsage usage,
-      const gpu::VulkanFunctionPointers* vulkan_function_pointers,
       VkDevice vk_device,
       VkDeviceMemory* vk_device_memory,
       VkImage* vk_image);