Start using GrGpuCommandBuffer in GrDrawTarget.

src/gpu/vk/GrVkCommandBuffer.h

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #ifndef GrVkCommandBuffer_DEFINED
 #define GrVkCommandBuffer_DEFINED
 
 #include "GrVkGpu.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "vk/GrVkDefines.h"
 
 class GrVkFramebuffer;
 class GrVkPipeline;
 class GrVkRenderPass;
 class GrVkRenderTarget;
 class GrVkTransferBuffer;
 
 class GrVkCommandBuffer : public GrVkResource {
 public:
-    ~GrVkCommandBuffer() override;
-
     void invalidateState();
 
     ////////////////////////////////////////////////////////////////////////////
     // CommandBuffer commands
     ////////////////////////////////////////////////////////////////////////////
     enum BarrierType {
         kMemory_BarrierType,
         kBufferMemory_BarrierType,
         kImageMemory_BarrierType
     };
@@ skipping 82 matching lines @@
         resource->ref();
         fTrackedResources.push_back(resource);
     }
 
 protected:
         GrVkCommandBuffer(VkCommandBuffer cmdBuffer, const GrVkRenderPass* rp = VK_NULL_HANDLE)
             : fTrackedResources(kInitialTrackedResourcesCount)
             , fIsActive(false)
             , fActiveRenderPass(rp)
             , fCmdBuffer(cmdBuffer)
-            , fSubmitFence(VK_NULL_HANDLE)
             , fBoundVertexBufferIsValid(false)
             , fBoundIndexBufferIsValid(false) {
             this->invalidateState();
         }
         SkTArray<const GrVkResource*, true>     fTrackedResources;
 
         // Tracks whether we are in the middle of a command buffer begin/end calls and thus can add
         // new commands to the buffer;
         bool fIsActive;
 
         // Stores a pointer to the current active render pass (i.e. begin has been called but not
         // end). A nullptr means there is no active render pass. The GrVKCommandBuffer does not own
         // the render pass.
         const GrVkRenderPass*     fActiveRenderPass;
 
         VkCommandBuffer           fCmdBuffer;
-        VkFence                   fSubmitFence;
 
 private:
     static const int kInitialTrackedResourcesCount = 32;
 
     void freeGPUData(const GrVkGpu* gpu) const override;
+    virtual void onFreeGPUData(const GrVkGpu* gpu) const = 0;
     void abandonSubResources() const override;
 
     VkBuffer                                fBoundVertexBuffer;
     bool                                    fBoundVertexBufferIsValid;
 
     VkBuffer                                fBoundIndexBuffer;
     bool                                    fBoundIndexBufferIsValid;
 
     // Cached values used for dynamic state updates
     VkViewport fCachedViewport;
     VkRect2D   fCachedScissor;
     float      fCachedBlendConstant[4];
 };
 
 class GrVkSecondaryCommandBuffer;
 
 class GrVkPrimaryCommandBuffer : public GrVkCommandBuffer {
 public:
+    ~GrVkPrimaryCommandBuffer() override;
+
     static GrVkPrimaryCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool);
 
     void begin(const GrVkGpu* gpu);
     void end(const GrVkGpu* gpu);
 
     // Begins render pass on this command buffer. The framebuffer from GrVkRenderTarget will be used
     // in the render pass.
     void beginRenderPass(const GrVkGpu* gpu,
                          const GrVkRenderPass* renderPass,
-                         const GrVkRenderTarget& target);
+                         const GrVkRenderTarget& target,
+                         const SkIRect& bounds,
+                         bool forSecondaryCB);
     void endRenderPass(const GrVkGpu* gpu);
 
     // Submits the SecondaryCommandBuffer into this command buffer. It is required that we are
     // currently inside a render pass that is compatible with the one used to create the
     // SecondaryCommandBuffer.
     void executeCommands(const GrVkGpu* gpu,
                          const GrVkSecondaryCommandBuffer* secondaryBuffer);
 
     // Commands that only work outside of a render pass
     void clearColorImage(const GrVkGpu* gpu,
@@ skipping 56 matching lines @@
                            GrVkTransferBuffer* srcBuffer,
                            GrVkImage* dstImage,
                            VkImageLayout dstLayout,
                            uint32_t copyRegionCount,
                            const VkBufferImageCopy* copyRegions);
 
     void submitToQueue(const GrVkGpu* gpu, VkQueue queue, GrVkGpu::SyncQueue sync);
     bool finished(const GrVkGpu* gpu) const;
 
 private:
-    explicit GrVkPrimaryCommandBuffer(VkCommandBuffer cmdBuffer) : INHERITED(cmdBuffer) {}
+    explicit GrVkPrimaryCommandBuffer(VkCommandBuffer cmdBuffer)
+        : INHERITED(cmdBuffer)
+        , fSubmitFence(VK_NULL_HANDLE) {}
+
+    void onFreeGPUData(const GrVkGpu* gpu) const override;
+
+    VkFence                   fSubmitFence;
 
     typedef GrVkCommandBuffer INHERITED;
 };
 
 class GrVkSecondaryCommandBuffer : public GrVkCommandBuffer {
 public:
     static GrVkSecondaryCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool, 
                                               const GrVkRenderPass* compatibleRenderPass);
 
     void begin(const GrVkGpu* gpu, const GrVkFramebuffer* framebuffer);
     void end(const GrVkGpu* gpu);
 
 private:
     explicit GrVkSecondaryCommandBuffer(VkCommandBuffer cmdBuffer,
                                         const GrVkRenderPass* compatibleRenderPass)
         : INHERITED(cmdBuffer, compatibleRenderPass) {
     }
 
+    void onFreeGPUData(const GrVkGpu* gpu) const override {}
+
     friend class GrVkPrimaryCommandBuffer;
 
     typedef GrVkCommandBuffer INHERITED;
 };
 
 #endif