Added initial implementation of the Vulkan Context Provider.

gpu/vulkan/vulkan_swap_chain.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_swap_chain.h"
 
 #include "gpu/vulkan/vulkan_command_buffer.h"
 #include "gpu/vulkan/vulkan_command_pool.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_image_view.h"
 #include "gpu/vulkan/vulkan_implementation.h"
 
 namespace gpu {
 
 VulkanSwapChain::VulkanSwapChain() {}
 
 VulkanSwapChain::~VulkanSwapChain() {
   DCHECK(images_.empty());
   DCHECK_EQ(static_cast<VkSwapchainKHR>(VK_NULL_HANDLE), swap_chain_);
   DCHECK_EQ(static_cast<VkSemaphore>(VK_NULL_HANDLE), next_present_semaphore_);
 }
 
-bool VulkanSwapChain::Initialize(VkSurfaceKHR surface,
+bool VulkanSwapChain::Initialize(VulkanDeviceQueue* device_queue,
+                                 VkSurfaceKHR surface,
                                  const VkSurfaceCapabilitiesKHR& surface_caps,
                                  const VkSurfaceFormatKHR& surface_format) {
+  DCHECK(device_queue);
+  device_queue_ = device_queue;
   return InitializeSwapChain(surface, surface_caps, surface_format) &&
          InitializeSwapImages(surface_caps, surface_format);
 }
 
 void VulkanSwapChain::Destroy() {
   DestroySwapImages();
   DestroySwapChain();
 }
 
 gfx::SwapResult VulkanSwapChain::SwapBuffers() {
   VkResult result = VK_SUCCESS;
 
-  VkDevice device = GetVulkanDevice();
-  VkQueue queue = GetVulkanQueue();
+  VkDevice device = device_queue_->GetVulkanDevice();
+  VkQueue queue = device_queue_->GetVulkanQueue();
 
   scoped_ptr<ImageData>& current_image_data = images_[current_image_];
 
   // Default image subresource range.
   VkImageSubresourceRange image_subresource_range = {};
   image_subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
   image_subresource_range.baseMipLevel = 0;
   image_subresource_range.levelCount = 1;
   image_subresource_range.baseArrayLayer = 0;
   image_subresource_range.layerCount = 1;
 
   // Submit our command buffer for the current buffer.
   if (!current_image_data->command_buffer->Submit(
-          queue, 1, &current_image_data->present_semaphore, 1,
+          1, &current_image_data->present_semaphore, 1,
           &current_image_data->render_semaphore)) {
     return gfx::SwapResult::SWAP_FAILED;
   }
 
   // Queue the present.
   VkPresentInfoKHR present_info = {};
   present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
   present_info.waitSemaphoreCount = 1;
   present_info.pWaitSemaphores = &current_image_data->render_semaphore;
   present_info.swapchainCount = 1;
   present_info.pSwapchains = &swap_chain_;
   present_info.pImageIndices = &current_image_;
 
   result = vkQueuePresentKHR(queue, &present_info);
   if (VK_SUCCESS != result) {
     return gfx::SwapResult::SWAP_FAILED;
   }
 
   // Acquire then next image.
   result = vkAcquireNextImageKHR(device, swap_chain_, UINT64_MAX,
                                  next_present_semaphore_, VK_NULL_HANDLE,
                                  &current_image_);
   if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkAcquireNextImageKHR() failed: " << result;
     return gfx::SwapResult::SWAP_FAILED;
   }
 
   // Swap in the "next_present_semaphore" into the newly acquired image. The
   // old "present_semaphore" for the image becomes the place holder for the next
   // present semaphore for the next image.
   std::swap(images_[current_image_]->present_semaphore,
             next_present_semaphore_);
 
   return gfx::SwapResult::SWAP_ACK;
 }
 
 bool VulkanSwapChain::InitializeSwapChain(
     VkSurfaceKHR surface,
     const VkSurfaceCapabilitiesKHR& surface_caps,
     const VkSurfaceFormatKHR& surface_format) {
-  VkDevice device = GetVulkanDevice();
+  VkDevice device = device_queue_->GetVulkanDevice();
   VkResult result = VK_SUCCESS;
 
   VkSwapchainCreateInfoKHR swap_chain_create_info = {};
   swap_chain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
   swap_chain_create_info.surface = surface;
   swap_chain_create_info.minImageCount =
       std::max(2u, surface_caps.minImageCount);
   swap_chain_create_info.imageFormat = surface_format.format;
   swap_chain_create_info.imageColorSpace = surface_format.colorSpace;
   swap_chain_create_info.imageExtent = surface_caps.currentExtent;
@@ skipping 17 matching lines @@
   Destroy();
 
   swap_chain_ = new_swap_chain;
   size_ = gfx::Size(swap_chain_create_info.imageExtent.width,
                     swap_chain_create_info.imageExtent.height);
 
   return true;
 }
 
 void VulkanSwapChain::DestroySwapChain() {
-  VkDevice device = GetVulkanDevice();
+  VkDevice device = device_queue_->GetVulkanDevice();
 
   if (swap_chain_ != VK_NULL_HANDLE) {
     vkDestroySwapchainKHR(device, swap_chain_, nullptr);
     swap_chain_ = VK_NULL_HANDLE;
   }
 }
 
 bool VulkanSwapChain::InitializeSwapImages(
     const VkSurfaceCapabilitiesKHR& surface_caps,
     const VkSurfaceFormatKHR& surface_format) {
-  VkDevice device = GetVulkanDevice();
+  VkDevice device = device_queue_->GetVulkanDevice();
   VkResult result = VK_SUCCESS;
 
   uint32_t image_count = 0;
   result = vkGetSwapchainImagesKHR(device, swap_chain_, &image_count, nullptr);
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkGetSwapchainImagesKHR(NULL) failed: " << result;
     return false;
   }
 
   std::vector<VkImage> images(image_count);
@@ skipping 19 matching lines @@
   // The image memory barrier is used to setup the image layout.
   VkImageMemoryBarrier image_memory_barrier = {};
   image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
   image_memory_barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
   image_memory_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
   image_memory_barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
   image_memory_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
   image_memory_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
   image_memory_barrier.subresourceRange = image_subresource_range;
 
-  command_pool_ = CreateCommandPool();
+  command_pool_ = device_queue_->CreateCommandPool();
   if (!command_pool_)
     return false;
 
   images_.resize(image_count);
   for (uint32_t i = 0; i < image_count; ++i) {
     images_[i].reset(new ImageData);
     scoped_ptr<ImageData>& image_data = images_[i];
     image_data->image = images[i];
 
     // Setup semaphores.
@@ skipping 16 matching lines @@
 
     // Setup the Image Layout as the first command that gets issued in each
     // command buffer.
     ScopedSingleUseCommandBufferRecorder recorder(*image_data->command_buffer);
     image_memory_barrier.image = images[i];
     vkCmdPipelineBarrier(recorder.handle(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                          VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 0,
                          nullptr, 1, &image_memory_barrier);
 
     // Create the image view.
-    image_data->image_view.reset(new VulkanImageView);
+    image_data->image_view.reset(new VulkanImageView(device_queue_));
     if (!image_data->image_view->Initialize(
             images[i], VK_IMAGE_VIEW_TYPE_2D, VulkanImageView::IMAGE_TYPE_COLOR,
             surface_format.format, size_.width(), size_.height(), 0, 1, 0, 1)) {
       return false;
     }
   }
 
   result = vkCreateSemaphore(device, &semaphore_create_info, nullptr,
                              &next_present_semaphore_);
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkCreateSemaphore(next_present) failed: " << result;
     return false;
   }
 
   // Acquire the initial buffer.
-  result = vkAcquireNextImageKHR(GetVulkanDevice(), swap_chain_, UINT64_MAX,
+  result = vkAcquireNextImageKHR(device, swap_chain_, UINT64_MAX,
                                  next_present_semaphore_, VK_NULL_HANDLE,
                                  &current_image_);
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkAcquireNextImageKHR() failed: " << result;
     return false;
   }
 
   std::swap(images_[current_image_]->present_semaphore,
             next_present_semaphore_);
 
   return true;
 }
 
 void VulkanSwapChain::DestroySwapImages() {
-  VkDevice device = GetVulkanDevice();
+  VkDevice device = device_queue_->GetVulkanDevice();
 
   if (VK_NULL_HANDLE != next_present_semaphore_) {
     vkDestroySemaphore(device, next_present_semaphore_, nullptr);
     next_present_semaphore_ = VK_NULL_HANDLE;
   }
 
   for (const scoped_ptr<ImageData>& image_data : images_) {
     if (image_data->command_buffer) {
       // Make sure command buffer is done processing.
       image_data->command_buffer->Wait(UINT64_MAX);
@@ skipping 27 matching lines @@
     command_pool_->Destroy();
     command_pool_.reset();
   }
 }
 
 VulkanSwapChain::ImageData::ImageData() {}
 
 VulkanSwapChain::ImageData::~ImageData() {}
 
 }  // namespace gpu