Revert of Start on simplifying generateGeometry() overrides

src/gpu/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>
 // TODO remove this header when we move entirely to batch
 #include "GrDrawTarget.h"
-#include "GrBatchTarget.h"
 #include "GrGeometryProcessor.h"
 #include "SkRefCnt.h"
 #include "SkThread.h"
 #include "SkTypes.h"
 
+class GrBatchTarget;
 class GrGpu;
 class GrIndexBufferAllocPool;
 class GrPipeline;
 class GrVertexBufferAllocPool;
 
 struct GrInitInvariantOutput;
 
 /*
  * 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
@@ skipping 76 matching lines @@
     uint32_t fClassID;
 
     // NOTE, compute some bounds, even if extremely conservative.  Do *NOT* setLargest on the bounds
     // rect because we outset it for dst copy textures
     void setBounds(const SkRect& newBounds) { fBounds = newBounds; }
 
     void joinBounds(const SkRect& otherBounds) {
         return fBounds.joinPossiblyEmptyRect(otherBounds);
     }
 
-    /** 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() : fInstancesRemaining(0) {}
-        /** Returns the allocated storage for the vertices. The caller should populate the before
-            vertices before calling issueDraws(). */
-        void* init(GrBatchTarget* batchTarget, size_t vertexStride,
-                   const GrIndexBuffer* indexBuffer, int verticesPerInstance,
-                   int indicesPerInstance, int instancesToDraw);
-
-        /** Call after init() to issue draws to the batch target.*/
-        void issueDraws(GrBatchTarget* batchTarget) {
-            SkASSERT(fDrawInfo.instanceCount());
-            do {
-                batchTarget->draw(fDrawInfo);
-            } while (fDrawInfo.nextInstances(&fInstancesRemaining, fMaxInstancesPerDraw));
-        }
-    private:
-        int                     fInstancesRemaining;
-        int                     fMaxInstancesPerDraw;
-        GrDrawTarget::DrawInfo  fDrawInfo;
-    };
-
-    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::issueDraws;
-
-    private:
-        typedef InstancedHelper INHERITED;
-    };
-
     SkRect fBounds;
 
 private:
     static uint32_t GenClassID() {
         // fCurrProcessorClassID has been initialized to kIllegalProcessorClassID. The
         // atomic inc returns the old value not the incremented value. So we add
         // 1 to the returned value.
         uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrBatchClassID)) + 1;
         if (!id) {
             SkFAIL("This should never wrap as it should only be called once for each GrBatch "
                    "subclass.");
         }
         return id;
     }
 
     enum {
         kIllegalBatchClassID = 0,
     };
     static int32_t gCurrBatchClassID;
 
     SkDEBUGCODE(bool fUsed;)
 
     int fNumberOfDraws;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif