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

ui/vulkan/vulkan_implementation.cc

Index: ui/vulkan/vulkan_implementation.cc
diff --git a/ui/vulkan/vulkan_implementation.cc b/ui/vulkan/vulkan_implementation.cc
new file mode 100644
index 0000000000000000000000000000000000000000..94c660d564abc7ef913cb4ea5aa6a4f3c8915f88
--- /dev/null
+++ b/ui/vulkan/vulkan_implementation.cc
@@ -0,0 +1,101 @@
+// 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 "ui/vulkan/vulkan_implementation.h"
+
+#include <string>
+#include <vector>
+#include <vulkan/vulkan.h>
+
+#include "base/macros.h"
+
+namespace gfx {
+
+static VkInstance vk_instance;
+static VkDevice vk_device;

[piman, 2016/02/25 06:49:44]

It would be nice to have these wrapped into an object, that would be injected
into the OutputSurface and so on. Ideally it wouldn't be a global, though maybe
ok as a first step.

We'll need more things to be associated with the device, among others keeping
the VkPhysicalDisplay that we chose (because we need it to query things such as
the memory types/heaps, the supported features/limits, the supported formats
etc.). We'll probably want a global memory allocator associated with it, because
we'll need to be able to track our usage globally.
Anyway, a bunch of things will be "global", so it would make sense to have them
gathered into a single class.

[David Yen, 2016/03/01 19:54:09]

Done.

+
+bool InitializeVulkan() {
+  // Initialize the Vulkan Instance.
+  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};
+
+  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);
+
+  VkResult status = VK_SUCCESS;
+  status = vkCreateInstance(&instance_create_info, nullptr, &vk_instance);
+  if (VK_SUCCESS != status)
+    return false;
+
+  // Initialize the Vulkan Device.
+  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)
+    return false;
+

[sohanjg, 2016/02/24 07:24:08]

sorry for the intrusion, but do we not want any layer or extensions here?

[David Yen, 2016/02/25 00:27:37]

The intent of this first CL is to just get linking working. I tried to write as
little code as possible to verify that the API calls actually call into Vulkan.
There definitely will be layers enabled here, although I haven't thought through
the API for that yet.

+  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) {

[piman, 2016/02/24 01:52:13]

We'll probably also want to pick a device that can present - maybe at first, on
the same queue, though we could extend support to other queues.

The best way to do this here is probably by using
vkGetPhysicalDeviceXlibPresentationSupportKHR (on X11) and others.

[David Yen, 2016/02/25 00:27:37]

That would make it seem like the output surface would have to own the device
since it's display/window specific. I can move this code over to
VulkanSurfaceX11 later and add the vkGetPhysicalDeviceXlibPresentationSupportKHR
check there.

[piman, 2016/02/25 06:49:44]

We wouldn't want a separate device per output surface, that would prevent
sharing resources.

vkGetPhysicalDeviceXlibPresentationSupportKHR only needs the Display (the X
connection) and the Visual ID (we can take the one used by the root window,
since we create child windows with CopyFromParent for the visual).

[David Yen, 2016/03/01 19:54:09]

Done (although this currently crashes on my driver...)

+          queue_index = static_cast<int>(n);

[Nico, 2016/02/24 01:28:57]

(nit: personally, i think this function could become more readable by splitting
it into several functions. guidelines i sometimes use:

1. When I do

   // Do foo.
  a();
  b();
  c();

then I sometimes extract that into

  doFoo();

2. Try to keep all things in one function at a similar level of abstraction. if
a function does "init a, init b, deeply nested loops" i try to extract the last
bit into its own function so that it's "init a, init b, do c" instead)

[David Yen, 2016/02/25 00:27:37]

Done.

+          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;
+
+  return true;
+}
+
+}  // namespace gfx