Update gpu trace marker system for MultiDrawBuffer world

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
 
@@ skipping 17 matching lines @@
 public:
     GrTargetCommands(GrGpu* gpu,
                      GrVertexBufferAllocPool* vertexPool,
                      GrIndexBufferAllocPool* indexPool)
         : fCmdBuffer(kCmdBufferInitialSizeInBytes)
         , fPrevState(NULL)
         , fBatchTarget(gpu, vertexPool, indexPool)
         , fDrawBatch(NULL) {
     }
 
-    struct Cmd : ::SkNoncopyable {
-        enum {
-            kDraw_Cmd              = 1,
-            kStencilPath_Cmd       = 2,
-            kSetState_Cmd          = 3,
-            kClear_Cmd             = 4,
-            kCopySurface_Cmd       = 5,
-            kDrawPath_Cmd          = 6,
-            kDrawPaths_Cmd         = 7,
-            kDrawBatch_Cmd         = 8,
+    class Cmd : ::SkNoncopyable {
+    public:
+        enum CmdType {
+            kDraw_CmdType              = 1,
+            kStencilPath_CmdType       = 2,
+            kSetState_CmdType          = 3,
+            kClear_CmdType             = 4,
+            kCopySurface_CmdType       = 5,
+            kDrawPath_CmdType          = 6,
+            kDrawPaths_CmdType         = 7,
+            kDrawBatch_CmdType         = 8,
         };
 
-        Cmd(uint8_t type) : fType(type) {}
+        Cmd(CmdType type) : fMarkerID(-1), fType(type) {}
         virtual ~Cmd() {}
 
         virtual void execute(GrGpu*, const SetState*) = 0;
 
-        uint8_t type() const { return fType & kCmdMask; }
+        CmdType type() const { return fType; }
 
-        bool isTraced() const { return SkToBool(fType & kTraceCmdBit); }
-        void makeTraced() { fType |= kTraceCmdBit; }
+        // trace markers
+        bool isTraced() const { return -1 != fMarkerID; }
+        void setMarkerID(int markerID) { SkASSERT(-1 == fMarkerID); fMarkerID = markerID; }
+        int markerID() const { return fMarkerID; }
 
     private:
-        static const int kCmdMask = 0x7F;
-        static const int kTraceCmdBit = 0x80;
-
-        uint8_t fType;
+        int              fMarkerID;
+        CmdType          fType;
     };
 
     void reset();
     void flush(GrInOrderDrawBuffer*);
 
     Cmd* recordClearStencilClip(GrInOrderDrawBuffer*,
                                 const SkIRect& rect,
                                 bool insideClip,
                                 GrRenderTarget* renderTarget);
 
@@ skipping 60 matching lines @@
     int concatInstancedDraw(GrInOrderDrawBuffer*, const GrDrawTarget::DrawInfo&);
 
     bool SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(GrInOrderDrawBuffer*,
                                                           const GrPrimitiveProcessor*,
                                                           const GrDrawTarget::PipelineInfo&);
     bool SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(GrInOrderDrawBuffer*,
                                                           GrBatch*,
                                                           const GrDrawTarget::PipelineInfo&);
 
     struct Draw : public Cmd {
-        Draw(const GrDrawTarget::DrawInfo& info) : Cmd(kDraw_Cmd), fInfo(info) {}
+        Draw(const GrDrawTarget::DrawInfo& info) : Cmd(kDraw_CmdType), fInfo(info) {}
 
         void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         GrDrawTarget::DrawInfo     fInfo;
     };
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path, GrRenderTarget* rt)
-            : Cmd(kStencilPath_Cmd)
+            : Cmd(kStencilPath_CmdType)
             , fRenderTarget(rt)
             , fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         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) {}
+        DrawPath(const GrPath* path) : Cmd(kDrawPath_CmdType), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         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) {}
+        DrawPaths(const GrPathRange* pathRange) : Cmd(kDrawPaths_CmdType), fPathRange(pathRange) {}
 
         const GrPathRange* pathRange() const { return fPathRange.get();  }
 
         void execute(GrGpu*, const SetState*) SK_OVERRIDE;
 
         char*                           fIndices;
         GrDrawTarget::PathIndexType     fIndexType;
         float*                          fTransforms;
         GrDrawTarget::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) {}
+        Clear(GrRenderTarget* rt) : Cmd(kClear_CmdType), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
         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) {}
+        ClearStencilClip(GrRenderTarget* rt) : Cmd(kClear_CmdType), fRenderTarget(rt) {}
 
         GrRenderTarget* renderTarget() const { return fRenderTarget.get(); }
 
         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) {}
+        CopySurface(GrSurface* dst, GrSurface* src)
+            : Cmd(kCopySurface_CmdType)
+            , fDst(dst)
+            , fSrc(src) {
+        }
 
         GrSurface* dst() const { return fDst.get(); }
         GrSurface* src() const { return fSrc.get(); }
 
         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)
+        : Cmd(kSetState_CmdType)
         , 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(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, GrBatchTarget* batchTarget) 
-            : Cmd(kDrawBatch_Cmd)
+            : Cmd(kDrawBatch_CmdType)
             , fBatch(SkRef(batch))
             , fBatchTarget(batchTarget) {
             SkASSERT(!batch->isUsed());
         }
 
         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;
 
@@ skipping 12 matching lines @@
      // TODO hack until batch is everywhere
      GrTargetCommands::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();
 };
 
 #endif