Plumb OptDrawState down to VertexShaderBuilder

src/gpu/gl/GrGpuGL_program.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 "GrGpuGL.h"
 
 #include "GrProcessor.h"
@@ skipping 72 matching lines @@
         SkDELETE(fEntries[i]);
     }
     fCount = 0;
 }
 
 int GrGpuGL::ProgramCache::search(const GrGLProgramDesc& desc) const {
     ProgDescLess less;
     return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
 }
 
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrGLProgramDesc& desc,
+GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState,
+                                               const GrGLProgramDesc& desc,
                                                const GrGeometryStage* geometryProcessor,
                                                const GrFragmentStage* colorStages[],
                                                const GrFragmentStage* coverageStages[]) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
     Entry* entry = NULL;
 
     uint32_t hashIdx = desc.getChecksum();
@@ skipping 17 matching lines @@
             ++fHashMisses;
 #endif
         }
     }
 
     if (NULL == entry) {
         // We have a cache miss
 #ifdef PROGRAM_CACHE_STATS
         ++fCacheMisses;
 #endif
-        GrGLProgram* program = GrGLProgram::Create(fGpu, desc, geometryProcessor,
-                colorStages, coverageStages);
+        GrGLProgram* program = GrGLProgram::Create(fGpu, optState, desc, geometryProcessor,
+                                                   colorStages, coverageStages);
         if (NULL == program) {
             return NULL;
         }
         int purgeIdx = 0;
         if (fCount < kMaxEntries) {
             entry = SkNEW(Entry);
             purgeIdx = fCount++;
             fEntries[purgeIdx] = entry;
         } else {
             SkASSERT(fCount == kMaxEntries);
@@ skipping 71 matching lines @@
         const GrRenderTarget* rt = optState->getRenderTarget();
         SkISize size;
         size.set(rt->width(), rt->height());
         this->glPathRendering()->setProjectionMatrix(optState->getViewMatrix(), size, rt->origin());
     } else {
         this->flushMiscFixedFunctionState(*optState.get());
 
         GrBlendCoeff srcCoeff = optState->getSrcBlendCoeff();
         GrBlendCoeff dstCoeff = optState->getDstBlendCoeff();
 
-        // In these blend coeff's we end up drawing nothing so we can skip draw all together
-        if (kZero_GrBlendCoeff == srcCoeff && kOne_GrBlendCoeff == dstCoeff &&
-            !optState->getStencil().doesWrite()) {
-            return false;
-        }
-
         const GrGeometryStage* geometryProcessor = NULL;
         SkSTArray<8, const GrFragmentStage*, true> colorStages;
         SkSTArray<8, const GrFragmentStage*, true> coverageStages;
         GrGLProgramDesc desc;
         if (!GrGLProgramDesc::Build(*optState.get(),
                                type,
                                srcCoeff,
                                dstCoeff,
                                this,
                                dstCopy,
                                &geometryProcessor,
                                &colorStages,
                                &coverageStages,
                                &desc)) {
             SkDEBUGFAIL("Failed to generate GL program descriptor");
             return false;
         }
 
-        fCurrentProgram.reset(fProgramCache->getProgram(desc,
+        fCurrentProgram.reset(fProgramCache->getProgram(*optState.get(),
+                                                        desc,
                                                         geometryProcessor,
                                                         colorStages.begin(),
                                                         coverageStages.begin()));
         if (NULL == fCurrentProgram.get()) {
             SkDEBUGFAIL("Failed to create program!");
             return false;
         }
 
         fCurrentProgram.get()->ref();
 
@@ skipping 103 matching lines @@
                              GrGLAttribTypeToLayout(attribType).fCount,
                              GrGLAttribTypeToLayout(attribType).fType,
                              GrGLAttribTypeToLayout(attribType).fNormalized,
                              stride,
                              reinterpret_cast<GrGLvoid*>(
                                  vertexOffsetInBytes + vertexAttrib->fOffset));
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }