Added initial Vulkan build files as well as a basic implementation file.

gpu/vulkan/vulkan_implementation.cc

Index: gpu/vulkan/vulkan_implementation.cc
diff --git a/gpu/vulkan/vulkan_implementation.cc b/gpu/vulkan/vulkan_implementation.cc
new file mode 100644
index 0000000000000000000000000000000000000000..808ed8450484ca94d529f098b5206cb4b1502d10
--- /dev/null
+++ b/gpu/vulkan/vulkan_implementation.cc
@@ -0,0 +1,179 @@
+// Copyright (c) 2016 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 "gpu/vulkan/vulkan_implementation.h"
+
+#include <string>
+#include <vector>
+#include <vulkan/vulkan.h>
+
+#include "base/macros.h"
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+#include "ui/gfx/x/x11_types.h"
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+
+namespace gpu {
+
+struct VulkanInstance {
+  VulkanInstance() : valid(false) {}
+
+  void Initialize() {
+    valid = InitializeVulkanInstance() && InitializeVulkanDevice();
+  }
+
+  bool InitializeVulkanInstance() {
+    VkResult status = VK_SUCCESS;
+
+    VkApplicationInfo app_info = {};
+    app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+    app_info.pApplicationName = "Chromium";
+    app_info.apiVersion = VK_MAKE_VERSION(1, 0, 2);
+
+    const char* instance_extensions[] = {
+      VK_KHR_SURFACE_EXTENSION_NAME,
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+      VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+    };
+
+    VkInstanceCreateInfo instance_create_info = {};
+    instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    instance_create_info.pApplicationInfo = &app_info;
+    instance_create_info.ppEnabledExtensionNames = instance_extensions;
+    instance_create_info.enabledExtensionCount = arraysize(instance_extensions);
+
+    status = vkCreateInstance(&instance_create_info, nullptr, &vk_instance);
+    DCHECK_EQ(VK_SUCCESS, status);
+    if (VK_SUCCESS != status)
+      return false;
+
+    return true;
+  }
+
+  bool InitializeVulkanDevice() {
+    VkResult status = VK_SUCCESS;
+
+    uint32_t device_count = 0;
+    status = vkEnumeratePhysicalDevices(vk_instance, &device_count, nullptr);
+    if (VK_SUCCESS != status || device_count == 0)
+      return false;
+
+    std::vector<VkPhysicalDevice> devices(device_count);
+    status =
+        vkEnumeratePhysicalDevices(vk_instance, &device_count, devices.data());
+    if (VK_SUCCESS != status) {
+      LOG(ERROR) << "vkEnumeratePhysicalDevices() failed: " << status;
+      return false;
+    }
+
+// TODO(dyen): Enable this once vkGetPhysicalDeviceXlibPresentationSupportKHR()
+// is properly supported in the driver.
+#if 0 && defined(VK_USE_PLATFORM_XLIB_KHR)
+    Display* xdisplay = gfx::GetXDisplay();
+    VisualID visual_id =
+        XVisualIDFromVisual(DefaultVisual(xdisplay, DefaultScreen(xdisplay)));
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+
+    int device_index = -1;
+    int queue_index = -1;
+    for (size_t i = 0; i < devices.size(); ++i) {
+      const VkPhysicalDevice& device = devices[i];
+      uint32_t queue_count = 0;
+      vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, nullptr);
+      if (queue_count) {
+        std::vector<VkQueueFamilyProperties> queue_properties(queue_count);
+        vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count,
+                                                 queue_properties.data());
+        for (size_t n = 0; n < queue_properties.size(); ++n) {
+          if ((queue_properties[n].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)
+            continue;
+
+// TODO(dyen): Enable this once vkGetPhysicalDeviceXlibPresentationSupportKHR()
+// is properly supported in the driver.
+#if 1
+#elif defined(VK_USE_PLATFORM_XLIB_KHR)
+          if (!vkGetPhysicalDeviceXlibPresentationSupportKHR(
+                  device, n, xdisplay, visual_id)) {
+            continue;
+          }
+#else
+#error Non-Supported Vulkan implementation.
+#endif
+
+          queue_index = static_cast<int>(n);
+          break;
+        }
+
+        if (-1 != queue_index) {
+          device_index = static_cast<int>(i);
+          break;
+        }
+      }
+    }
+
+    if (queue_index == -1)
+      return false;
+
+    float queue_priority = 0.0f;
+    VkDeviceQueueCreateInfo queue_create_info = {};
+    queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queue_create_info.queueFamilyIndex = queue_index;
+    queue_create_info.queueCount = 1;
+    queue_create_info.pQueuePriorities = &queue_priority;
+
+    const char* device_extensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+
+    VkDeviceCreateInfo device_create_info = {};
+    device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    device_create_info.queueCreateInfoCount = 1;
+    device_create_info.pQueueCreateInfos = &queue_create_info;
+    device_create_info.enabledExtensionCount = arraysize(device_extensions);
+    device_create_info.ppEnabledExtensionNames = device_extensions;
+
+    status = vkCreateDevice(devices[device_index], &device_create_info, nullptr,
+                            &vk_device);
+    if (VK_SUCCESS != status)
+      return false;
+
+    vkGetDeviceQueue(vk_device, queue_index, 0, &vk_queue);
+
+    return true;
+  }
+
+  bool valid;
+  VkInstance vk_instance;
+  VkDevice vk_device;
+  VkQueue vk_queue;
+};
+
+static VulkanInstance* vulkan_instance = nullptr;
+
+bool InitializeVulkan() {
+  DCHECK(!vulkan_instance);
+  vulkan_instance = new VulkanInstance;
+  vulkan_instance->Initialize();
+  return vulkan_instance->valid;
+}
+
+VkInstance GetVulkanInstance() {
+  DCHECK(vulkan_instance);
+  DCHECK(vulkan_instance->valid);
+  return vulkan_instance->vk_instance;
+}
+
+VkDevice GetVulkanDevice() {
+  DCHECK(vulkan_instance);
+  DCHECK(vulkan_instance->valid);
+  return vulkan_instance->vk_device;
+}
+
+VkQueue GetVulkanQueue() {
+  DCHECK(vulkan_instance);
+  DCHECK(vulkan_instance->valid);
+  return vulkan_instance->vk_queue;
+}
+
+}  // namespace gpu