Added initial implementation of Vulkan Render Passes.

gpu/vulkan/vulkan_command_buffer.h

Index: gpu/vulkan/vulkan_command_buffer.h
diff --git a/gpu/vulkan/vulkan_command_buffer.h b/gpu/vulkan/vulkan_command_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..56aa0844608f1ed913c09f4959056f02e9ec83cc
--- /dev/null
+++ b/gpu/vulkan/vulkan_command_buffer.h
@@ -0,0 +1,130 @@
+// 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.
+
+#ifndef GPU_VULKAN_VULKAN_COMMAND_BUFFER_H_
+#define GPU_VULKAN_VULKAN_COMMAND_BUFFER_H_
+
+#include <vulkan/vulkan.h>
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace gfx {
+
+class VulkanCommandBuffer {
+ public:
+  VulkanCommandBuffer(VkCommandPool command_pool, bool primary);
+  ~VulkanCommandBuffer();
+
+  bool Initialize();
+  void Destroy();
+
+  // Submit primary command buffer to the queue.
+  bool Submit();

[piman, 2016/03/09 01:25:33]

I would prefer being explicit here and passing the queue. It's likely we'll want
to take advantage of a separate transfer queue if available.

[David Yen, 2016/03/10 01:39:48]

Done.

+
+  // Enqueue secondary command buffer within a primary command buffer.
+  void Enqueue(VkCommandBuffer primary_command_buffer);
+
+  void Clear();
+
+ private:
+  friend class CommandBufferRecorderBase;
+
+  enum RecordType {
+    // Nothing has been recorded yet.
+    RECORD_TYPE_EMPTY,
+
+    // Recorded for single use, will be reset upon submission.
+    RECORD_TYPE_SINGLE_USE,
+
+    // Recording for multi use, once submitted it can't be modified until reset.
+    RECORD_TYPE_MULTI_USE,
+
+    // Recorded for multi-use, can no longer be modified unless reset.
+    RECORD_TYPE_RECORDED,
+
+    // Dirty, should be cleared before use. This assumes its externally
+    // synchronized and the command buffer is no longer in use.
+    RECORD_TYPE_DIRTY,
+  };
+
+  void PostExecution();
+  void ResetIfDirty();
+
+  const bool primary_;
+  bool recording_ = false;
+  RecordType record_type_ = RECORD_TYPE_EMPTY;
+  VkCommandBuffer command_buffer_ = VK_NULL_HANDLE;
+  VkCommandPool command_pool_;
+
+  DISALLOW_COPY_AND_ASSIGN(VulkanCommandBuffer);
+};
+
+class CommandBufferRecorderBase {
+ public:
+  VkCommandBuffer handle() { return handle_; }
+
+ protected:
+  CommandBufferRecorderBase(VulkanCommandBuffer& command_buffer)
+      : handle_(command_buffer.command_buffer_) {
+    command_buffer.ResetIfDirty();
+  }
+
+  virtual ~CommandBufferRecorderBase();
+
+  void ValidateSingleUse(VulkanCommandBuffer& command_buffer) {
+    DCHECK((VulkanCommandBuffer::RECORD_TYPE_SINGLE_USE ==
+            command_buffer.record_type_) ||
+           (VulkanCommandBuffer::RECORD_TYPE_EMPTY ==
+            command_buffer.record_type_));
+    command_buffer.record_type_ = VulkanCommandBuffer::RECORD_TYPE_SINGLE_USE;
+  }
+
+  void ValidateMultiUse(VulkanCommandBuffer& command_buffer) {
+    DCHECK((VulkanCommandBuffer::RECORD_TYPE_MULTI_USE ==
+            command_buffer.record_type_) ||
+           (VulkanCommandBuffer::RECORD_TYPE_EMPTY ==
+            command_buffer.record_type_));
+    command_buffer.record_type_ = VulkanCommandBuffer::RECORD_TYPE_MULTI_USE;
+  }
+
+  VkCommandBuffer handle_;
+};
+
+class ScopedMultiUseCommandBufferRecorder : public CommandBufferRecorderBase {
+ public:
+  ScopedMultiUseCommandBufferRecorder(VulkanCommandBuffer& command_buffer)
+      : CommandBufferRecorderBase(command_buffer) {
+    ValidateMultiUse(command_buffer);
+    VkCommandBufferBeginInfo begin_info = {};
+    begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+    vkBeginCommandBuffer(handle_, &begin_info);
+  }
+
+  ~ScopedMultiUseCommandBufferRecorder() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedMultiUseCommandBufferRecorder);
+};
+
+class ScopedSingleUseCommandBufferRecorder : public CommandBufferRecorderBase {
+ public:
+  ScopedSingleUseCommandBufferRecorder(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);
+  }
+
+  ~ScopedSingleUseCommandBufferRecorder() override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedSingleUseCommandBufferRecorder);
+};
+
+}  // namespace gfx
+
+#endif  // GPU_VULKAN_VULKAN_COMMAND_BUFFER_H_