Start using GrGpuCommandBuffer in GrDrawTarget.

src/gpu/GrGpuCommandBuffer.h

 /*
 * 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 GrGpuCommandBuffer_DEFINED
 #define GrGpuCommandBuffer_DEFINED
 
 #include "GrColor.h"
 
+class GrGpu;
+class GrMesh;
+class GrPipeline;
+class GrPrimitiveProcessor;
 class GrRenderTarget;
+struct SkIRect;
 
+/**
+ * The GrGpuCommandBuffer is a series of commands (draws, clears, and discards), which all target
+ * the same render target. It is possible that these commands execute immediately (GL), or get
+ * buffered up for later execution (Vulkan). Currently GrBatches will execute their draw commands

[bsalomon, 2016/06/23 02:12:55]

Why "Currently"? Is this likely to change?

[egdaniel, 2016/06/23 13:57:08]

Removed. I put currently at first, cause technically this class doesn't rely on
anything specific from Batch. Thus it gives the idea that the upstack calles of
this are free to send in commands however they like.

+ * into a GrGpuCommandBuffer.
+ */
 class GrGpuCommandBuffer {
 public:
-    enum LoadAndStoreOp {
-        kLoadAndStore_LoadAndStoreOp,
-        kLoadAndDiscard_LoadAndStoreOp,
-        kClearAndStore_LoadAndStoreOp,
-        kClearAndDiscard_LoadAndStoreOp,
-        kDiscardAndStore_LoadAndStoreOp,
-        kDiscardAndDiscard_LoadAndStoreOp,
+    enum LoadOp {

[bsalomon, 2016/06/23 02:12:55]

enum classes? No strong preference but it is the future.

[egdaniel, 2016/06/23 13:57:08]

Done.

+        kLoad_LoadOp,
+        kClear_LoadOp,
+        kDiscard_LoadOp,
+    };
+
+    enum StoreOp {
+        kStore_StoreOp,
+        kDiscard_StoreOp,
+    };
+
+    struct LoadAndStoreInfo {
+        LoadOp  fLoadOp;
+        StoreOp fStoreOp;
+        GrColor fClearColor;
+
+        LoadAndStoreInfo(LoadOp loadOp, StoreOp storeOp, GrColor color = GrColor_ILLEGAL)

[bsalomon, 2016/06/23 02:12:55]

It seems like you have this constructor in order to check for consistency
between fLoadOp and fClearColor, but with public members it's a pretty weak
guard. I'd advocate for either going whole hog with setters and accessors or
just making it a struct with no methods (or maybe a default cons). Personally,
I'd go with the latter. It seems any bug where fLoadOp was set to kClear without
specifying the color would be caught by a memory checker or a test.

[egdaniel, 2016/06/23 13:57:08]

when with pure struct.

+            : fLoadOp(loadOp)
+            , fStoreOp(storeOp)
+            , fClearColor(color) {
+            SkASSERT(kClear_LoadOp != fLoadOp || GrColor_ILLEGAL != fClearColor);
+        }
     };
 
     GrGpuCommandBuffer() {}
     virtual ~GrGpuCommandBuffer() {}
 
     // Signals the end of recording to the command buffer and that it can now be submitted.
     virtual void end() = 0;
 
     // Sends the command buffer off to the GPU object to execute the commands built up in the
     // buffer. The gpu object is allowed to defer execution of the commands until it is flushed.
-    virtual void submit() = 0;
+    // The bounds should represent the bounds of all the draws put into the command buffer.
+    void submit(const SkIRect& bounds);
+    
+    // We pass in an array of meshCount GrMesh to the draw. The backend should loop over each
+    // GrMesh object and emit a draw for it. Each draw will use the same GrPipeline and
+    // GrPrimitiveProcessor. This may fail if the draw would exceed any resource limits (e.g.
+    // number of vertex attributes is too large).
+    bool draw(const GrPipeline&,
+              const GrPrimitiveProcessor&,
+              const GrMesh*,
+              int meshCount);
+
+    /**
+    * Clear the passed in render target. Ignores the draw state and clip.
+    */
+    void clear(const SkIRect& rect, GrColor color, GrRenderTarget* renderTarget);
+
+    void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget);
+    /**
+    * Discards the contents render target. nullptr indicates that the current render target should
+    * be discarded.
+    **/
+    // TODO: This should be removed in the future to favor using the load and store ops for discard
+    virtual void discard(GrRenderTarget* = nullptr) = 0;
+
+private:
+    virtual GrGpu* gpu() = 0;
+    virtual void onSubmit(const SkIRect& bounds) = 0;
+
+    // overridden by backend-specific derived class to perform the draw call.
+    virtual void onDraw(const GrPipeline&,
+                        const GrPrimitiveProcessor&,
+                        const GrMesh*,
+                        int meshCount) = 0;
+
+    // overridden by backend-specific derived class to perform the clear.
+    virtual void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) = 0;
+
+    virtual void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) = 0;
+
 };
 
 #endif