Vulkan support for SkiaRenderer.

This CL enables the following,
1.Vulkan support for Skia Renderer leveraging Skia's
  Vulkan backend.
2.Vulkan context creation based on Skia's GrVkBackendContext.

Bug: 582554

Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I226cd5819dd89e5b71b605093eed1feb6f5074f9
Signed-off-by: suyambu <suyambu.rm@samsung.com>
Reviewed-on: https://chromium-review.googlesource.com/649387
Commit-Queue: Chandan Padhi <c.padhi@samsung.com>
Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#521292}

AUTHORS

@@ -779,6 +779,7 @@ Sungmann Cho <sungmann.cho@navercorp.com>
 Sunil Ratnu <sunil.ratnu@samsung.com>
 Sunitha Srivatsa <srivats@amazon.com>
 Suvanjan Mukherjee <suvanjanmukherjee@gmail.com>
+Suyambulingam R M <suyambu.rm@samsung.com>
 Suyash Sengar <suyash.s@samsung.com>
 Swarali Raut <swarali.sr@samsung.com>
 Swati Jaiswal <swa.jaiswal@samsung.com>

cc/test/fake_output_surface.cc

@@ -106,4 +106,11 @@ unsigned FakeOutputSurface::GetOverlayTextureId() const {
   return 0;
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface* FakeOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace cc

cc/test/fake_output_surface.h

@@ -77,6 +77,9 @@ class FakeOutputSurface : public viz::OutputSurface {
   bool IsDisplayedAsOverlayPlane() const override;
   unsigned GetOverlayTextureId() const override;
   gfx::BufferFormat GetOverlayBufferFormat() const override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
 
   void set_framebuffer(GLint framebuffer, GLenum format) {
     framebuffer_ = framebuffer;

cc/test/pixel_test_output_surface.cc

@@ -109,4 +109,11 @@ uint32_t PixelTestOutputSurface::GetFramebufferCopyTextureFormat() {
   return GL_RGB;
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface* PixelTestOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace cc

cc/test/pixel_test_output_surface.h

@@ -39,6 +39,9 @@ class PixelTestOutputSurface : public viz::OutputSurface {
   gfx::BufferFormat GetOverlayBufferFormat() const override;
   bool SurfaceIsSuspendForRecycle() const override;
   uint32_t GetFramebufferCopyTextureFormat() override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
 
   void set_has_external_stencil_test(bool has_test) {
     external_stencil_test_ = has_test;

components/viz/common/BUILD.gn

@@ -4,6 +4,7 @@
 
 import("//components/viz/viz.gni")
 import("//testing/test.gni")
+import("//gpu/vulkan/features.gni")
 
 viz_component("resource_format") {
   output_name = "viz_resource_format"
@@ -167,6 +168,11 @@ viz_component("common") {
     "//ui/latency",
   ]
 
+  if (enable_vulkan) {
+    configs = [ "//third_party/vulkan:vulkan_config" ]
+    deps += [ "//gpu/vulkan" ]
+  }
+
   public_deps = [
     ":resource_format",
     "//gpu/command_buffer/client",

components/viz/common/gpu/vulkan_context_provider.h

@@ -8,6 +8,8 @@
 #include "base/memory/ref_counted.h"
 #include "components/viz/common/viz_common_export.h"
 
+class GrContext;
+
 namespace gpu {
 class VulkanDeviceQueue;
 }
@@ -19,6 +21,7 @@ class VIZ_COMMON_EXPORT VulkanContextProvider
     : public base::RefCountedThreadSafe<VulkanContextProvider> {
  public:
   virtual gpu::VulkanDeviceQueue* GetDeviceQueue() = 0;
+  virtual GrContext* GetGrContext() = 0;
 
  protected:
   friend class base::RefCountedThreadSafe<VulkanContextProvider>;

components/viz/common/gpu/vulkan_in_process_context_provider.cc

@@ -8,6 +8,8 @@
 #if BUILDFLAG(ENABLE_VULKAN)
 #include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_implementation.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/vk/GrVkInterface.h"
 #endif  // BUILDFLAG(ENABLE_VULKAN)
 
 namespace viz {
@@ -28,6 +30,20 @@ VulkanInProcessContextProvider::Create() {
 #endif
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+GrVkInterface::GetProc make_unified_getter(
+    const GrVkInterface::GetInstanceProc& iproc,
+    const GrVkInterface::GetDeviceProc& dproc) {
+  return [&iproc, &dproc](const char* proc_name, VkInstance instance,
+                          VkDevice device) {
+    if (device != VK_NULL_HANDLE) {
+      return dproc(device, proc_name);
+    }
+    return iproc(instance, proc_name);
+  };
+}
+#endif
+
 bool VulkanInProcessContextProvider::Initialize() {
 #if BUILDFLAG(ENABLE_VULKAN)
   DCHECK(!device_queue_);
@@ -41,6 +57,32 @@ bool VulkanInProcessContextProvider::Initialize() {
   }
 
   device_queue_ = std::move(device_queue);
+  const uint32_t feature_flags = kGeometryShader_GrVkFeatureFlag |
+                                 kDualSrcBlend_GrVkFeatureFlag |
+                                 kSampleRateShading_GrVkFeatureFlag;
+  const uint32_t extension_flags =
+      kEXT_debug_report_GrVkExtensionFlag | kKHR_surface_GrVkExtensionFlag |
+      kKHR_swapchain_GrVkExtensionFlag | kKHR_xcb_surface_GrVkExtensionFlag;
+  GrVkBackendContext* backend_context = new GrVkBackendContext();
+  backend_context->fInstance = device_queue_->GetVulkanInstance();
+  backend_context->fPhysicalDevice = device_queue_->GetVulkanPhysicalDevice();
+  backend_context->fDevice = device_queue_->GetVulkanDevice();
+  backend_context->fQueue = device_queue_->GetVulkanQueue();
+  backend_context->fGraphicsQueueIndex = device_queue_->GetVulkanQueueIndex();
+  backend_context->fMinAPIVersion = VK_MAKE_VERSION(1, 0, 8);
+  backend_context->fExtensions = extension_flags;
+  backend_context->fFeatures = feature_flags;
+
+  auto interface = sk_make_sp<GrVkInterface>(
+      make_unified_getter(vkGetInstanceProcAddr, vkGetDeviceProcAddr),
+      backend_context->fInstance, backend_context->fDevice,
+      backend_context->fExtensions);
+  backend_context->fInterface.reset(interface.release());
+  backend_context->fOwnsInstanceAndDevice = false;
+  backend_context_.reset(backend_context);
+  gr_context_ = GrContext::Create(
+      kVulkan_GrBackend,
+      reinterpret_cast<GrBackendContext>(backend_context_.get()));
   return true;
 #else
   return false;
@@ -52,10 +94,15 @@ void VulkanInProcessContextProvider::Destroy() {
   if (device_queue_) {
     device_queue_->Destroy();
     device_queue_.reset();
+    backend_context_.reset();
   }
 #endif
 }
 
+GrContext* VulkanInProcessContextProvider::GetGrContext() {
+  return gr_context_;
+}
+
 gpu::VulkanDeviceQueue* VulkanInProcessContextProvider::GetDeviceQueue() {
 #if BUILDFLAG(ENABLE_VULKAN)
   return device_queue_.get();

components/viz/common/gpu/vulkan_in_process_context_provider.h

@@ -10,6 +10,9 @@
 #include "components/viz/common/gpu/vulkan_context_provider.h"
 #include "components/viz/common/viz_common_export.h"
 #include "gpu/vulkan/features.h"
+#if BUILDFLAG(ENABLE_VULKAN)
+#include "third_party/skia/include/gpu/vk/GrVkBackendContext.h"
+#endif
 
 namespace gpu {
 class VulkanDeviceQueue;
@@ -24,6 +27,7 @@ class VIZ_COMMON_EXPORT VulkanInProcessContextProvider
 
   bool Initialize();
   void Destroy();
+  GrContext* GetGrContext() override;
 
   // VulkanContextProvider implementation
   gpu::VulkanDeviceQueue* GetDeviceQueue() override;
@@ -33,8 +37,10 @@ class VIZ_COMMON_EXPORT VulkanInProcessContextProvider
   ~VulkanInProcessContextProvider() override;
 
  private:
+  GrContext* gr_context_;
 #if BUILDFLAG(ENABLE_VULKAN)
   std::unique_ptr<gpu::VulkanDeviceQueue> device_queue_;
+  sk_sp<GrVkBackendContext> backend_context_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(VulkanInProcessContextProvider);

components/viz/service/BUILD.gn

@@ -240,11 +240,6 @@ viz_component("service") {
   }
 
   if (enable_vulkan) {
-    sources += [
-      "display/vulkan_renderer.cc",
-      "display/vulkan_renderer.h",
-    ]
-
     deps += [ "//gpu/vulkan" ]
   }
 }

components/viz/service/display/direct_renderer.cc

@@ -471,6 +471,13 @@ void DirectRenderer::DrawRenderPass(const RenderPass* render_pass) {
     return;
   UseRenderPass(render_pass);
 
+  // TODO(crbug.com/582554): This change applies only when Vulkan is enabled and
+  // it will be removed once SkiaRenderer has complete support for Vulkan.
+  if (current_frame()->current_render_pass !=
+          current_frame()->root_render_pass &&
+      !IsRenderPassResourceAllocated(render_pass->id))
+    return;
+
   const gfx::Rect surface_rect_in_draw_space = OutputSurfaceRectInDrawSpace();
   gfx::Rect render_pass_scissor_in_draw_space = surface_rect_in_draw_space;
 
@@ -619,6 +626,11 @@ void DirectRenderer::UseRenderPass(const RenderPass* render_pass) {
   AllocateRenderPassResourceIfNeeded(render_pass->id, enlarged_size,
                                      RenderPassTextureHint(render_pass));
 
+  // TODO(crbug.com/582554): This change applies only when Vulkan is enabled and
+  // it will be removed once SkiaRenderer has complete support for Vulkan.
+  if (!IsRenderPassResourceAllocated(render_pass->id))
+    return;
+
   BindFramebufferToTexture(render_pass->id);
   InitializeViewport(current_frame(), render_pass->output_rect,
                      gfx::Rect(render_pass->output_rect.size()),

components/viz/service/display/display.cc

@@ -35,10 +35,6 @@
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/presentation_feedback.h"
 
-#if BUILDFLAG(ENABLE_VULKAN)
-#include "cc/output/vulkan_renderer.h"
-#endif
-
 namespace viz {
 
 Display::Display(
@@ -207,8 +203,8 @@ void Display::InitializeRenderer() {
           &settings_, output_surface_.get(), resource_provider_.get());
     }
   } else if (output_surface_->vulkan_context_provider()) {
-#if defined(ENABLE_VULKAN)
-    renderer_ = base::MakeUnique<VulkanRenderer>(
+#if BUILDFLAG(ENABLE_VULKAN)
+    renderer_ = base::MakeUnique<SkiaRenderer>(
         &settings_, output_surface_.get(), resource_provider_.get());
 #else
     NOTREACHED();

components/viz/service/display/output_surface.h

@@ -18,6 +18,8 @@
 #include "components/viz/service/display/software_output_device.h"
 #include "components/viz/service/viz_service_export.h"
 #include "gpu/command_buffer/common/texture_in_use_response.h"
+#include "gpu/vulkan/features.h"
+#include "gpu/vulkan/vulkan_surface.h"
 #include "ui/gfx/color_space.h"
 #include "ui/latency/latency_info.h"
 
@@ -122,6 +124,11 @@ class VIZ_SERVICE_EXPORT OutputSurface {
   // after returning from this method in order to unblock the next frame.
   virtual void SwapBuffers(OutputSurfaceFrame frame) = 0;
 
+#if BUILDFLAG(ENABLE_VULKAN)
+  // Gives the Vulkan surface created when enable_vulkan flag is set.
+  virtual gpu::VulkanSurface* GetVulkanSurface() = 0;
+#endif
+
   // A helper class for implementations of OutputSurface that want to cache
   // LatencyInfos that can be updated when we get the corresponding
   // gfx::SwapResponse.

components/viz/service/display/skia_renderer.cc

@@ -4,6 +4,7 @@
 
 #include "components/viz/service/display/skia_renderer.h"
 
+#include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ -39,6 +40,17 @@
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
+#if BUILDFLAG(ENABLE_VULKAN)
+#include "components/viz/common/gpu/vulkan_in_process_context_provider.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
+#include "gpu/vulkan/vulkan_implementation.h"
+#include "gpu/vulkan/vulkan_surface.h"
+#include "gpu/vulkan/vulkan_swap_chain.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/vk/GrVkBackendContext.h"
+#include "third_party/skia/include/gpu/vk/GrVkTypes.h"
+#endif
+
 namespace viz {
 namespace {
 
@@ -62,14 +74,21 @@ SkiaRenderer::SkiaRenderer(const RendererSettings* settings,
                            OutputSurface* output_surface,
                            cc::DisplayResourceProvider* resource_provider)
     : DirectRenderer(settings, output_surface, resource_provider) {
+#if BUILDFLAG(ENABLE_VULKAN)
+  use_swap_with_bounds_ = false;
+#else
   const auto& context_caps =
       output_surface_->context_provider()->ContextCapabilities();
   use_swap_with_bounds_ = context_caps.swap_buffers_with_bounds;
+#endif
 }
 
 SkiaRenderer::~SkiaRenderer() {}
 
 bool SkiaRenderer::CanPartialSwap() {
+#if BUILDFLAG(ENABLE_VULKAN)
+  return false;
+#endif
   if (use_swap_with_bounds_)
     return false;
   auto* context_provider = output_surface_->context_provider();
@@ -87,6 +106,9 @@ ResourceFormat SkiaRenderer::BackbufferFormat() const {
 
 void SkiaRenderer::BeginDrawingFrame() {
   TRACE_EVENT0("viz", "SkiaRenderer::BeginDrawingFrame");
+#if BUILDFLAG(ENABLE_VULKAN)
+  return;
+#else
   // Copied from GLRenderer.
   bool use_sync_query_ = false;
   scoped_refptr<ResourceFence> read_lock_fence;
@@ -108,6 +130,7 @@ void SkiaRenderer::BeginDrawingFrame() {
         resource_provider_->WaitSyncToken(resource_id);
     }
   }
+#endif
 }
 
 void SkiaRenderer::FinishDrawingFrame() {
@@ -170,6 +193,33 @@ void SkiaRenderer::BindFramebufferToOutputSurface() {
   DCHECK(!output_surface_->HasExternalStencilTest());
   current_framebuffer_lock_ = nullptr;
 
+  // LegacyFontHost will get LCD text and skia figures out what type to use.
+  SkSurfaceProps surface_props =
+      SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType);
+
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* vulkan_surface = output_surface_->GetVulkanSurface();
+  gpu::VulkanSwapChain* swap_chain = vulkan_surface->GetSwapChain();
+  VkImage image = swap_chain->GetCurrentImage(swap_chain->current_image());
+
+  GrVkImageInfo info_;
+  info_.fImage = image;
+  info_.fAlloc = {VK_NULL_HANDLE, 0, 0, 0};
+  info_.fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+  info_.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+  info_.fFormat = VK_FORMAT_B8G8R8A8_UNORM;
+  info_.fLevelCount = 1;
+
+  GrBackendRenderTarget render_target(
+      current_frame()->device_viewport_size.width(),
+      current_frame()->device_viewport_size.height(), 0, 0, info_);
+
+  GrContext* gr_context =
+      output_surface_->vulkan_context_provider()->GetGrContext();
+  root_surface_ = SkSurface::MakeFromBackendRenderTarget(
+      gr_context, render_target, kTopLeft_GrSurfaceOrigin, nullptr,
+      &surface_props);
+#else
   // TODO(weiliangc): Set up correct can_use_lcd_text and
   // use_distance_field_text for SkSurfaceProps flags. How to setup is in
   // ResourceProvider. (crbug.com/644851)
@@ -187,15 +237,11 @@ void SkiaRenderer::BindFramebufferToOutputSurface() {
         current_frame()->device_viewport_size.height(), 0, 8,
         kRGBA_8888_GrPixelConfig, framebuffer_info);
 
-    // This is for use_distance_field_text false, and can_use_lcd_text true.
-    // LegacyFontHost will get LCD text and skia figures out what type to use.
-    SkSurfaceProps surface_props =
-        SkSurfaceProps(0, SkSurfaceProps::kLegacyFontHost_InitType);
-
     root_surface_ = SkSurface::MakeFromBackendRenderTarget(
         gr_context, render_target, kBottomLeft_GrSurfaceOrigin, nullptr,
         &surface_props);
   }
+#endif
 
   root_canvas_ = root_surface_->getCanvas();
   if (settings_->show_overdraw_feedback) {
@@ -217,6 +263,10 @@ void SkiaRenderer::BindFramebufferToTexture(const RenderPassId render_pass_id) {
   cc::ScopedResource* texture = render_pass_textures_[render_pass_id].get();
   DCHECK(texture);
   DCHECK(texture->id());
+#if BUILDFLAG(ENABLE_VULKAN)
+  NOTIMPLEMENTED();
+  return;
+#endif
 
   // Explicitly release lock, otherwise we can crash when try to lock
   // same texture again.
@@ -557,6 +607,10 @@ void SkiaRenderer::DrawTileQuad(const TileDrawQuad* quad) {
 }
 
 void SkiaRenderer::DrawRenderPassQuad(const RenderPassDrawQuad* quad) {
+#if BUILDFLAG(ENABLE_VULKAN)
+  NOTIMPLEMENTED();
+  return;
+#endif
   cc::ScopedResource* content_texture =
       render_pass_textures_[quad->render_pass_id].get();
   DCHECK(content_texture);
@@ -741,6 +795,10 @@ void SkiaRenderer::AllocateRenderPassResourceIfNeeded(
     const RenderPassId render_pass_id,
     const gfx::Size& enlarged_size,
     ResourceTextureHint texturehint) {
+#if BUILDFLAG(ENABLE_VULKAN)
+  NOTIMPLEMENTED();
+  return;
+#endif
   auto& resource = render_pass_textures_[render_pass_id];
   if (resource && resource->id())
     return;

components/viz/service/display/skia_renderer.h

@@ -9,6 +9,7 @@
 #include "cc/cc_export.h"
 #include "components/viz/service/display/direct_renderer.h"
 #include "components/viz/service/viz_service_export.h"
+#include "gpu/vulkan/features.h"
 #include "ui/latency/latency_info.h"
 
 class SkNWayCanvas;

components/viz/service/display_embedder/gl_output_surface.cc

@@ -169,4 +169,11 @@ void GLOutputSurface::OnPresentation(
   client_->DidReceivePresentationFeedback(swap_id, feedback);
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface* GLOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace viz

components/viz/service/display_embedder/gl_output_surface.h

@@ -44,6 +44,9 @@ class GLOutputSurface : public OutputSurface,
   bool SurfaceIsSuspendForRecycle() const override;
   bool HasExternalStencilTest() const override;
   void ApplyExternalStencil() override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
 
   // OutputSurface::LatencyInfoCache::Client implementation.
   void LatencyInfoCompleted(

components/viz/service/display_embedder/software_output_surface.cc

@@ -128,4 +128,11 @@ void SoftwareOutputSurface::SwapBuffersCallback(uint64_t swap_id) {
       gfx::PresentationFeedback(base::TimeTicks::Now(), refresh_interval_, 0u));
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface* SoftwareOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace viz

components/viz/service/display_embedder/software_output_surface.h

@@ -39,6 +39,9 @@ class VIZ_SERVICE_EXPORT SoftwareOutputSurface : public OutputSurface {
   void ApplyExternalStencil() override;
   bool SurfaceIsSuspendForRecycle() const override;
   uint32_t GetFramebufferCopyTextureFormat() override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
 
  private:
   void SwapBuffersCallback(uint64_t swap_id);

content/browser/compositor/gpu_browser_compositor_output_surface.cc

@@ -207,4 +207,11 @@ GpuBrowserCompositorOutputSurface::GetCommandBufferProxy() {
   return command_buffer_proxy;
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface* GpuBrowserCompositorOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace content

content/browser/compositor/gpu_browser_compositor_output_surface.h

@@ -11,6 +11,7 @@
 #include "build/build_config.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
 #include "content/browser/compositor/gpu_vsync_begin_frame_source.h"
+#include "gpu/vulkan/features.h"
 #include "ui/gfx/swap_result.h"
 
 namespace viz {
@@ -80,6 +81,9 @@ class GpuBrowserCompositorOutputSurface
 
   // GpuVSyncControl implementation.
   void SetNeedsVSync(bool needs_vsync) override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
 
   // OutputSurface::LatencyInfoCache::Client implementation.
   void LatencyInfoCompleted(

content/browser/compositor/offscreen_browser_compositor_output_surface.cc

@@ -205,4 +205,12 @@ void OffscreenBrowserCompositorOutputSurface::OnSwapBuffersComplete(
   client_->DidReceivePresentationFeedback(swap_id, gfx::PresentationFeedback());
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface*
+OffscreenBrowserCompositorOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace content

content/browser/compositor/offscreen_browser_compositor_output_surface.h

@@ -14,6 +14,7 @@
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
+#include "gpu/vulkan/features.h"
 #include "ui/latency/latency_info.h"
 
 namespace ui {
@@ -59,6 +60,10 @@ class OffscreenBrowserCompositorOutputSurface
   void SetSurfaceSuspendedForRecycle(bool suspended) override {}
 #endif
 
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
+
   void OnSwapBuffersComplete(const std::vector<ui::LatencyInfo>& latency_info,
                              uint64_t swap_id);
 

content/browser/compositor/reflector_impl_unittest.cc

@@ -118,6 +118,10 @@ class TestOutputSurface : public BrowserCompositorOutputSurface {
   void SetSurfaceSuspendedForRecycle(bool suspended) override {}
 #endif
 
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override { return nullptr; }
+#endif
+
  private:
   std::unique_ptr<ReflectorTexture> reflector_texture_;
 };

content/browser/compositor/software_browser_compositor_output_surface.cc

@@ -145,4 +145,11 @@ void SoftwareBrowserCompositorOutputSurface::SetSurfaceSuspendedForRecycle(
 }
 #endif
 
+#if BUILDFLAG(ENABLE_VULKAN)
+gpu::VulkanSurface* SoftwareBrowserCompositorOutputSurface::GetVulkanSurface() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+#endif
+
 }  // namespace content

content/browser/compositor/software_browser_compositor_output_surface.h

@@ -11,6 +11,7 @@
 #include "build/build_config.h"
 #include "content/browser/compositor/browser_compositor_output_surface.h"
 #include "content/common/content_export.h"
+#include "gpu/vulkan/features.h"
 
 namespace cc {
 class SoftwareOutputDevice;
@@ -45,6 +46,9 @@ class CONTENT_EXPORT SoftwareBrowserCompositorOutputSurface
   gfx::BufferFormat GetOverlayBufferFormat() const override;
   bool SurfaceIsSuspendForRecycle() const override;
   uint32_t GetFramebufferCopyTextureFormat() override;
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override;
+#endif
 
  private:
   // BrowserCompositorOutputSurface implementation.

content/browser/compositor/vulkan_browser_compositor_output_surface.cc

@@ -106,16 +106,21 @@ VulkanBrowserCompositorOutputSurface::GetFramebufferCopyTextureFormat() {
 void VulkanBrowserCompositorOutputSurface::SwapBuffers(
     viz::OutputSurfaceFrame frame) {
   surface_->SwapBuffers();
+  ++swap_id_;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&VulkanBrowserCompositorOutputSurface::SwapBuffersAck,
-                 weak_ptr_factory_.GetWeakPtr()));
+                 weak_ptr_factory_.GetWeakPtr(), swap_id_));
 }
 
-void VulkanBrowserCompositorOutputSurface::SwapBuffersAck() {
+void VulkanBrowserCompositorOutputSurface::SwapBuffersAck(uint64_t swap_id) {
   DCHECK(client_);
-  client_->DidReceiveSwapBuffersAck();
+  client_->DidReceiveSwapBuffersAck(swap_id);
+}
+
+gpu::VulkanSurface* VulkanBrowserCompositorOutputSurface::GetVulkanSurface() {
+  return surface_.get();
 }
 
 }  // namespace content

content/browser/compositor/vulkan_browser_compositor_output_surface.h

@@ -49,11 +49,15 @@ class VulkanBrowserCompositorOutputSurface
   void SwapBuffers(viz::OutputSurfaceFrame frame) override;
   void SetDrawRectangle(const gfx::Rect& rect) override;
 
+  gpu::VulkanSurface* GetVulkanSurface() override;
+
  private:
-  void SwapBuffersAck();
+  void SwapBuffersAck(uint64_t swap_id);
 
   std::unique_ptr<gpu::VulkanSurface> surface_;
   viz::OutputSurfaceClient* client_ = nullptr;
+  uint64_t swap_id_ = 0;
+
   base::WeakPtrFactory<VulkanBrowserCompositorOutputSurface> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VulkanBrowserCompositorOutputSurface);

gpu/vulkan/BUILD.gn

@@ -51,19 +51,10 @@ if (enable_vulkan) {
       ]
 
       configs += [ "//build/config:precompiled_headers" ]
-      defines = [ "VULKAN_IMPLEMENTATION" ]
 
-      all_dependent_configs = [ "//third_party/vulkan:vulkan_headers" ]
-      libs = [ "vulkan" ]
+      defines = [ "VULKAN_IMPLEMENTATION" ]
 
-      if (current_cpu == "x64") {
-        lib_dirs = [
-          "/usr/lib/x86_64-linux-gnu",
-          vulkan_lib_dir,
-        ]
-      } else {
-        assert(false, "Unsupported vulkan target: " + current_cpu)
-      }
+      all_dependent_configs = [ "//third_party/vulkan:vulkan_config" ]
 
       deps = [
         "//base",

gpu/vulkan/vulkan_device_queue.cc

@@ -26,20 +26,21 @@ VulkanDeviceQueue::~VulkanDeviceQueue() {
 }
 
 bool VulkanDeviceQueue::Initialize(uint32_t options) {
-  VkInstance vk_instance = gpu::GetVulkanInstance();
-  if (VK_NULL_HANDLE == vk_instance)
+  vk_instance_ = gpu::GetVulkanInstance();
+
+  if (VK_NULL_HANDLE == vk_instance_)
     return false;
 
   VkResult result = VK_SUCCESS;
 
   uint32_t device_count = 0;
-  result = vkEnumeratePhysicalDevices(vk_instance, &device_count, nullptr);
+  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());
+      vkEnumeratePhysicalDevices(vk_instance_, &device_count, devices.data());
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkEnumeratePhysicalDevices() failed: " << result;
     return false;

gpu/vulkan/vulkan_device_queue.h

@@ -46,6 +46,8 @@ class VULKAN_EXPORT VulkanDeviceQueue {
     return vk_queue_;
   }
 
+  VkInstance GetVulkanInstance() const { return vk_instance_; }
+
   uint32_t GetVulkanQueueIndex() const { return vk_queue_index_; }
 
   std::unique_ptr<gpu::VulkanCommandPool> CreateCommandPool();
@@ -55,6 +57,7 @@ class VULKAN_EXPORT VulkanDeviceQueue {
   VkDevice vk_device_ = VK_NULL_HANDLE;
   VkQueue vk_queue_ = VK_NULL_HANDLE;
   uint32_t vk_queue_index_ = 0;
+  VkInstance vk_instance_ = VK_NULL_HANDLE;
 
   DISALLOW_COPY_AND_ASSIGN(VulkanDeviceQueue);
 };

gpu/vulkan/vulkan_swap_chain.h

@@ -52,6 +52,11 @@ class VulkanSwapChain {
     return images_[current_image_]->command_buffer.get();
   }
 
+  VkImage GetCurrentImage(uint32_t index) const {
+    DCHECK_LT(index, images_.size());
+    return images_[index]->image;
+  }
+
  private:
   bool InitializeSwapChain(VkSurfaceKHR surface,
                            const VkSurfaceCapabilitiesKHR& surface_caps,

skia/BUILD.gn

@@ -8,6 +8,7 @@ import("//build/config/sanitizers/sanitizers.gni")
 import("//printing/features/features.gni")
 import("//testing/test.gni")
 import("//third_party/skia/gn/shared_sources.gni")
+import("//gpu/vulkan/features.gni")
 
 if (current_cpu == "arm") {
   import("//build/config/arm.gni")
@@ -21,6 +22,9 @@ skia_support_pdf = !is_ios && (enable_basic_printing || enable_print_preview)
 
 declare_args() {
   skia_whitelist_serialized_typefaces = false
+  if (enable_vulkan) {
+    vulkan_sdk_path = getenv("VULKAN_SDK")
+  }
 }
 
 # External-facing config for dependent code.
@@ -43,6 +47,9 @@ config("skia_config") {
     "//third_party/skia/include/utils",
     "//third_party/skia/third_party/vulkan",
   ]
+  if (enable_vulkan) {
+    include_dirs += [ "$vulkan_sdk_path/include" ]
+  }
 
   defines = skia_for_chromium_defines
   defines += [
@@ -53,6 +60,9 @@ config("skia_config") {
   if (!is_ios) {
     defines += [ "SK_HAS_JPEG_LIBRARY" ]
   }
+  if (enable_vulkan) {
+    defines += [ "SK_VULKAN=1" ]
+  }
 
   if (is_component_build) {
     defines += [
@@ -66,6 +76,9 @@ config("skia_config") {
       "//third_party/skia/src/gpu",
       "//third_party/skia/src/sksl",
     ]
+    if (enable_vulkan) {
+      include_dirs += [ "//third_party/skia/include/gpu/vk/" ]
+    }
     defines += [ "SK_SUPPORT_GPU=1" ]
   } else {
     defines += [ "SK_SUPPORT_GPU=0" ]
@@ -305,6 +318,9 @@ component("skia") {
     sources += skia_gpu_sources
     sources += skia_null_gpu_sources
     sources += skia_sksl_sources
+    if (enable_vulkan) {
+      sources += skia_vk_sources
+    }
   }
 
   # Remove unused util sources.

third_party/vulkan/BUILD.gn

@@ -2,6 +2,17 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-config("vulkan_headers") {
+config("vulkan_config") {
   include_dirs = [ "include" ]
+  vulkan_lib_dir = getenv("VULKAN_SDK") + "/lib"
+  libs = [ "vulkan" ]
+
+  if (current_cpu == "x64") {
+    lib_dirs = [
+      "/usr/lib/x86_64-linux-gnu",
+      vulkan_lib_dir,
+    ]
+  } else {
+    assert(false, "Unsupported vulkan target: " + current_cpu)
+  }
 }

third_party/vulkan/README.chromium

-Name: Vulkan API headers
+Name: Vulkan API headers & library
 Short Name: Vulkan
 URL: https://github.com/LunarG/VulkanTools/tree/master/include/vulkan
 Version: Unknown
@@ -7,7 +7,7 @@ License: MIT
 License File: LICENSE
 
 Description:
-This simply includes the include files for the Vulkan SDK. Eventually this
+This simply includes the include files and library for the Vulkan SDK. Eventually this
 will just be taken from the build system.
 
 Local Modifications:

ui/compositor/test/in_process_context_factory.cc

@@ -123,6 +123,9 @@ class DirectOutputSurface : public viz::OutputSurface {
   bool SurfaceIsSuspendForRecycle() const override { return false; }
   bool HasExternalStencilTest() const override { return false; }
   void ApplyExternalStencil() override {}
+#if BUILDFLAG(ENABLE_VULKAN)
+  gpu::VulkanSurface* GetVulkanSurface() override { return nullptr; }
+#endif
 
  private:
   void OnSwapBuffersComplete(uint64_t swap_id) {