Added initial implementation of the Vulkan Context Provider.

gpu/vulkan/vulkan_command_buffer.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 "gpu/vulkan/vulkan_command_buffer.h"
 
 #include "base/logging.h"
 #include "gpu/vulkan/vulkan_command_pool.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_implementation.h"
 
 namespace gpu {
 
-VulkanCommandBuffer::VulkanCommandBuffer(VulkanCommandPool* command_pool,
+VulkanCommandBuffer::VulkanCommandBuffer(VulkanDeviceQueue* device_queue,
+                                         VulkanCommandPool* command_pool,
                                          bool primary)
-    : primary_(primary), command_pool_(command_pool) {
+    : primary_(primary),
+      device_queue_(device_queue),
+      command_pool_(command_pool) {
   command_pool_->IncrementCommandBufferCount();
 }
 
 VulkanCommandBuffer::~VulkanCommandBuffer() {
   DCHECK_EQ(static_cast<VkCommandBuffer>(VK_NULL_HANDLE), command_buffer_);
   DCHECK_EQ(static_cast<VkFence>(VK_NULL_HANDLE), submission_fence_);
   DCHECK(!recording_);
   command_pool_->DecrementCommandBufferCount();
 }
 
 bool VulkanCommandBuffer::Initialize() {
   VkResult result = VK_SUCCESS;
-  VkDevice device = GetVulkanDevice();
+  VkDevice device = device_queue_->GetVulkanDevice();
 
   VkCommandBufferAllocateInfo command_buffer_info = {};
   command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
   command_buffer_info.commandPool = command_pool_->handle();
   command_buffer_info.level = primary_ ? VK_COMMAND_BUFFER_LEVEL_PRIMARY
                                        : VK_COMMAND_BUFFER_LEVEL_SECONDARY;
   command_buffer_info.commandBufferCount = 1;
 
   result =
       vkAllocateCommandBuffers(device, &command_buffer_info, &command_buffer_);
@@ skipping 11 matching lines @@
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkCreateFence(submission) failed: " << result;
     return false;
   }
 
   record_type_ = RECORD_TYPE_EMPTY;
   return true;
 }
 
 void VulkanCommandBuffer::Destroy() {
-  VkDevice device = GetVulkanDevice();
+  VkDevice device = device_queue_->GetVulkanDevice();
   if (VK_NULL_HANDLE != submission_fence_) {
     DCHECK(SubmissionFinished());
     vkDestroyFence(device, submission_fence_, nullptr);
     submission_fence_ = VK_NULL_HANDLE;
   }
 
   if (VK_NULL_HANDLE != command_buffer_) {
     vkFreeCommandBuffers(device, command_pool_->handle(), 1, &command_buffer_);
     command_buffer_ = VK_NULL_HANDLE;
   }
 }
 
-bool VulkanCommandBuffer::Submit(VkQueue queue,
-                                 uint32_t num_wait_semaphores,
+bool VulkanCommandBuffer::Submit(uint32_t num_wait_semaphores,
                                  VkSemaphore* wait_semaphores,
                                  uint32_t num_signal_semaphores,
                                  VkSemaphore* signal_semaphores) {
   DCHECK(primary_);
   VkSubmitInfo submit_info = {};
   submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
   submit_info.commandBufferCount = 1;
   submit_info.pCommandBuffers = &command_buffer_;
   submit_info.waitSemaphoreCount = num_wait_semaphores;
   submit_info.pWaitSemaphores = wait_semaphores;
   submit_info.signalSemaphoreCount = num_signal_semaphores;
   submit_info.pSignalSemaphores = signal_semaphores;
 
-  vkResetFences(GetVulkanDevice(), 1, &submission_fence_);
-  VkResult result = vkQueueSubmit(queue, 1, &submit_info, submission_fence_);
+  VkResult result = VK_SUCCESS;
+
+  result =
+      vkResetFences(device_queue_->GetVulkanDevice(), 1, &submission_fence_);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkResetFences() failed: " << result;
+    return false;
+  }
+
+  result = vkQueueSubmit(device_queue_->GetVulkanQueue(), 1, &submit_info,
+                         submission_fence_);
+
   PostExecution();
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkQueueSubmit() failed: " << result;
     return false;
   }
 
   return true;
 }
 
 void VulkanCommandBuffer::Enqueue(VkCommandBuffer primary_command_buffer) {
   DCHECK(!primary_);
   vkCmdExecuteCommands(primary_command_buffer, 1, &command_buffer_);
   PostExecution();
 }
 
 void VulkanCommandBuffer::Clear() {
   // Mark to reset upon next use.
   if (record_type_ != RECORD_TYPE_EMPTY)
     record_type_ = RECORD_TYPE_DIRTY;
 }
 
 void VulkanCommandBuffer::Wait(uint64_t timeout) {
-  vkWaitForFences(GetVulkanDevice(), 1, &submission_fence_, true, timeout);
+  VkDevice device = device_queue_->GetVulkanDevice();
+  vkWaitForFences(device, 1, &submission_fence_, true, timeout);
 }
 
 bool VulkanCommandBuffer::SubmissionFinished() {
-  return VK_SUCCESS == vkGetFenceStatus(GetVulkanDevice(), submission_fence_);
+  VkDevice device = device_queue_->GetVulkanDevice();
+  return VK_SUCCESS == vkGetFenceStatus(device, submission_fence_);
 }
 
 void VulkanCommandBuffer::PostExecution() {
   if (record_type_ == RECORD_TYPE_SINGLE_USE) {
     // Clear upon next use.
     record_type_ = RECORD_TYPE_DIRTY;
   } else if (record_type_ == RECORD_TYPE_MULTI_USE) {
     // Can no longer record new items unless marked as clear.
     record_type_ = RECORD_TYPE_RECORDED;
   }
 }
 
 void VulkanCommandBuffer::ResetIfDirty() {
   DCHECK(!recording_);
   if (record_type_ == RECORD_TYPE_DIRTY) {
     // Block if command buffer is still in use. This can be externally avoided
     // using the asynchronous SubmissionFinished() function.
-    vkWaitForFences(GetVulkanDevice(), 1, &submission_fence_, true, UINT64_MAX);
+    VkDevice device = device_queue_->GetVulkanDevice();
+    vkWaitForFences(device, 1, &submission_fence_, true, UINT64_MAX);
 
     vkResetCommandBuffer(command_buffer_, 0);
     record_type_ = RECORD_TYPE_EMPTY;
   }
 }
 
 CommandBufferRecorderBase::~CommandBufferRecorderBase() {
   vkEndCommandBuffer(handle_);
 };
 
@@ skipping 10 matching lines @@
     VulkanCommandBuffer& command_buffer)
     : CommandBufferRecorderBase(command_buffer) {
   ValidateSingleUse(command_buffer);
   VkCommandBufferBeginInfo begin_info = {};
   begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
   begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
   vkBeginCommandBuffer(handle_, &begin_info);
 }
 
 }  // namespace gpu