Introduce GrBatch subclasses GrDrawBatch and GrVertexBatch to prepare for non-drawing batches

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 16 matching lines @@
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
 class GrClip;
 class GrCaps;
 class GrPath;
 class GrPathRange;
+class GrDrawBatch;
 
 class GrDrawTarget : public SkRefCnt {
 public:
     
 
     typedef GrPathRange::PathIndexType PathIndexType;
     typedef GrPathRendering::PathTransformType PathTransformType;
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ skipping 12 matching lines @@
      * This plays any queued up draws to its GrGpu target. It also resets this object (i.e. flushing
      * is destructive).
      */
     void flush();
 
     /**
      * Gets the capabilities of the draw target.
      */
     const GrCaps* caps() const { return fCaps; }
 
-    void drawBatch(const GrPipelineBuilder&, GrBatch*);
+    void drawBatch(const GrPipelineBuilder&, GrDrawBatch*);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * winding (not inverse or hairline). It will respect the HW antialias flag
      * on the GrPipelineBuilder (if possible in the 3D API).  Note, we will never have an inverse
      * fill with stencil path
      */
     void stencilPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*,
                      GrPathRendering::FillType);
 
@@ skipping 119 matching lines @@
     virtual void purgeResources() {};
 
     bool programUnitTest(GrContext* owner, int maxStages);
 
     struct PipelineInfo {
         PipelineInfo(const GrPipelineBuilder* pipelineBuilder, const GrScissorState* scissor,
                      const GrPrimitiveProcessor* primProc,
                      const SkRect* devBounds, GrDrawTarget* target);
 
         PipelineInfo(const GrPipelineBuilder* pipelineBuilder, const GrScissorState* scissor,
-                     const GrBatch* batch, const SkRect* devBounds,
+                     const GrDrawBatch* batch, const SkRect* devBounds,
                      GrDrawTarget* target);
 
         bool valid() const { return SkToBool(fArgs.fPipelineBuilder); }
 
         const GrPipeline::CreateArgs& pipelineCreateArgs() const {
             SkASSERT(this->valid());
             return fArgs;
         }
 
     private:
@@ skipping 14 matching lines @@
                                  const GrProcOptInfo& colorPOI,
                                  const GrProcOptInfo& coveragePOI,
                                  GrXferProcessor::DstTexture*,
                                  const SkRect* drawBounds);
 
 private:
     virtual void onReset() = 0;
 
     virtual void onFlush() = 0;
 
-    virtual void onDrawBatch(GrBatch*) = 0;
+    virtual void onDrawBatch(GrDrawBatch*) = 0;
     virtual void onStencilPath(const GrPipelineBuilder&,
                                const GrPathProcessor*,
                                const GrPath*,
                                const GrScissorState&,
                                const GrStencilSettings&) = 0;
     virtual void onDrawPath(const GrPathProcessor*,
                             const GrPath*,
                             const GrStencilSettings&,
                             const PipelineInfo&) = 0;
     virtual void onDrawPaths(const GrPathProcessor*,
@@ skipping 76 matching lines @@
     bool setupClip(const GrPipelineBuilder&,
                    GrPipelineBuilder::AutoRestoreFragmentProcessorState*,
                    GrPipelineBuilder::AutoRestoreStencil*,
                    GrScissorState* scissorState,
                    const SkRect* devBounds) override;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif