ozone: drm: Add vulkan implementation

This enables initializing vulkan and offscreen rendering but not
presentation.

Bug: 851997
Test: ozone_demo gets past vulkan instance creation on
  eve build with vulkan support

Change-Id: I14f56fb4e22c0cdc275aaead3e734f59e18722a9
Reviewed-on: https://chromium-review.googlesource.com/1104862
Commit-Queue: Michael Spang <spang@chromium.org>
Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Cr-Commit-Position: refs/heads/master@{#569976}

ui/ozone/demo/simple_renderer_factory.cc

@@ -55,7 +55,8 @@ bool SimpleRendererFactory::Initialize() {
   if (command_line->HasSwitch(kEnableVulkan)) {
     vulkan_implementation_ = gpu::CreateVulkanImplementation();
     if (vulkan_implementation_ &&
-        vulkan_implementation_->InitializeVulkanInstance()) {
+        vulkan_implementation_->InitializeVulkanInstance() &&
+        gpu_helper_.Initialize(base::ThreadTaskRunnerHandle::Get())) {
       type_ = VULKAN;
       return true;
     } else {

ui/ozone/demo/vulkan_renderer.cc

@@ -42,6 +42,8 @@ bool VulkanRenderer::Initialize() {
   CHECK(device_queue_);
 
   surface_ = vulkan_implementation_->CreateViewSurface(widget_);
+  if (!surface_)
+    LOG(FATAL) << "Vulkan surface not supported by platform";
   CHECK(surface_->Initialize(device_queue_.get(),
                              gpu::VulkanSurface::DEFAULT_SURFACE_FORMAT));
 

ui/ozone/platform/drm/BUILD.gn

@@ -4,6 +4,7 @@
 
 import("//build/config/linux/pkg_config.gni")
 import("//ui/ozone/ozone.gni")
+import("//gpu/vulkan/features.gni")
 
 visibility = [ "//ui/ozone/*" ]
 
@@ -118,6 +119,7 @@ source_set("gbm") {
 
   deps = [
     "//base",
+    "//gpu/vulkan:buildflags",
     "//ipc",
     "//mojo/public/cpp/system",
     "//services/service_manager/public/cpp",
@@ -146,6 +148,14 @@ source_set("gbm") {
     "//ui/platform_window",
   ]
 
+  if (enable_vulkan) {
+    sources += [
+      "gpu/vulkan_implementation_gbm.cc",
+      "gpu/vulkan_implementation_gbm.h",
+    ]
+    deps += [ "//gpu/vulkan" ]
+  }
+
   public_configs = [ "//third_party/khronos:khronos_headers" ]
 
   defines = [ "OZONE_IMPLEMENTATION" ]

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

@@ -27,6 +27,10 @@
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
+#if BUILDFLAG(ENABLE_VULKAN)
+#include "ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.h"
+#endif
+
 namespace ui {
 
 namespace {
@@ -125,6 +129,13 @@ GLOzone* GbmSurfaceFactory::GetGLOzone(gl::GLImplementation implementation) {
   }
 }
 
+#if BUILDFLAG(ENABLE_VULKAN)
+std::unique_ptr<gpu::VulkanImplementation>
+GbmSurfaceFactory::CreateVulkanImplementation() {
+  return std::make_unique<ui::VulkanImplementationGbm>();
+}
+#endif
+
 std::unique_ptr<SurfaceOzoneCanvas> GbmSurfaceFactory::CreateCanvasForWidget(
     gfx::AcceleratedWidget widget) {
   DCHECK(thread_checker_.CalledOnValidThread());

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

@@ -13,6 +13,7 @@
 
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
+#include "gpu/vulkan/buildflags.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/ozone/common/gl_ozone_egl.h"
@@ -36,6 +37,11 @@ class GbmSurfaceFactory : public SurfaceFactoryOzone {
   std::vector<gl::GLImplementation> GetAllowedGLImplementations() override;
   GLOzone* GetGLOzone(gl::GLImplementation implementation) override;
 
+#if BUILDFLAG(ENABLE_VULKAN)
+  std::unique_ptr<gpu::VulkanImplementation> CreateVulkanImplementation()
+      override;
+#endif
+
   std::vector<gfx::BufferFormat> GetScanoutFormats(
       gfx::AcceleratedWidget widget) override;
   std::unique_ptr<SurfaceOzoneCanvas> CreateCanvasForWidget(

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

+// Copyright (c) 2018 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 "ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.h"
+
+#include "base/files/file_path.h"
+#include "base/native_library.h"
+#include "gpu/vulkan/vulkan_function_pointers.h"
+#include "gpu/vulkan/vulkan_instance.h"
+#include "gpu/vulkan/vulkan_surface.h"
+
+namespace ui {
+
+VulkanImplementationGbm::VulkanImplementationGbm() {}
+
+VulkanImplementationGbm::~VulkanImplementationGbm() {}
+
+bool VulkanImplementationGbm::InitializeVulkanInstance() {
+  gpu::VulkanFunctionPointers* vulkan_function_pointers =
+      gpu::GetVulkanFunctionPointers();
+
+  base::NativeLibraryLoadError native_library_load_error;
+  vulkan_function_pointers->vulkan_loader_library_ = base::LoadNativeLibrary(
+      base::FilePath("libvulkan.so.1"), &native_library_load_error);
+  if (!vulkan_function_pointers->vulkan_loader_library_)
+    return false;
+
+  std::vector<const char*> required_extensions;
+  if (!vulkan_instance_.Initialize(required_extensions)) {
+    vulkan_instance_.Destroy();
+    return false;
+  }
+
+  return true;
+}
+
+VkInstance VulkanImplementationGbm::GetVulkanInstance() {
+  return vulkan_instance_.vk_instance();
+}
+
+std::unique_ptr<gpu::VulkanSurface> VulkanImplementationGbm::CreateViewSurface(
+    gfx::AcceleratedWidget window) {
+  return nullptr;
+}
+
+bool VulkanImplementationGbm::GetPhysicalDevicePresentationSupport(
+    VkPhysicalDevice device,
+    const std::vector<VkQueueFamilyProperties>& queue_family_properties,
+    uint32_t queue_family_index) {
+  return true;
+}
+
+std::vector<const char*>
+VulkanImplementationGbm::GetRequiredDeviceExtensions() {
+  return std::vector<const char*>();
+}
+
+}  // namespace ui

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

+// Copyright (c) 2018 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 UI_OZONE_PLATFORM_DRM_GPU_VULKAN_IMPLEMENTATION_GBM_H_
+#define UI_OZONE_PLATFORM_DRM_GPU_VULKAN_IMPLEMENTATION_GBM_H_
+
+#include <memory>
+
+#include "gpu/vulkan/vulkan_implementation.h"
+#include "gpu/vulkan/vulkan_instance.h"
+
+namespace ui {
+
+class VulkanImplementationGbm : public gpu::VulkanImplementation {
+ public:
+  VulkanImplementationGbm();
+  ~VulkanImplementationGbm() override;
+
+  // VulkanImplementation:
+  bool InitializeVulkanInstance() override;
+  VkInstance GetVulkanInstance() override;
+  std::unique_ptr<gpu::VulkanSurface> CreateViewSurface(
+      gfx::AcceleratedWidget window) override;
+  bool GetPhysicalDevicePresentationSupport(
+      VkPhysicalDevice device,
+      const std::vector<VkQueueFamilyProperties>& queue_family_properties,
+      uint32_t queue_family_index) override;
+  std::vector<const char*> GetRequiredDeviceExtensions() override;
+
+ private:
+  gpu::VulkanInstance vulkan_instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(VulkanImplementationGbm);
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_DRM_GPU_VULKAN_IMPLEMENTATION_GBM_H_