Isolate GrBufferAllocPools inside GrBatchTarget

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 12 matching lines @@
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
 class GrClip;
 class GrDrawTargetCaps;
-class GrIndexBufferAllocPool;
 class GrPath;
 class GrPathRange;
 class GrPipeline;
-class GrVertexBufferAllocPool;
 
 class GrDrawTarget : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawTarget)
 
     typedef GrPathRange::PathIndexType PathIndexType;
     typedef GrPathRendering::PathTransformType PathTransformType;
 
     ///////////////////////////////////////////////////////////////////////////
 
     // The context may not be fully constructed and should not be used during GrDrawTarget
     // construction.
-    GrDrawTarget(GrContext* context, GrVertexBufferAllocPool*, GrIndexBufferAllocPool*);
+    GrDrawTarget(GrContext* context);
 
     virtual ~GrDrawTarget() {}
 
     /**
      * Empties the draw buffer of any queued up draws.
      */
-    void reset();
+    void reset() { this->onReset(); }
 
     /**
      * 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.
      */
@@ skipping 165 matching lines @@
 
     GrGpu* getGpu() {
         SkASSERT(fContext && fContext->getGpu());
         return fContext->getGpu();
     }
     const GrGpu* getGpu() const {
         SkASSERT(fContext && fContext->getGpu());
         return fContext->getGpu();
     }
 
-    GrVertexBufferAllocPool* getVertexAllocPool() { return fVertexPool; }
-    GrIndexBufferAllocPool* getIndexAllocPool() { return fIndexPool; }
-
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  const GrProcOptInfo& colorPOI,
                                  const GrProcOptInfo& coveragePOI,
                                  GrDeviceCoordTexture* dstCopy,
                                  const SkRect* drawBounds);
@@ skipping 71 matching lines @@
                            GrScissorState*,
                            const SkRect* devBounds) = 0;
 
     // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
     GrContext*                                                      fContext;
     SkAutoTUnref<const GrDrawTargetCaps>                            fCaps;
     // To keep track that we always have at least as many debug marker adds as removes
     int                                                             fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                fActiveTraceMarkers;
     GrTraceMarkerSet                                                fStoredTraceMarkers;
-    GrVertexBufferAllocPool*                                        fVertexPool;
-    GrIndexBufferAllocPool*                                         fIndexPool;
     bool                                                            fFlushing;
 
     typedef SkRefCnt INHERITED;
 };
 
 /*
  * This class is JUST for clip mask manager.  Everyone else should just use draw target above.
  */
 class GrClipTarget : public GrDrawTarget {
 public:
-    GrClipTarget(GrContext* context,
-                 GrVertexBufferAllocPool* vpool,
-                 GrIndexBufferAllocPool* ipool)
-        : INHERITED(context, vpool, ipool) {
+    GrClipTarget(GrContext* context)
+        : INHERITED(context) {
         fClipMaskManager.setClipTarget(this);
     }
 
     /* Clip mask manager needs access to the context.
      * TODO we only need a very small subset of context in the CMM.
      */
     GrContext* getContext() { return INHERITED::getContext(); }
     const GrContext* getContext() const { return INHERITED::getContext(); }
 
     /**
@@ skipping 23 matching lines @@
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreFragmentProcessors*,
                            GrPipelineBuilder::AutoRestoreStencil*,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) override;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif