Split GrDrawBatch and GrVertexBatch into their own files

src/gpu/batches/GrBatch.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 GrBatch_DEFINED
 #define GrBatch_DEFINED
 
 #include <new>
-#include "GrBatchTarget.h"
-#include "GrGeometryProcessor.h"
 #include "GrNonAtomicRef.h"
-#include "GrVertices.h"
-#include "SkAtomics.h"
-#include "SkTypes.h"
 
-class GrGpu;
-class GrPipeline;
+#include "SkRect.h"
 
-struct GrInitInvariantOutput;
+class GrCaps;
 
 /**
  * GrBatch is the base class for all Ganesh deferred geometry generators.  To facilitate
  * reorderable batching, Ganesh does not generate geometry inline with draw calls.  Instead, it
  * captures the arguments to the draw and then generates the geometry on demand.  This gives GrBatch
  * subclasses complete freedom to decide how / what they can batch.
  *
  * Batches are created when GrContext processes a draw call. Batches of the same  subclass may be
  * merged using combineIfPossible. When two batches merge, one takes on the union of the data
  * and the other is left empty. The merged batch becomes responsible for drawing the data from both
@@ skipping 90 matching lines @@
     uint32_t                            fClassID;
     SkDEBUGCODE(bool                    fUsed;)
 #if GR_BATCH_SPEW
     uint32_t                            fUniqueID;
     static int32_t gCurrBatchUniqueID;
 #endif
     static int32_t gCurrBatchClassID;
     typedef GrNonAtomicRef INHERITED;
 };
 
-/**
- * Base class for GrBatches that draw. These batches have a GrPipeline installed by GrDrawTarget.
- */
-class GrDrawBatch : public GrBatch {
-public:
-    GrDrawBatch();
-    ~GrDrawBatch() override;
-
-    virtual void getInvariantOutputColor(GrInitInvariantOutput* out) const = 0;
-    virtual void getInvariantOutputCoverage(GrInitInvariantOutput* out) const = 0;
-
-    const GrPipeline* pipeline() const {
-        SkASSERT(fPipelineInstalled);
-        return reinterpret_cast<const GrPipeline*>(fPipelineStorage.get());
-    }
-
-    bool installPipeline(const GrPipeline::CreateArgs&);
-
-    // TODO no GrPrimitiveProcessors yet read fragment position
-    bool willReadFragmentPosition() const { return false; }
-
-private:
-    /**
-     * initBatchTracker is a hook for the some additional overrides / optimization possibilities
-     * from the GrXferProcessor.
-     */
-    virtual void initBatchTracker(const GrPipelineOptimizations&) = 0;
-
-    SkAlignedSTStorage<1, GrPipeline>   fPipelineStorage;
-    bool                                fPipelineInstalled;
-    typedef GrBatch INHERITED;
-};
-
-/**
- * Base class for vertex-based GrBatches.
- */
-class GrVertexBatch : public GrDrawBatch {
-public:
-    GrVertexBatch();
-
-    virtual void generateGeometry(GrBatchTarget*) = 0;
-
-    // TODO this goes away when batches are everywhere
-    void setNumberOfDraws(int numberOfDraws) { fNumberOfDraws = numberOfDraws; }
-    int numberOfDraws() const { return fNumberOfDraws; }
-
-protected:
-    /** Helper for rendering instances using an instanced index index buffer. This class creates the
-        space for the vertices and flushes the draws to the batch target. */
-   class InstancedHelper {
-   public:
-        InstancedHelper() {}
-        /** Returns the allocated storage for the vertices. The caller should populate the before
-            vertices before calling issueDraws(). */
-        void* init(GrBatchTarget* batchTarget, GrPrimitiveType, size_t vertexStride,
-                   const GrIndexBuffer*, int verticesPerInstance, int indicesPerInstance,
-                   int instancesToDraw);
-
-        /** Call after init() to issue draws to the batch target.*/
-        void issueDraw(GrBatchTarget* batchTarget) {
-            SkASSERT(fVertices.instanceCount());
-            batchTarget->draw(fVertices);
-        }
-    private:
-        GrVertices  fVertices;
-    };
-
-    static const int kVerticesPerQuad = 4;
-    static const int kIndicesPerQuad = 6;
-
-    /** A specialization of InstanceHelper for quad rendering. */
-    class QuadHelper : private InstancedHelper {
-    public:
-        QuadHelper() : INHERITED() {}
-        /** Finds the cached quad index buffer and reserves vertex space. Returns NULL on failure
-            and on sucess a pointer to the vertex data that the caller should populate before
-            calling issueDraws(). */
-        void* init(GrBatchTarget* batchTarget, size_t vertexStride, int quadsToDraw);
-
-        using InstancedHelper::issueDraw;
-
-    private:
-        typedef InstancedHelper INHERITED;
-    };
-
-private:
-    int                                 fNumberOfDraws;
-    typedef GrDrawBatch INHERITED;
-};
-
 #endif