Update gpu trace marker system for MultiDrawBuffer world

src/gpu/GrTargetCommands.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTargetCommands.h"
 
 #include "GrColor.h"
@@ skipping 29 matching lines @@
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(info.isInstanced());
 
     const GrIndexBuffer* ib;
     if (!iodb->canConcatToIndexBuffer(&ib)) {
         return 0;
     }
 
     // Check if there is a draw info that is compatible that uses the same VB from the pool and
     // the same IB
-    if (Cmd::kDraw_Cmd != fCmdBuffer.back().type()) {
+    if (Cmd::kDraw_CmdType != fCmdBuffer.back().type()) {
         return 0;
     }
 
     Draw* draw = static_cast<Draw*>(&fCmdBuffer.back());
 
     if (!draw->fInfo.isInstanced() ||
         draw->fInfo.primitiveType() != info.primitiveType() ||
         draw->fInfo.verticesPerInstance() != info.verticesPerInstance() ||
         draw->fInfo.indicesPerInstance() != info.indicesPerInstance() ||
         draw->fInfo.vertexBuffer() != info.vertexBuffer() ||
@@ skipping 46 matching lines @@
 
 GrTargetCommands::Cmd* GrTargetCommands::recordDrawBatch(
                                                   GrInOrderDrawBuffer* iodb,
                                                   GrBatch* batch,
                                                   const GrDrawTarget::PipelineInfo& pipelineInfo) {
     if (!this->setupPipelineAndShouldDraw(iodb, batch, pipelineInfo)) {
         return NULL;
     }
 
     // Check if there is a Batch Draw we can batch with
-    if (Cmd::kDrawBatch_Cmd != fCmdBuffer.back().type() || !fDrawBatch) {
+    if (Cmd::kDrawBatch_CmdType != fCmdBuffer.back().type() || !fDrawBatch) {
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
         return fDrawBatch;
     }
 
     SkASSERT(&fCmdBuffer.back() == fDrawBatch);
     if (!fDrawBatch->fBatch->combineIfPossible(batch)) {
         this->closeBatch();
         fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
     }
 
@@ skipping 56 matching lines @@
         return NULL;
     }
 
     char* savedIndices;
     float* savedTransforms;
     
     iodb->appendIndicesAndTransforms(indexValues, indexType,
                                      transformValues, transformType,
                                      count, &savedIndices, &savedTransforms);
 
-    if (Cmd::kDrawPaths_Cmd == fCmdBuffer.back().type()) {
+    if (Cmd::kDrawPaths_CmdType == fCmdBuffer.back().type()) {
         // The previous command was also DrawPaths. Try to collapse this call into the one
         // before. Note that stenciling all the paths at once, then covering, may not be
         // equivalent to two separate draw calls if there is overlap. Blending won't work,
         // and the combined calls may also cancel each other's winding numbers in some
         // places. For now the winding numbers are only an issue if the fill is even/odd,
         // because DrawPaths is currently only used for glyphs, and glyphs in the same
         // font tend to all wind in the same direction.
         DrawPaths* previous = static_cast<DrawPaths*>(&fCmdBuffer.back());
         if (pathRange == previous->pathRange() &&
             indexType == previous->fIndexType &&
@@ skipping 74 matching lines @@
     fCmdBuffer.reset();
     fPrevState = NULL;
     fDrawBatch = NULL;
 }
 
 void GrTargetCommands::flush(GrInOrderDrawBuffer* iodb) {
     if (fCmdBuffer.empty()) {
         return;
     }
 
-    // Updated every time we find a set state cmd to reflect the current state in the playback
-    // stream.
-    SetState* currentState = NULL;
-
     // TODO this is temporary while batch is being rolled out
     this->closeBatch();
     iodb->getVertexAllocPool()->unmap();
     iodb->getIndexAllocPool()->unmap();
     fBatchTarget.preFlush();
 
-    currentState = NULL;
+    // Updated every time we find a set state cmd to reflect the current state in the playback
+    // stream.
+    SetState* currentState = NULL;
+
     CmdBuffer::Iter iter(fCmdBuffer);
 
-    int currCmdMarker = 0;
-
     GrGpu* gpu = iodb->getGpu();
 
-    int i = 0;
     while (iter.next()) {
-        i++;
         GrGpuTraceMarker newMarker("", -1);
         SkString traceString;
         if (iter->isTraced()) {
-            traceString = iodb->getCmdString(currCmdMarker);
+            traceString = iodb->getCmdString(iter->markerID());
             newMarker.fMarker = traceString.c_str();
             gpu->addGpuTraceMarker(&newMarker);
-            ++currCmdMarker;
         }
 
         // TODO temporary hack
-        if (Cmd::kDrawBatch_Cmd == iter->type()) {
+        if (Cmd::kDrawBatch_CmdType == iter->type()) {
             DrawBatch* db = reinterpret_cast<DrawBatch*>(iter.get());
             fBatchTarget.flushNext(db->fBatch->numberOfDraws());
 
             if (iter->isTraced()) {
                 gpu->removeGpuTraceMarker(&newMarker);
             }
             continue;
         }
 
-        if (Cmd::kSetState_Cmd == iter->type()) {
+        if (Cmd::kSetState_CmdType == iter->type()) {
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
 
-            // TODO sometimes we have a prim proc, othertimes we have a GrBatch.  Eventually we
-            // will only have GrBatch and we can delete this
-            if (ss->fPrimitiveProcessor) {
-                gpu->buildProgramDesc(&ss->fDesc, *ss->fPrimitiveProcessor,
-                                      *ss->getPipeline(),
-                                      ss->fBatchTracker);
-            }
+            ss->execute(gpu, currentState);
             currentState = ss;
         } else {
             iter->execute(gpu, currentState);
         }
 
         if (iter->isTraced()) {
             gpu->removeGpuTraceMarker(&newMarker);
         }
     }
 
@@ skipping 34 matching lines @@
                    fIndices, fIndexType,
                    fTransforms, fTransformType,
                    fCount, fStencilSettings);
 }
 
 void GrTargetCommands::DrawBatch::execute(GrGpu*, const SetState* state) {
     SkASSERT(state);
     fBatch->generateGeometry(fBatchTarget, state->getPipeline());
 }
 
-void GrTargetCommands::SetState::execute(GrGpu*, const SetState*) {}
+void GrTargetCommands::SetState::execute(GrGpu* gpu, const SetState*) {
+    // TODO sometimes we have a prim proc, othertimes we have a GrBatch.  Eventually we
+    // will only have GrBatch and we can delete this
+    if (fPrimitiveProcessor) {
+        gpu->buildProgramDesc(&fDesc, *fPrimitiveProcessor, *getPipeline(), fBatchTracker);
+    }
+}
 
 void GrTargetCommands::Clear::execute(GrGpu* gpu, const SetState*) {
     if (GrColor_ILLEGAL == fColor) {
         gpu->discard(this->renderTarget());
     } else {
         gpu->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
 }
 
 void GrTargetCommands::ClearStencilClip::execute(GrGpu* gpu, const SetState*) {
@@ skipping 63 matching lines @@
         fPrevState->getPipeline()->isEqual(*ss->getPipeline())) {
         fCmdBuffer.pop_back();
     } else {
         this->closeBatch();
         fPrevState = ss;
         iodb->recordTraceMarkersIfNecessary(ss);
     }
     return true;
 }