Added the Vulkan Context Provider implementation.

cc/output/vulkan_in_process_context_provider.cc

 // 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 "cc/output/vulkan_in_process_context_provider.h"
 
 #include <vector>
 
 #include "gpu/vulkan/vulkan_device_queue.h"
+#include "gpu/vulkan/vulkan_surface.h"
 
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
 #include "ui/gfx/x/x11_types.h"
 #endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
 
 namespace cc {
 
 scoped_refptr<VulkanInProcessContextProvider>
 VulkanInProcessContextProvider::Create() {
+  static bool vulkan_initialized = false;

[David Yen, 2016/04/16 01:32:38]

Not sure where the best place to call this is yet, this should be good enough
for now?

[piman, 2016/04/19 01:36:42]

BrowserMainLoop::BrowserThreadsStarted is probably the right place for it - next
to BrowserGpuChannelHostFactory::Initialize

[David Yen, 2016/04/19 22:20:28]

Done. I also just removed the InitializeOneOff() function from VulkanSurface, I
think just calling InitializeVulkan from vulkan_implementation should be good
enough. I also added a function to check whether or not the initialization
succeeded "gpu::VulkanSupported()" in vulkan_implementation.

[piman, 2016/04/19 23:42:02]

Yeah, it sounds better.

+  static bool vulkan_supported = false;
+  if (!vulkan_initialized) {
+    vulkan_initialized = true;
+    vulkan_supported = gpu::VulkanSurface::InitializeOneOff();
+  }
+  if (!vulkan_supported)
+    return nullptr;
+
   scoped_refptr<VulkanInProcessContextProvider> context_provider(
       new VulkanInProcessContextProvider);
   if (!context_provider->Initialize())
     return nullptr;
   return context_provider;
 }
 
 bool VulkanInProcessContextProvider::Initialize() {
   std::unique_ptr<gpu::VulkanDeviceQueue> device_queue(
       new gpu::VulkanDeviceQueue);
-  if (device_queue->Initialize(
+  if (!device_queue->Initialize(
           gpu::VulkanDeviceQueue::GRAPHICS_QUEUE_FLAG |
           gpu::VulkanDeviceQueue::PRESENTATION_SUPPORT_QUEUE_FLAG)) {
-    device_queue_ = std::move(device_queue);
-    return true;
+    return false;
   }
 
-  return false;
+  device_queue_ = std::move(device_queue);
+  return true;
+}
+
+void VulkanInProcessContextProvider::SwapBuffers() {
+  // Has no output surface attached to this.
+  NOTIMPLEMENTED();
 }
 
 void VulkanInProcessContextProvider::Destroy() {
   if (device_queue_) {
     device_queue_->Destroy();
     device_queue_.reset();
   }
 }
 
 gpu::VulkanDeviceQueue* VulkanInProcessContextProvider::GetDeviceQueue() {
   return device_queue_.get();
 }
 
 VulkanInProcessContextProvider::VulkanInProcessContextProvider() {}
 
 VulkanInProcessContextProvider::~VulkanInProcessContextProvider() {}
 
 }  // namespace cc