Add GpuCommandBuffer support.

Currently this is not actually hooked into the system.

To give some context, in a follow up CL I'll add this to GrDrawTarget.
For this I will move the gpu onDraw command to the GpuCommandBuffer as well.
For GL this will end up just being a pass through to a non virtual draw(...)
on GrGLGpu, and for vulkan it will mostly do what it currently does but
adding commands to the secondary command buffer instead.

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2038583002

Review-Url: https://codereview.chromium.org/2038583002

7 files changed, 171 insertions, 2 deletions

diff --git a/src/gpu/vk/GrVkCommandBuffer.cpp b/src/gpu/vk/GrVkCommandBuffer.cpp
index 9604355aad..2b636edf20 100644
--- a/src/gpu/vk/GrVkCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkCommandBuffer.cpp
@@ -311,6 +311,9 @@ void GrVkPrimaryCommandBuffer::executeCommands(const GrVkGpu* gpu,
 
     GR_VK_CALL(gpu->vkInterface(), CmdExecuteCommands(fCmdBuffer, 1, &buffer->fCmdBuffer));
     this->addResource(buffer);
+    // When executing a secondary command buffer all state (besides render pass state) becomes
+    // invalidated and must be reset. This includes bound buffers, pipelines, dynamic state, etc.
+    this->invalidateState();
 }
 
 void GrVkPrimaryCommandBuffer::submitToQueue(const GrVkGpu* gpu,
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index bc0b98ea8b..6f953653e4 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -17,6 +17,7 @@
 #include "GrTexturePriv.h"
 
 #include "GrVkCommandBuffer.h"
+#include "GrVkGpuCommandBuffer.h"
 #include "GrVkImage.h"
 #include "GrVkIndexBuffer.h"
 #include "GrVkMemory.h"
@@ -160,6 +161,15 @@ GrVkGpu::~GrVkGpu() {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+GrGpuCommandBuffer* GrVkGpu::createCommandBuffer(const GrRenderTarget& target,
+                                                 GrGpuCommandBuffer::LoadAndStoreOp colorOp,
+                                                 GrColor colorClear,
+                                                 GrGpuCommandBuffer::LoadAndStoreOp stencilOp,
+                                                 GrColor stencilClear) {
+    const GrVkRenderTarget& vkRT = static_cast<const GrVkRenderTarget&>(target);
+    return new GrVkGpuCommandBuffer(this, vkRT, colorOp, colorClear, stencilOp, stencilClear);
+}
+
 void GrVkGpu::submitCommandBuffer(SyncQueue sync) {
     SkASSERT(fCurrentCmdBuffer);
     fCurrentCmdBuffer->end(this);
@@ -1569,6 +1579,11 @@ bool GrVkGpu::onReadPixels(GrSurface* surface,
 
     return true;
 }
+
+void GrVkGpu::submitSecondaryCommandBuffer(const GrVkSecondaryCommandBuffer* buffer) {
+    fCurrentCmdBuffer->executeCommands(this, buffer);
+}
+
 sk_sp<GrVkPipelineState> GrVkGpu::prepareDrawState(const GrPipeline& pipeline,
                                                    const GrPrimitiveProcessor& primProc,
                                                    GrPrimitiveType primitiveType,
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 00055ad87c..cd72c69bd4 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -24,10 +24,11 @@ class GrPipeline;
 class GrNonInstancedMesh;
 
 class GrVkBufferImpl;
-class GrVkCommandBuffer;
 class GrVkPipeline;
 class GrVkPipelineState;
+class GrVkPrimaryCommandBuffer;
 class GrVkRenderPass;
+class GrVkSecondaryCommandBuffer;
 class GrVkTexture;
 struct GrVkInterface;
 
@@ -90,6 +91,12 @@ public:
 
     void clearStencil(GrRenderTarget* target) override;
 
+    GrGpuCommandBuffer* createCommandBuffer(const GrRenderTarget& target,
+                                            GrGpuCommandBuffer::LoadAndStoreOp colorOp,
+                                            GrColor colorClear,
+                                            GrGpuCommandBuffer::LoadAndStoreOp stencilOp,
+                                            GrColor stencilClear) override;
+
     void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {}
 
     void addMemoryBarrier(VkPipelineStageFlags srcStageMask,
@@ -109,6 +116,8 @@ public:
         return fCompiler;
     }
 
+    void submitSecondaryCommandBuffer(const GrVkSecondaryCommandBuffer*);
+
     void finishDrawTarget() override;
 
     void generateMipmap(GrVkTexture* tex) const;
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.cpp b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
new file mode 100644
index 0000000000..e9a13d4517
--- /dev/null
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
@@ -0,0 +1,92 @@
+/*
+* Copyright 2016 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#include "GrVkGpuCommandBuffer.h"
+
+#include "GrVkCommandBuffer.h"
+#include "GrVkGpu.h"
+#include "GrVkRenderPass.h"
+#include "GrVkRenderTarget.h"
+#include "GrVkResourceProvider.h"
+
+void get_vk_load_store_ops(GrGpuCommandBuffer::LoadAndStoreOp op,
+                           VkAttachmentLoadOp* loadOp, VkAttachmentStoreOp* storeOp) {
+    switch (op) {
+        case GrGpuCommandBuffer::kLoadAndStore_LoadAndStoreOp:
+            *loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+            *storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+            break;
+        case GrGpuCommandBuffer::kLoadAndDiscard_LoadAndStoreOp:
+            *loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+            *storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+            break;
+        case GrGpuCommandBuffer::kClearAndStore_LoadAndStoreOp:
+            *loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+            *storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+            break;
+        case GrGpuCommandBuffer::kClearAndDiscard_LoadAndStoreOp:
+            *loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+            *storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+            break;
+        case GrGpuCommandBuffer::kDiscardAndStore_LoadAndStoreOp:
+            *loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+            *storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+            break;
+        case GrGpuCommandBuffer::kDiscardAndDiscard_LoadAndStoreOp:
+            *loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+            *storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+            break;
+    }
+}
+
+GrVkGpuCommandBuffer::GrVkGpuCommandBuffer(GrVkGpu* gpu,
+                                           const GrVkRenderTarget& target,
+                                           LoadAndStoreOp colorOp, GrColor colorClear,
+                                           LoadAndStoreOp stencilOp, GrColor stencilClear)
+    : fGpu(gpu) {
+    VkAttachmentLoadOp vkLoadOp;
+    VkAttachmentStoreOp vkStoreOp;
+
+    get_vk_load_store_ops(colorOp, &vkLoadOp, &vkStoreOp);
+    GrVkRenderPass::LoadStoreOps vkColorOps(vkLoadOp, vkStoreOp);
+
+    get_vk_load_store_ops(stencilOp, &vkLoadOp, &vkStoreOp);
+    GrVkRenderPass::LoadStoreOps vkStencilOps(vkLoadOp, vkStoreOp);
+    
+    GrVkRenderPass::LoadStoreOps vkResolveOps(VK_ATTACHMENT_LOAD_OP_LOAD,
+                                              VK_ATTACHMENT_STORE_OP_STORE);
+
+    const GrVkResourceProvider::CompatibleRPHandle& rpHandle = target.compatibleRenderPassHandle();
+    if (rpHandle.isValid()) {
+        fRenderPass = fGpu->resourceProvider().findRenderPass(rpHandle,
+                                                              vkColorOps,
+                                                              vkResolveOps,
+                                                              vkStencilOps);
+    } else {
+        fRenderPass = fGpu->resourceProvider().findRenderPass(target,
+                                                              vkColorOps,
+                                                              vkResolveOps,
+                                                              vkStencilOps);
+    }
+
+    fCommandBuffer = GrVkSecondaryCommandBuffer::Create(gpu, gpu->cmdPool(), fRenderPass);
+    fCommandBuffer->begin(gpu, target.framebuffer());
+}
+
+GrVkGpuCommandBuffer::~GrVkGpuCommandBuffer() {
+    fCommandBuffer->unref(fGpu);
+    fRenderPass->unref(fGpu);
+}
+
+void GrVkGpuCommandBuffer::end() {
+    fCommandBuffer->end(fGpu);
+}
+
+void GrVkGpuCommandBuffer::submit() {
+    fGpu->submitSecondaryCommandBuffer(fCommandBuffer);
+}
+
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.h b/src/gpu/vk/GrVkGpuCommandBuffer.h
new file mode 100644
index 0000000000..b68aa0334c
--- /dev/null
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.h
@@ -0,0 +1,41 @@
+/*
+* Copyright 2016 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef GrVkGpuCommandBuffer_DEFINED
+#define GrVkGpuCommandBuffer_DEFINED
+
+#include "GrGpuCommandBuffer.h"
+
+#include "GrColor.h"
+
+class GrVkGpu;
+class GrVkRenderPass;
+class GrVkRenderTarget;
+class GrVkSecondaryCommandBuffer;
+
+class GrVkGpuCommandBuffer : public GrGpuCommandBuffer {
+public:
+    GrVkGpuCommandBuffer(GrVkGpu* gpu,
+                         const GrVkRenderTarget&,
+                         LoadAndStoreOp colorOp, GrColor colorClear,
+                         LoadAndStoreOp stencilOp, GrColor stencilClear);
+
+    virtual ~GrVkGpuCommandBuffer();
+
+    void end() override;
+
+    void submit() override;
+
+private:
+    const GrVkRenderPass*       fRenderPass;
+    GrVkSecondaryCommandBuffer* fCommandBuffer;
+    GrVkGpu*                    fGpu;
+
+    typedef GrGpuCommandBuffer INHERITED;
+};
+
+#endif
diff --git a/src/gpu/vk/GrVkRenderTarget.h b/src/gpu/vk/GrVkRenderTarget.h
index 735f5cdf7c..01ebf269df 100644
--- a/src/gpu/vk/GrVkRenderTarget.h
+++ b/src/gpu/vk/GrVkRenderTarget.h
@@ -53,6 +53,9 @@ public:
     const GrVkImageView* stencilAttachmentView() const;
 
     const GrVkRenderPass* simpleRenderPass() const { return fCachedSimpleRenderPass; }
+    GrVkResourceProvider::CompatibleRPHandle compatibleRenderPassHandle() const {
+        return fCompatibleRPHandle;
+    }
 
     // override of GrRenderTarget
     ResolveType getResolveType() const override {
diff --git a/src/gpu/vk/GrVkResourceProvider.cpp b/src/gpu/vk/GrVkResourceProvider.cpp
index ae333bc69e..a632be44e2 100644
--- a/src/gpu/vk/GrVkResourceProvider.cpp
+++ b/src/gpu/vk/GrVkResourceProvider.cpp
@@ -10,6 +10,7 @@
 #include "GrTextureParams.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkPipeline.h"
+#include "GrVkRenderTarget.h"
 #include "GrVkSampler.h"
 #include "GrVkUtil.h"
 
@@ -139,10 +140,15 @@ const GrVkRenderPass* GrVkResourceProvider::findRenderPass(
                                                      const GrVkRenderPass::LoadStoreOps& resolveOps,
                                                      const GrVkRenderPass::LoadStoreOps& stencilOps,
                                                      CompatibleRPHandle* compatibleHandle) {
+    GrVkResourceProvider::CompatibleRPHandle tempRPHandle;
+    GrVkResourceProvider::CompatibleRPHandle* pRPHandle = compatibleHandle ? compatibleHandle
+                                                                           : &tempRPHandle;
+    *pRPHandle = target.compatibleRenderPassHandle();
+
     // This will get us the handle to (and possible create) the compatible set for the specific
     // GrVkRenderPass we are looking for.
     this->findCompatibleRenderPass(target, compatibleHandle);
-    return this->findRenderPass(*compatibleHandle, colorOps, resolveOps, stencilOps);
+    return this->findRenderPass(*pRPHandle, colorOps, resolveOps, stencilOps);
 }
 
 const GrVkRenderPass*