Don't use NULL GrOptDrawState to indicate that draw should be skipped.

src/gpu/GrOptDrawState.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOptDrawState.h"
 
 #include "GrDefaultGeoProcFactory.h"
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
 #include "GrProcOptInfo.h"
 
 GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
-                               GrDrawState::BlendOpt blendOpt,
-                               GrBlendCoeff optSrcCoeff,
-                               GrBlendCoeff optDstCoeff,
                                GrGpu* gpu,
                                const ScissorState& scissorState,
                                const GrDeviceCoordTexture* dstCopy,
-                               GrGpu::DrawType drawType)
-: fRenderTarget(drawState.fRenderTarget.get()) {
+                               GrGpu::DrawType drawType) {
+
+    GrBlendCoeff optSrcCoeff;
+    GrBlendCoeff optDstCoeff;
+    GrDrawState::BlendOpt blendOpt = drawState.getBlendOpt(false, &optSrcCoeff, &optDstCoeff);
+
+    // When path rendering the stencil settings are not always set on the draw state
+    // so we must check the draw type. In cases where we will skip drawing we simply return a
+    // null GrOptDrawState.
+    if (GrDrawState::kSkipDraw_BlendOpt == blendOpt && GrGpu::kStencilPath_DrawType != drawType) {
+        // Set the fields that don't default init and return. The lack of a render target will
+        // indicate that this can be skipped.
+        fFlags = 0;
+        fVAPtr = NULL;
+        fVACount = 0;
+        fVAStride = 0;
+        fDrawFace = GrDrawState::kInvalid_DrawFace;
+        fSrcBlend = kZero_GrBlendCoeff;
+        fDstBlend = kZero_GrBlendCoeff;
+        fBlendConstant = 0x0;
+        fViewMatrix.reset();
+        return;
+    }
+
+    fRenderTarget.reset(drawState.fRenderTarget.get());

[egdaniel, 2014/11/19 21:07:11]

is worth having SkASSERT(ds.fRT.get())? Mostly thinking since we are using this
as a trigger for skipping.

[bsalomon, 2014/11/20 15:00:30]

Done.

     fScissorState = scissorState;
     fViewMatrix = drawState.getViewMatrix();
     fBlendConstant = drawState.getBlendConstant();
     fVAPtr = drawState.getVertexAttribs();
     fVACount = drawState.getVertexAttribCount();
     fVAStride = drawState.getVertexStride();
     fStencilSettings = drawState.getStencil();
     fDrawFace = drawState.getDrawFace();
     fSrcBlend = optSrcCoeff;
     fDstBlend = optDstCoeff;
@@ skipping 58 matching lines @@
                                GrPendingFragmentStage,
                                (drawState.fCoverageStages[i], explicitLocalCoords));
     }
 
     this->setOutputStateInfo(drawState, blendOpt, *gpu->caps(), &descInfo);
 
     // now create a key
     gpu->buildProgramDesc(*this, descInfo, drawType, dstCopy, &fDesc);
 };
 
-GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState,
-                                       GrGpu* gpu,
-                                       const ScissorState& scissorState,
-                                       const GrDeviceCoordTexture* dstCopy,
-                                       GrGpu::DrawType drawType) {
-    GrBlendCoeff srcCoeff;
-    GrBlendCoeff dstCoeff;
-    GrDrawState::BlendOpt blendOpt = drawState.getBlendOpt(false, &srcCoeff, &dstCoeff);
-
-    // If our blend coeffs are set to 0,1 we know we will not end up drawing unless we are
-    // stenciling. When path rendering the stencil settings are not always set on the draw state
-    // so we must check the draw type. In cases where we will skip drawing we simply return a
-    // null GrOptDrawState.
-    if (kZero_GrBlendCoeff == srcCoeff && kOne_GrBlendCoeff == dstCoeff &&
-        !drawState.getStencil().doesWrite() && GrGpu::kStencilPath_DrawType != drawType) {
-        return NULL;
-    }
-
-    return SkNEW_ARGS(GrOptDrawState, (drawState, blendOpt, srcCoeff,
-                                       dstCoeff, gpu, scissorState, dstCopy, drawType));
-}
-
 void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
                                         GrDrawState::BlendOpt blendOpt,
                                         const GrDrawTargetCaps& caps,
                                         GrProgramDesc::DescInfo* descInfo) {
     // Set this default and then possibly change our mind if there is coverage.
     descInfo->fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
     descInfo->fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
 
     // Determine whether we should use dual source blending or shader code to keep coverage
     // separate from color.
@@ skipping 166 matching lines @@
     SkASSERT(this->numFragmentStages() == that.numFragmentStages());
     for (int i = 0; i < this->numFragmentStages(); i++) {
 
         if (this->getFragmentStage(i) != that.getFragmentStage(i)) {
             return false;
         }
     }
     return true;
 }