Start using GrGpuCommandBuffer in GrDrawTarget.

src/gpu/vk/GrVkGpu.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 GrVkGpu_DEFINED
 #define GrVkGpu_DEFINED
 
@@ skipping 47 matching lines @@
     };
 
     bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
                              GrPixelConfig readConfig, DrawPreference*,
                              ReadPixelTempDrawInfo*) override;
 
     bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
                               GrPixelConfig srcConfig, DrawPreference*,
                               WritePixelTempDrawInfo*) override;
 
-    void discard(GrRenderTarget*) override {}
-
     bool onCopySurface(GrSurface* dst,
                        GrSurface* src,
                        const SkIRect& srcRect,
                        const SkIPoint& dstPoint) override;
 
     void onGetMultisampleSpecs(GrRenderTarget* rt,
                                const GrStencilSettings&,
                                int* effectiveSampleCnt,
                                SkAutoTDeleteArray<SkPoint>*) override;
 
     bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const override;
 
     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
 
     GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
                                                     GrPixelConfig config) override;
     bool isTestingOnlyBackendTexture(GrBackendObject id) const override;
     void deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) override;
 
     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
                                                                 int width,
                                                                 int height) override;
 
     void clearStencil(GrRenderTarget* target) override;
 
-    GrGpuCommandBuffer* createCommandBuffer(const GrRenderTarget& target,
+    GrGpuCommandBuffer* createCommandBuffer(GrRenderTarget* target,
                                             GrGpuCommandBuffer::LoadAndStoreOp colorOp,
                                             GrColor colorClear,
                                             GrGpuCommandBuffer::LoadAndStoreOp stencilOp,
                                             GrColor stencilClear) override;
 
     void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {}
 
     void addMemoryBarrier(VkPipelineStageFlags srcStageMask,
                           VkPipelineStageFlags dstStageMask,
                           bool byRegion,
                           VkMemoryBarrier* barrier) const;
     void addBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                 VkPipelineStageFlags dstStageMask,
                                 bool byRegion,
                                 VkBufferMemoryBarrier* barrier) const;
     void addImageMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                VkPipelineStageFlags dstStageMask,
                                bool byRegion,
                                VkImageMemoryBarrier* barrier) const;
 
     shaderc_compiler_t shadercCompiler() const {
         return fCompiler;
     }
 
-    void submitSecondaryCommandBuffer(const GrVkSecondaryCommandBuffer*);
+    void submitSecondaryCommandBuffer(const GrVkSecondaryCommandBuffer*,
+                                      const GrVkRenderPass*,
+                                      const VkClearValue*,
+                                      GrVkRenderTarget*,
+                                      const SkIRect& bounds);
 
     void finishDrawTarget() override;
 
     void generateMipmap(GrVkTexture* tex) const;
 
     // Heaps
     enum Heap {
         kLinearImage_Heap = 0,
         // We separate out small (i.e., <= 16K) images to reduce fragmentation
         // in the main heap.
@@ skipping 27 matching lines @@
 
     GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;
 
     GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
                                               GrWrapOwnership) override;
     GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) override { return NULL; }
 
     GrBuffer* onCreateBuffer(size_t size, GrBufferType type, GrAccessPattern,
                              const void* data) override;
 
-    void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) override;
-
-    void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override;
-
-    void onDraw(const GrPipeline&,
-                const GrPrimitiveProcessor&,
-                const GrMesh*,
-                int meshCount) override;
-
     bool onReadPixels(GrSurface* surface,
                       int left, int top, int width, int height,
                       GrPixelConfig,
                       void* buffer,
                       size_t rowBytes) override;
 
     bool onWritePixels(GrSurface* surface,
                        int left, int top, int width, int height,
                        GrPixelConfig config, const SkTArray<GrMipLevel>&) override;
 
     bool onTransferPixels(GrSurface*,
                           int left, int top, int width, int height,
                           GrPixelConfig config, GrBuffer* transferBuffer,
                           size_t offset, size_t rowBytes) override { return false; }
 
     void onResolveRenderTarget(GrRenderTarget* target) override {}
 
-    sk_sp<GrVkPipelineState> prepareDrawState(const GrPipeline&,
-                                              const GrPrimitiveProcessor&,
-                                              GrPrimitiveType,
-                                              const GrVkRenderPass&);
-
-    // Bind vertex and index buffers
-    void bindGeometry(const GrPrimitiveProcessor&, const GrNonInstancedMesh&);
-
     // Ends and submits the current command buffer to the queue and then creates a new command
     // buffer and begins it. If sync is set to kForce_SyncQueue, the function will wait for all
     // work in the queue to finish before returning.
     void submitCommandBuffer(SyncQueue sync);
 
     void copySurfaceAsCopyImage(GrSurface* dst,
                                 GrSurface* src,
                                 GrVkImage* dstImage,
                                 GrVkImage* srcImage,
                                 const SkIRect& srcRect,
@@ skipping 45 matching lines @@
 
     // Shaderc compiler used for compiling glsl in spirv. We only want to create the compiler once
     // since there is significant overhead to the first compile of any compiler.
     shaderc_compiler_t fCompiler;
 
 
     typedef GrGpu INHERITED;
 };
 
 #endif