Added initial implementation of the Vulkan Context Provider.

gpu/vulkan/tests/vulkan_test.cc

 // Copyright 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/tests/native_window.h"
 #include "gpu/vulkan/vulkan_command_buffer.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
 #include "gpu/vulkan/vulkan_render_pass.h"
 #include "gpu/vulkan/vulkan_surface.h"
 #include "gpu/vulkan/vulkan_swap_chain.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 
 // This file tests basic vulkan initialization steps.
 
 namespace gpu {
 
 class BasicVulkanTest : public testing::Test {
  public:
   void SetUp() override {
     const gfx::Rect kDefaultBounds(10, 10, 100, 100);
     window_ = CreateNativeWindow(kDefaultBounds);
+    device_queue_.Initialize(
+        VulkanDeviceQueue::GRAPHICS_QUEUE_FLAG |
+        VulkanDeviceQueue::PRESENTATION_SUPPORT_QUEUE_FLAG);
   }
 
   void TearDown() override {
     DestroyNativeWindow(window_);
     window_ = gfx::kNullAcceleratedWidget;
+    device_queue_.Destroy();
   }
 
   gfx::AcceleratedWidget window() const { return window_; }
+  VulkanDeviceQueue* GetDeviceQueue() { return &device_queue_; }
 
  private:
+  VulkanDeviceQueue device_queue_;
   gfx::AcceleratedWidget window_ = gfx::kNullAcceleratedWidget;
 };
 
 TEST_F(BasicVulkanTest, BasicVulkanSurface) {
   scoped_ptr<VulkanSurface> surface =
       VulkanSurface::CreateViewSurface(window());
   EXPECT_TRUE(surface);
-  EXPECT_TRUE(surface->Initialize(VulkanSurface::DEFAULT_SURFACE_FORMAT));
+  EXPECT_TRUE(surface->Initialize(GetDeviceQueue(),
+                                  VulkanSurface::DEFAULT_SURFACE_FORMAT));
   surface->Destroy();
 }
 
 TEST_F(BasicVulkanTest, EmptyVulkanSwaps) {
   scoped_ptr<VulkanSurface> surface =
       VulkanSurface::CreateViewSurface(window());
   ASSERT_TRUE(surface);
-  ASSERT_TRUE(surface->Initialize(VulkanSurface::DEFAULT_SURFACE_FORMAT));
+  ASSERT_TRUE(surface->Initialize(GetDeviceQueue(),
+                                  VulkanSurface::DEFAULT_SURFACE_FORMAT));
 
   // First swap is a special case, call it first to get better errors.
   EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
 
   // Also make sure we can swap multiple times.
   for (int i = 0; i < 10; ++i) {
     EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
   }
   surface->Finish();
   surface->Destroy();
 }
 
 TEST_F(BasicVulkanTest, BasicRenderPass) {
   scoped_ptr<VulkanSurface> surface =
       VulkanSurface::CreateViewSurface(window());
   ASSERT_TRUE(surface);
-  ASSERT_TRUE(surface->Initialize(VulkanSurface::DEFAULT_SURFACE_FORMAT));
+  ASSERT_TRUE(surface->Initialize(GetDeviceQueue(),
+                                  VulkanSurface::DEFAULT_SURFACE_FORMAT));
   VulkanSwapChain* swap_chain = surface->GetSwapChain();
 
   VulkanRenderPass::RenderPassData render_pass_data;
 
   // There is a single attachment which transitions present -> color -> present.
   render_pass_data.attachments.resize(1);
   VulkanRenderPass::AttachmentData* attachment =
       &render_pass_data.attachments[0];
   attachment->attachment_type =
       VulkanRenderPass::AttachmentType::ATTACHMENT_TYPE_SWAP_IMAGE;
@@ skipping 15 matching lines @@
   // Our subpass will handle the transition to Color.
   subpass_data->subpass_attachments.resize(1);
   VulkanRenderPass::SubpassAttachment* subpass_attachment =
       &subpass_data->subpass_attachments[0];
   subpass_attachment->attachment_index = 0;
   subpass_attachment->subpass_layout =
       VulkanRenderPass::ImageLayoutType::IMAGE_LAYOUT_TYPE_IMAGE_VIEW;
 
   ASSERT_TRUE(render_pass_data.ValidateData(swap_chain));
 
-  VulkanRenderPass render_pass;
+  VulkanRenderPass render_pass(GetDeviceQueue());
   EXPECT_TRUE(render_pass.Initialize(swap_chain, render_pass_data));
 
   for (int i = 0; i < 10; ++i) {
     VulkanCommandBuffer* command_buffer = swap_chain->GetCurrentCommandBuffer();
     {
       ScopedSingleUseCommandBufferRecorder recorder(*command_buffer);
 
       render_pass.BeginRenderPass(recorder, true);
       render_pass.EndRenderPass(recorder);
     }
 
     EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
   }
 
   surface->Finish();
   render_pass.Destroy();
   surface->Destroy();
 }
 
 }  // namespace gpu