Create GrOptDrawState directly in the cmd buffer in GrIODB.

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 417 matching lines @@
         }
     }
 }
 
 void GrInOrderDrawBuffer::reset() {
     SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
 
     fCmdBuffer.reset();
-    fLastState.reset(NULL);
+    fLastState = NULL;
     fVertexPool.reset();
     fIndexPool.reset();
     reset_data_buffer(&fPathIndexBuffer, kPathIdxBufferMinReserve);
     reset_data_buffer(&fPathTransformBuffer, kPathXformBufferMinReserve);
     fGpuCmdMarkers.reset();
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
@@ skipping 14 matching lines @@
     fVertexPool.unmap();
     fIndexPool.unmap();
 
     CmdBuffer::Iter iter(fCmdBuffer);
 
     int currCmdMarker = 0;
     fDstGpu->saveActiveTraceMarkers();
 
     // Updated every time we find a set state cmd to reflect the current state in the playback
     // stream.
-    SkAutoTUnref<const GrOptDrawState> currentOptState;
+    const GrOptDrawState* currentOptState = NULL;
 
     while (iter.next()) {
         GrGpuTraceMarker newMarker("", -1);
         SkString traceString;
         if (cmd_has_trace_marker(iter->fType)) {
             traceString = fGpuCmdMarkers[currCmdMarker].toString();
             newMarker.fMarker = traceString.c_str();
             fDstGpu->addGpuTraceMarker(&newMarker);
             ++currCmdMarker;
         }
 
         if (kSetState_Cmd == strip_trace_bit(iter->fType)) {
             SetState* ss = reinterpret_cast<SetState*>(iter.get());
-            currentOptState.reset(SkRef(ss->fState.get()));
+            currentOptState = &ss->fState;
         } else {
-            iter->execute(this, currentOptState.get());
+            iter->execute(this, currentOptState);
         }
 
         if (cmd_has_trace_marker(iter->fType)) {
             fDstGpu->removeGpuTraceMarker(&newMarker);
         }
     }
 
     fDstGpu->restoreActiveTraceMarkers();
     SkASSERT(fGpuCmdMarkers.count() == currCmdMarker);
 
     this->reset();
     ++fDrawID;
 }
 
 void GrInOrderDrawBuffer::Draw::execute(GrInOrderDrawBuffer* buf, const GrOptDrawState* optState) {
+    SkASSERT(optState);
     buf->fDstGpu->draw(*optState, fInfo);
 }
 
 void GrInOrderDrawBuffer::StencilPath::execute(GrInOrderDrawBuffer* buf,
                                                const GrOptDrawState* optState) {
+    SkASSERT(optState);
     buf->fDstGpu->stencilPath(*optState, this->path(), fStencilSettings);
 }
 
 void GrInOrderDrawBuffer::DrawPath::execute(GrInOrderDrawBuffer* buf,
                                             const GrOptDrawState* optState) {
+    SkASSERT(optState);
     buf->fDstGpu->drawPath(*optState, this->path(), fStencilSettings);
 }
 
 void GrInOrderDrawBuffer::DrawPaths::execute(GrInOrderDrawBuffer* buf,
                                              const GrOptDrawState* optState) {
+    SkASSERT(optState);
     buf->fDstGpu->drawPaths(*optState, this->pathRange(),
                             &buf->fPathIndexBuffer[fIndicesLocation], fCount,
                             &buf->fPathTransformBuffer[fTransformsLocation], fTransformsType,
                             fStencilSettings);
 }
 
-void GrInOrderDrawBuffer::SetState::execute(GrInOrderDrawBuffer*, const GrOptDrawState*) {
-}
+void GrInOrderDrawBuffer::SetState::execute(GrInOrderDrawBuffer*, const GrOptDrawState*) { }

[egdaniel, 2014/11/21 22:26:24]

extra space in { }

[bsalomon, 2014/11/24 14:36:57]

Done.

 
 void GrInOrderDrawBuffer::Clear::execute(GrInOrderDrawBuffer* buf, const GrOptDrawState*) {
     if (GrColor_ILLEGAL == fColor) {
         buf->fDstGpu->discard(this->renderTarget());
     } else {
         buf->fDstGpu->clear(&fRect, fColor, fCanIgnoreRect, this->renderTarget());
     }
 }
 
 void GrInOrderDrawBuffer::ClearStencilClip::execute(GrInOrderDrawBuffer* buf,
@@ skipping 182 matching lines @@
     }
     if (kReserved_GeometrySrcType == restoredState.fIndexSrc) {
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) * restoredState.fIndexCount;
     }
 }
 
 bool GrInOrderDrawBuffer::recordStateAndShouldDraw(const GrDrawState& ds,
                                                    GrGpu::DrawType drawType,
                                                    const GrClipMaskManager::ScissorState& scissor,
                                                    const GrDeviceCoordTexture* dstCopy) {
-    SkAutoTUnref<GrOptDrawState> optState(
-        SkNEW_ARGS(GrOptDrawState, (ds, fDstGpu, scissor, dstCopy, drawType)));
-    if (optState->mustSkip()) {
+    SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState,
+                                            (ds, fDstGpu, scissor, dstCopy, drawType));
+    if (ss->fState.mustSkip()) {
+        fCmdBuffer.pop_back();
         return false;
     }
-    if (!fLastState || *optState != *fLastState) {
-        SetState* ss = GrNEW_APPEND_TO_RECORDER(fCmdBuffer, SetState, (optState));
-        fLastState.reset(SkRef(optState.get()));
-        ss->fDrawType = drawType;
+    if (fLastState && *fLastState == ss->fState) {
+        fCmdBuffer.pop_back();
+    } else {
+        fLastState = &ss->fState;
         this->recordTraceMarkersIfNecessary();
     }
     return true;
 }
 
 void GrInOrderDrawBuffer::recordTraceMarkersIfNecessary() {
     SkASSERT(!fCmdBuffer.empty());
     SkASSERT(!cmd_has_trace_marker(fCmdBuffer.back().fType));
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         fCmdBuffer.back().fType = add_trace_bit(fCmdBuffer.back().fType);
         fGpuCmdMarkers.push_back(activeTraceMarkers);
     }
 }