ozone: demo: Rewrite VulkanRenderer post VulkanRenderPass deprecation

The vulkan rendering code in ozone_demo uses code which has been removed
such as gpu::VulkanSwapChain and gpu::VulkanImageView. Rewrite it to
manage its own image views, render passes, and framebuffers just like
VulkanOverlayRenderer has to.

Bug: 861853
Test: ozone_demo --ozone-platform=x11 --enable-vulkan

Change-Id: I358912b02a11d902803cc0a0682da769b47a5a65
Reviewed-on: https://chromium-review.googlesource.com/1228959
Commit-Queue: Michael Spang <spang@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#592225}

gpu/vulkan/vulkan_surface.h

@@ -45,6 +45,7 @@ class VULKAN_EXPORT VulkanSurface {
 
   bool SetSize(const gfx::Size& size);
   const gfx::Size& size() const { return size_; }
+  VkSurfaceFormatKHR surface_format() const { return surface_format_; }
 
  private:
   const VkInstance vk_instance_;

gpu/vulkan/vulkan_swap_chain.h

@@ -20,7 +20,7 @@ class VulkanCommandBuffer;
 class VulkanCommandPool;
 class VulkanDeviceQueue;
 
-class VulkanSwapChain {
+class VULKAN_EXPORT VulkanSwapChain {
  public:
   VulkanSwapChain();
   ~VulkanSwapChain();
@@ -43,6 +43,11 @@ class VulkanSwapChain {
     return images_[current_image_]->pre_raster_command_buffer.get();
   }
 
+  VkImage GetImage(uint32_t index) const {
+    DCHECK_LT(index, images_.size());
+    return images_[index]->image;
+  }
+
   VkImage GetCurrentImage() const {
     DCHECK_LT(current_image_, images_.size());
     return images_[current_image_]->image;

ui/ozone/demo/simple_renderer_factory.cc

@@ -18,6 +18,7 @@
 
 #if BUILDFLAG(ENABLE_VULKAN)
 #include "gpu/vulkan/init/vulkan_factory.h"
+#include "gpu/vulkan/vulkan_surface.h"
 #include "ui/ozone/demo/vulkan_overlay_renderer.h"
 #include "ui/ozone/demo/vulkan_renderer.h"
 #endif
@@ -102,7 +103,10 @@ std::unique_ptr<Renderer> SimpleRendererFactory::CreateRenderer(
             std::move(overlay_surface), surface_factory_ozone,
             vulkan_implementation_.get(), widget, size);
       }
-      return std::make_unique<VulkanRenderer>(vulkan_implementation_.get(),
+      std::unique_ptr<gpu::VulkanSurface> vulkan_surface =
+          vulkan_implementation_->CreateViewSurface(widget);
+      return std::make_unique<VulkanRenderer>(std::move(vulkan_surface),
+                                              vulkan_implementation_.get(),
                                               widget, size);
     }
 #endif

ui/ozone/demo/vulkan_overlay_renderer.cc

@@ -15,7 +15,6 @@
 #include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
 #include "gpu/vulkan/vulkan_implementation.h"
-#include "gpu/vulkan/vulkan_render_pass.h"
 #include "gpu/vulkan/vulkan_surface.h"
 #include "gpu/vulkan/vulkan_swap_chain.h"
 #include "ui/display/types/display_snapshot.h"
@@ -48,6 +47,7 @@ VulkanOverlayRenderer::VulkanOverlayRenderer(
 
 VulkanOverlayRenderer::~VulkanOverlayRenderer() {
   DestroyBuffers();
+  DestroyRenderPass();
   command_pool_->Destroy();
   command_pool_.reset();
   device_queue_->Destroy();
@@ -118,6 +118,14 @@ bool VulkanOverlayRenderer::Initialize() {
   return true;
 }
 
+void VulkanOverlayRenderer::DestroyRenderPass() {
+  if (render_pass_ == VK_NULL_HANDLE)
+    return;
+
+  vkDestroyRenderPass(device_queue_->GetVulkanDevice(), render_pass_, nullptr);
+  render_pass_ = VK_NULL_HANDLE;
+}
+
 void VulkanOverlayRenderer::DestroyBuffers() {
   VkDevice vk_device = device_queue_->GetVulkanDevice();
 

ui/ozone/demo/vulkan_overlay_renderer.h

@@ -89,6 +89,7 @@ class VulkanOverlayRenderer : public RendererBase {
     const VkFence fence_;
   };
 
+  void DestroyRenderPass();
   void DestroyBuffers();
   void RecreateBuffers();
   void RenderFrame();
@@ -111,7 +112,7 @@ class VulkanOverlayRenderer : public RendererBase {
   std::unique_ptr<gpu::VulkanCommandPool> command_pool_;
   std::unique_ptr<OverlaySurface> overlay_surface_;
 
-  VkRenderPass render_pass_;
+  VkRenderPass render_pass_ = VK_NULL_HANDLE;
 
   base::WeakPtrFactory<VulkanOverlayRenderer> weak_ptr_factory_;
 

ui/ozone/demo/vulkan_renderer.h

@@ -5,16 +5,21 @@
 #ifndef UI_OZONE_DEMO_VULKAN_RENDERER_H_
 #define UI_OZONE_DEMO_VULKAN_RENDERER_H_
 
+#include <vulkan/vulkan.h>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "ui/gfx/buffer_types.h"
+#include "ui/gfx/presentation_feedback.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/ozone/demo/renderer_base.h"
 
 namespace gpu {
 class VulkanDeviceQueue;
 class VulkanImplementation;
-class VulkanRenderPass;
+class VulkanCommandBuffer;
+class VulkanCommandPool;
 class VulkanSurface;
 }  // namespace gpu
 
@@ -22,7 +27,8 @@ namespace ui {
 
 class VulkanRenderer : public RendererBase {
  public:
-  VulkanRenderer(gpu::VulkanImplementation* vulkan_instance,
+  VulkanRenderer(std::unique_ptr<gpu::VulkanSurface> surface,
+                 gpu::VulkanImplementation* vulkan_instance,
                  gfx::AcceleratedWidget widget,
                  const gfx::Size& size);
   ~VulkanRenderer() override;
@@ -31,13 +37,47 @@ class VulkanRenderer : public RendererBase {
   bool Initialize() override;
 
  private:
+  class Framebuffer {
+   public:
+    Framebuffer(VkImageView vk_image_view,
+                VkFramebuffer vk_framebuffer,
+                std::unique_ptr<gpu::VulkanCommandBuffer> command_buffer);
+    ~Framebuffer();
+
+    static std::unique_ptr<Framebuffer> Create(
+        gpu::VulkanDeviceQueue* vulkan_device_queue,
+        gpu::VulkanCommandPool* vulkan_command_pool,
+        VkRenderPass vk_render_pass,
+        gpu::VulkanSurface* vulkan_surface,
+        uint32_t vulkan_swap_chain_image_index);
+
+    VkImageView vk_image_view() const { return vk_image_view_; }
+    VkFramebuffer vk_framebuffer() const { return vk_framebuffer_; }
+    gpu::VulkanCommandBuffer* command_buffer() const {
+      return command_buffer_.get();
+    }
+
+   private:
+    const VkImageView vk_image_view_;
+    const VkFramebuffer vk_framebuffer_;
+    const std::unique_ptr<gpu::VulkanCommandBuffer> command_buffer_;
+  };
+
+  void DestroyRenderPass();
+  void DestroyFramebuffers();
+  void RecreateFramebuffers();
   void RenderFrame();
   void PostRenderFrameTask();
 
+  std::vector<std::unique_ptr<Framebuffer>> framebuffers_;
+
   gpu::VulkanImplementation* const vulkan_implementation_;
   std::unique_ptr<gpu::VulkanDeviceQueue> device_queue_;
+  std::unique_ptr<gpu::VulkanCommandPool> command_pool_;
   std::unique_ptr<gpu::VulkanSurface> surface_;
-  std::unique_ptr<gpu::VulkanRenderPass> render_pass_;
+  gfx::Size size_;
+
+  VkRenderPass render_pass_ = VK_NULL_HANDLE;
 
   base::WeakPtrFactory<VulkanRenderer> weak_ptr_factory_;