Decrease GrInOrderDrawBuffer::Cmd's reliance on GrInOrderDrawBuffer

src/gpu/GrInOrderDrawBuffer.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
 #include "GrFlushToGpuDrawTarget.h"
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
+#include "SkChunkAlloc.h"
 #include "GrPipeline.h"
 #include "GrPath.h"
 #include "GrTRecorder.h"
 
 /**
  * GrInOrderDrawBuffer is an implementation of GrDrawTarget that queues up draws for eventual
  * playback into a GrGpu. In theory one draw buffer could playback into another. When index or
  * vertex buffers are used as geometry sources it is the callers the draw buffer only holds
  * references to the buffers. It is the callers responsibility to ensure that the data is still
  * valid when the draw buffer is played back into a GrGpu. Similarly, it is the caller's
@@ skipping 46 matching lines @@
             kClear_Cmd             = 4,
             kCopySurface_Cmd       = 5,
             kDrawPath_Cmd          = 6,
             kDrawPaths_Cmd         = 7,
             kDrawBatch_Cmd         = 8,
         };
 
         Cmd(uint8_t type) : fType(type) {}
         virtual ~Cmd() {}
 
-        virtual void execute(GrInOrderDrawBuffer*, const SetState*) = 0;
+        virtual void execute(GrGpu*, const SetState*) = 0;
 
         uint8_t type() const { return fType & kCmdMask; }
 
         bool isTraced() const { return SkToBool(fType & kTraceCmdBit); }
         void makeTraced() { fType |= kTraceCmdBit; }
 
     private:
         static const int kCmdMask = 0x7F;
         static const int kTraceCmdBit = 0x80;
 
         uint8_t fType;
     };
 
     struct Draw : public Cmd {
         Draw(const DrawInfo& info) : Cmd(kDraw_Cmd), fInfo(info) {}
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         DrawInfo     fInfo;
     };
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path, GrRenderTarget* rt)
             : Cmd(kStencilPath_Cmd)
             , fRenderTarget(rt)
             , fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         SkMatrix                                                fViewMatrix;
         bool                                                    fUseHWAA;
         GrStencilSettings                                       fStencil;
         GrScissorState                                          fScissor;
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType>    fRenderTarget;
         GrPendingIOResource<const GrPath, kRead_GrIOType>       fPath;
     };
 
     struct DrawPath : public Cmd {
         DrawPath(const GrPath* path) : Cmd(kDrawPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType> fPath;
     };
 
     struct DrawPaths : public Cmd {
         DrawPaths(const GrPathRange* pathRange) : Cmd(kDrawPaths_Cmd), fPathRange(pathRange) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
-        int                     fIndicesLocation;
+        char*                   fIndices;
         PathIndexType           fIndexType;
-        int                     fTransformsLocation;
+        float*                  fTransforms;
         PathTransformType       fTransformType;
         int                     fCount;
         GrStencilSettings       fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     };
 
     // This is also used to record a discard by setting the color to GrColor_ILLEGAL
     struct Clear : public Cmd {
         Clear(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         SkIRect fRect;
         GrColor fColor;
         bool    fCanIgnoreRect;
 
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     // This command is ONLY used by the clip mask manager to clear the stencil clip bits
     struct ClearStencilClip : public Cmd {
         ClearStencilClip(GrRenderTarget* rt) : Cmd(kClear_Cmd), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         SkIRect fRect;
         bool    fInsideClip;
 
     private:
         GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
     };
 
     struct CopySurface : public Cmd {
         CopySurface(GrSurface* dst, GrSurface* src) : Cmd(kCopySurface_Cmd), fDst(dst), fSrc(src) {}
 
         GrSurface* dst() const { return fDst.get(); }
         GrSurface* src() const { return fSrc.get(); }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         SkIPoint    fDstPoint;
         SkIRect     fSrcRect;
 
     private:
         GrPendingIOResource<GrSurface, kWrite_GrIOType> fDst;
         GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc;
     };
 
     // TODO: rename to SetPipeline once pp, batch tracker, and desc are removed
     struct SetState : public Cmd {
         // TODO get rid of the prim proc parameter when we use batch everywhere
         SetState(const GrPrimitiveProcessor* primProc = NULL)
         : Cmd(kSetState_Cmd)
         , fPrimitiveProcessor(primProc) {}
 
         ~SetState() { reinterpret_cast<GrPipeline*>(fPipeline.get())->~GrPipeline(); }
 
         // This function is only for getting the location in memory where we will create our
         // pipeline object.
         GrPipeline* pipelineLocation() { return reinterpret_cast<GrPipeline*>(fPipeline.get()); }
 
         const GrPipeline* getPipeline() const {
             return reinterpret_cast<const GrPipeline*>(fPipeline.get());
         }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
         ProgramPrimitiveProcessor               fPrimitiveProcessor;
         SkAlignedSStorage<sizeof(GrPipeline)>   fPipeline;
         GrProgramDesc                           fDesc;
         GrBatchTracker                          fBatchTracker;
     };
 
     struct DrawBatch : public Cmd {
-        DrawBatch(GrBatch* batch) : Cmd(kDrawBatch_Cmd), fBatch(SkRef(batch)) {
+        DrawBatch(GrBatch* batch, GrBatchTarget* batchTarget) 
+            : Cmd(kDrawBatch_Cmd)
+            , fBatch(SkRef(batch))
+            , fBatchTarget(batchTarget) {
             SkASSERT(!batch->isUsed());
         }
 
-        void execute(GrInOrderDrawBuffer*, const SetState*) SK_OVERRIDE;
+        void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         // TODO it wouldn't be too hard to let batches allocate in the cmd buffer
         SkAutoTUnref<GrBatch>  fBatch;
+
+    private:
+        GrBatchTarget*         fBatchTarget;
     };
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
     void onReset() SK_OVERRIDE;
     void onFlush() SK_OVERRIDE;
 
     // overrides from GrDrawTarget
     void onDraw(const GrGeometryProcessor*, const DrawInfo&, const PipelineInfo&) SK_OVERRIDE;
@@ skipping 56 matching lines @@
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdBufferInitialSizeInBytes = 8 * 1024,
         kPathIdxBufferMinReserve     = 2 * 64,  // 64 uint16_t's
         kPathXformBufferMinReserve   = 2 * 64,  // 64 two-float transforms
     };
 
     CmdBuffer                           fCmdBuffer;
     SetState*                           fPrevState;
     SkTArray<GrTraceMarkerSet, false>   fGpuCmdMarkers;
-    SkTDArray<char>                     fPathIndexBuffer;
-    SkTDArray<float>                    fPathTransformBuffer;
+    SkChunkAlloc                        fPathIndexBuffer;
+    SkChunkAlloc                        fPathTransformBuffer;
     uint32_t                            fDrawID;
     GrBatchTarget                       fBatchTarget;
     // TODO hack until batch is everywhere
     DrawBatch*                          fDrawBatch;
 
     // This will go away when everything uses batch.  However, in the short term anything which
     // might be put into the GrInOrderDrawBuffer needs to make sure it closes the last batch
     void closeBatch() {
         if (fDrawBatch) {
             fBatchTarget.resetNumberOfDraws();
-            fDrawBatch->execute(this, fPrevState);
+            fDrawBatch->execute(this->getGpu(), fPrevState);
             fDrawBatch->fBatch->setNumberOfDraws(fBatchTarget.numberOfDraws());
             fDrawBatch = NULL;
         }
     }
 
     typedef GrFlushToGpuDrawTarget INHERITED;
 };
 
 #endif