simple cleanup in GrTargetCommands

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 16 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

[robertphillips, 2015/04/30 15:51:08]

Why don't we need a "fCmdBuffer.count() && ..." in this if-test?

-    if (Cmd::kDrawBatch_CmdType != fCmdBuffer.back().type() || !fDrawBatch) {
-        fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
-        return fDrawBatch;
+    if (Cmd::kDrawBatch_CmdType == fCmdBuffer.back().type()) {
+        DrawBatch* previous = static_cast<DrawBatch*>(&fCmdBuffer.back());
+        if (!previous->fBatch->combineIfPossible(batch)) {

[robertphillips, 2015/04/30 15:51:08]

Why not return NULL here and just fall through otherwise?

+            return GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
+        }
+        // We batched
+        return NULL;
     }
 
-    SkASSERT(&fCmdBuffer.back() == fDrawBatch);
-    if (!fDrawBatch->fBatch->combineIfPossible(batch)) {
-        fDrawBatch = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
-    }
-
-    return fDrawBatch;
+    DrawBatch* current = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, DrawBatch, (batch, &fBatchTarget));
+    return current;
 }
 
 GrTargetCommands::Cmd* GrTargetCommands::recordStencilPath(
                                                         GrInOrderDrawBuffer* iodb,
                                                         const GrPipelineBuilder& pipelineBuilder,
                                                         const GrPathProcessor* pathProc,
                                                         const GrPath* path,
                                                         const GrScissorState& scissorState,
                                                         const GrStencilSettings& stencilSettings) {
     StencilPath* sp = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, StencilPath,
@@ skipping 124 matching lines @@
     SkASSERT(renderTarget);
 
     Clear* clr = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, Clear, (renderTarget));
     clr->fColor = GrColor_ILLEGAL;
     return clr;
 }
 
 void GrTargetCommands::reset() {
     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;
 
     GrGpu* gpu = iodb->getGpu();
 
-#ifdef USE_BITMAP_TEXTBLOBS
     // Loop over all batches and generate geometry
     CmdBuffer::Iter genIter(fCmdBuffer);
     while (genIter.next()) {
         if (Cmd::kDrawBatch_CmdType == genIter->type()) {
             DrawBatch* db = reinterpret_cast<DrawBatch*>(genIter.get());
             fBatchTarget.resetNumberOfDraws();
             db->execute(NULL, currentState);
             db->fBatch->setNumberOfDraws(fBatchTarget.numberOfDraws());
         } else if (Cmd::kSetState_CmdType == genIter->type()) {
             SetState* ss = reinterpret_cast<SetState*>(genIter.get());
 
             ss->execute(gpu, currentState);
             currentState = ss;
         }
     }
-#endif
 
     iodb->getVertexAllocPool()->unmap();
     iodb->getIndexAllocPool()->unmap();
     fBatchTarget.preFlush();
 
     CmdBuffer::Iter iter(fCmdBuffer);
 
     while (iter.next()) {
         GrGpuTraceMarker newMarker("", -1);
         SkString traceString;
         if (iter->isTraced()) {
             traceString = iodb->getCmdString(iter->markerID());
             newMarker.fMarker = traceString.c_str();
             gpu->addGpuTraceMarker(&newMarker);
         }
 
-        // TODO temporary hack
         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_CmdType == iter->type()) {
-#ifndef USE_BITMAP_TEXTBLOBS
-            SetState* ss = reinterpret_cast<SetState*>(iter.get());
-
-            ss->execute(gpu, currentState);
-            currentState = ss;
-#else
             // TODO this is just until NVPR is in batch
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
 
             if (ss->fPrimitiveProcessor) {
                 ss->execute(gpu, currentState);
             }
             currentState = ss;
-#endif
 
         } else {
             iter->execute(gpu, currentState);
         }
 
         if (iter->isTraced()) {
             gpu->removeGpuTraceMarker(&newMarker);
         }
     }
 
-    // TODO see copious notes about hack
     fBatchTarget.postFlush();
 }
 
-void GrTargetCommands::Draw::execute(GrGpu* gpu, const SetState* state) {
-    SkASSERT(state);
-    DrawArgs args(state->fPrimitiveProcessor.get(), state->getPipeline(), &state->fDesc,
-                  &state->fBatchTracker);
-    gpu->draw(args, fInfo);
-}
-
 void GrTargetCommands::StencilPath::execute(GrGpu* gpu, const SetState*) {
     GrGpu::StencilPathState state;
     state.fRenderTarget = fRenderTarget.get();
     state.fScissor = &fScissor;
     state.fStencil = &fStencil;
     state.fUseHWAA = fUseHWAA;
     state.fViewMatrix = &fViewMatrix;
 
     gpu->stencilPath(this->path(), state);
 }
@@ skipping 122 matching lines @@
     if (!xp.willNeedXferBarrier(rt, *iodb->caps(), &barrierType)) {
         return;
     }
 
     XferBarrier* xb = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, XferBarrier, ());
     xb->fBarrierType = barrierType;
 
     iodb->recordTraceMarkersIfNecessary(xb);
 }