Make GrBatch carry its own GrPipeline

src/gpu/GrTargetCommands.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 GrTargetCommands_DEFINED
 #define GrTargetCommands_DEFINED
 
 #include "GrBatchTarget.h"
 #include "GrDrawTarget.h"
 #include "GrGpu.h"
 #include "GrPath.h"
 #include "GrPendingProgramElement.h"
 #include "GrRenderTarget.h"
 #include "GrTRecorder.h"
 #include "SkRect.h"
 #include "SkTypes.h"
 
 #include "batches/GrBatch.h"
 
 class GrBufferedDrawTarget;
 
+// TODO: Convert all commands into GrBatch and remove this class. Xferbarrier will just become a
+// batch blocker (when there is overlap) and the xp is responsible for issuing any barrier calls
+// on the backend.
 class GrTargetCommands : ::SkNoncopyable {
 public:
     GrTargetCommands(GrGpu* gpu)
         : fCmdBuffer(kCmdBufferInitialSizeInBytes)
         , fBatchTarget(gpu) {
     }
 
     class Cmd : ::SkNoncopyable {
     public:
         enum CmdType {
             kStencilPath_CmdType       = 1,
-            kSetState_CmdType          = 2,
-            kClear_CmdType             = 3,
-            kClearStencil_CmdType      = 4,
-            kCopySurface_CmdType       = 5,
-            kDrawPath_CmdType          = 6,
-            kDrawPaths_CmdType         = 7,
-            kDrawBatch_CmdType         = 8,
-            kXferBarrier_CmdType       = 9,
+            kClear_CmdType             = 2,
+            kClearStencil_CmdType      = 3,
+            kCopySurface_CmdType       = 4,
+            kDrawPath_CmdType          = 5,
+            kDrawPaths_CmdType         = 6,
+            kDrawBatch_CmdType         = 7,
+            kXferBarrier_CmdType       = 8,
         };
 
         Cmd(CmdType type)
             : fMarkerID(-1)
             , fType(type)
 #if GR_BATCH_SPEW
             , fUniqueID(GenID(&gUniqueID))
 #endif
 {}
         virtual ~Cmd() {}
@@ skipping 29 matching lines @@
 private:
     friend class GrCommandBuilder;
     friend class GrBufferedDrawTarget; // This goes away when State becomes just a pipeline
     friend class GrReorderCommandBuilder;
 
     typedef GrGpu::DrawArgs DrawArgs;
 
     void recordXferBarrierIfNecessary(const GrPipeline&, GrBufferedDrawTarget*);
 
     // TODO: This can be just a pipeline once paths are in batch, and it should live elsewhere
-    struct State : public SkNVRefCnt<State> {
+    struct StateForPathDraw : public SkNVRefCnt<StateForPathDraw> {
         // TODO get rid of the prim proc parameter when we use batch everywhere
-        State(const GrPrimitiveProcessor* primProc = NULL)
+        StateForPathDraw(const GrPrimitiveProcessor* primProc = NULL)
             : fPrimitiveProcessor(primProc)
             , fCompiled(false) {}
 
-        ~State() { reinterpret_cast<GrPipeline*>(fPipeline.get())->~GrPipeline(); }
+        ~StateForPathDraw() { reinterpret_cast<GrPipeline*>(fPipeline.get())->~GrPipeline(); }
 
         // This function is only for getting the location in memory where we will create our
         // pipeline object.
         void* pipelineLocation() { return fPipeline.get(); }
 
         const GrPipeline* getPipeline() const {
             return reinterpret_cast<const GrPipeline*>(fPipeline.get());
         }
         GrRenderTarget* getRenderTarget() const {
             return this->getPipeline()->getRenderTarget();
@@ skipping 14 matching lines @@
         }
 
         typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
         ProgramPrimitiveProcessor               fPrimitiveProcessor;
         SkAlignedSStorage<sizeof(GrPipeline)>   fPipeline;
         GrProgramDesc                           fDesc;
         GrBatchTracker                          fBatchTracker;
         bool                                    fCompiled;
     };
     // TODO remove this when State is just a pipeline
-    friend SkNVRefCnt<State>;
+    friend SkNVRefCnt<StateForPathDraw>;
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path, GrRenderTarget* rt)
             : Cmd(kStencilPath_CmdType)
             , fRenderTarget(rt)
             , fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         void execute(GrGpu*) 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(State* state, const GrPath* path)
+        DrawPath(StateForPathDraw* state, const GrPath* path)
             : Cmd(kDrawPath_CmdType)
             , fState(SkRef(state))
             , fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         void execute(GrGpu*) override;
 
-        SkAutoTUnref<State>     fState;
-        GrStencilSettings       fStencilSettings;
+        SkAutoTUnref<StateForPathDraw>  fState;
+        GrStencilSettings               fStencilSettings;
     private:
         GrPendingIOResource<const GrPath, kRead_GrIOType> fPath;
     };
 
     struct DrawPaths : public Cmd {
-        DrawPaths(State* state, const GrPathRange* pathRange)
+        DrawPaths(StateForPathDraw* state, const GrPathRange* pathRange)
             : Cmd(kDrawPaths_CmdType)
             , fState(SkRef(state))
             , fPathRange(pathRange) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
 
         void execute(GrGpu*) override;
 
-        SkAutoTUnref<State>             fState;
+        SkAutoTUnref<StateForPathDraw>  fState;
         char*                           fIndices;
         GrDrawTarget::PathIndexType     fIndexType;
         float*                          fTransforms;
         GrDrawTarget::PathTransformType fTransformType;
         int                             fCount;
         GrStencilSettings               fStencilSettings;
 
     private:
         GrPendingIOResource<const GrPathRange, kRead_GrIOType> fPathRange;
     };
@@ skipping 42 matching lines @@
 
         SkIPoint    fDstPoint;
         SkIRect     fSrcRect;
 
     private:
         GrPendingIOResource<GrSurface, kWrite_GrIOType> fDst;
         GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc;
     };
 
     struct DrawBatch : public Cmd {
-        DrawBatch(const State* state, GrBatch* batch, GrBatchTarget* batchTarget)
+        DrawBatch(GrBatch* batch, GrBatchTarget* batchTarget)
             : Cmd(kDrawBatch_CmdType)
-            , fState(SkRef(state))
             , fBatch(SkRef(batch))
             , fBatchTarget(batchTarget) {
             SkASSERT(!batch->isUsed());
         }
 
+        GrBatch* batch() { return fBatch; }
         void execute(GrGpu*) override;
-
-        SkAutoTUnref<const State>   fState;
-        SkAutoTUnref<GrBatch>       fBatch;
-
     private:
+        SkAutoTUnref<GrBatch>  fBatch;
         GrBatchTarget*         fBatchTarget;
     };
 
     struct XferBarrier : public Cmd {
         XferBarrier(GrRenderTarget* rt)
             : Cmd(kXferBarrier_CmdType)
             , fRenderTarget(rt) {
         }
 
         void execute(GrGpu*) override;
@@ skipping 11 matching lines @@
 
     CmdBuffer* cmdBuffer() { return &fCmdBuffer; }
     GrBatchTarget* batchTarget() { return &fBatchTarget; }
 
     CmdBuffer                           fCmdBuffer;
     GrBatchTarget                       fBatchTarget;
 };
 
 #endif