separate arrays for color and coverage effects.

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 "GrEffect.h"
@@ skipping 66 matching lines @@
     }
     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,
-                                               const GrEffectStage* stages[]) {
+                                               const GrEffectStage* colorStages[],
+                                               const GrEffectStage* coverageStages[]) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
     Entry* entry = NULL;
 
     uint32_t hashIdx = desc.getChecksum();
     hashIdx ^= hashIdx >> 16;
     if (kHashBits <= 8) {
         hashIdx ^= hashIdx >> 8;
@@ skipping 14 matching lines @@
             ++fHashMisses;
 #endif
         }
     }
 
     if (NULL == entry) {
         // We have a cache miss
 #ifdef PROGRAM_CACHE_STATS
         ++fCacheMisses;
 #endif
-        GrGLProgram* program = GrGLProgram::Create(fGL, desc, stages);
+        GrGLProgram* program = GrGLProgram::Create(fGL, desc, colorStages, coverageStages);
         if (NULL == program) {
             return NULL;
         }
         int purgeIdx = 0;
         if (fCount < kMaxEntries) {
             entry = SkNEW(Entry);
             purgeIdx = fCount++;
             fEntries[purgeIdx] = entry;
         } else {
             GrAssert(fCount == kMaxEntries);
@@ skipping 133 matching lines @@
     } else {
         this->flushMiscFixedFunctionState();
 
         GrBlendCoeff srcCoeff;
         GrBlendCoeff dstCoeff;
         GrDrawState::BlendOptFlags blendOpts = drawState.getBlendOpts(false, &srcCoeff, &dstCoeff);
         if (GrDrawState::kSkipDraw_BlendOptFlag & blendOpts) {
             return false;
         }
 
-        const GrEffectStage* stages[GrDrawState::kNumStages];
+        SkSTArray<8, const GrEffectStage*, true> colorStages;
+        SkSTArray<8, const GrEffectStage*, true> coverageStages;
         GrGLProgramDesc desc;
         GrGLProgramDesc::Build(this->getDrawState(),
                                kDrawPoints_DrawType == type,
                                blendOpts,
                                srcCoeff,
                                dstCoeff,
                                this,
                                dstCopy,
-                               stages,
+                               &colorStages,
+                               &coverageStages,
                                &desc);
 
-        fCurrentProgram.reset(fProgramCache->getProgram(desc, stages));
+        fCurrentProgram.reset(fProgramCache->getProgram(desc,
+                                                        colorStages.begin(),
+                                                        coverageStages.begin()));
         if (NULL == fCurrentProgram.get()) {
             GrAssert(!"Failed to create program!");
             return false;
         }
         fCurrentProgram.get()->ref();
 
         GrGLuint programID = fCurrentProgram->programID();
         if (fHWProgramID != programID) {
             GL_CALL(UseProgram(programID));
             fHWProgramID = programID;
         }
 
         fCurrentProgram->overrideBlend(&srcCoeff, &dstCoeff);
         this->flushBlend(kDrawLines_DrawType == type, srcCoeff, dstCoeff);
 
-        fCurrentProgram->setData(this, blendOpts, stages, dstCopy, &fSharedGLProgramState);
+        fCurrentProgram->setData(this,
+                                 blendOpts,
+                                 colorStages.begin(),
+                                 coverageStages.begin(),
+                                 dstCopy,
+                                 &fSharedGLProgramState);
     }
     this->flushStencil(type);
     this->flushScissor();
     this->flushAAState(type);
 
     GrIRect* devRect = NULL;
     GrIRect devClipBounds;
     if (drawState.isClipState()) {
         this->getClip()->getConservativeBounds(drawState.getRenderTarget(), &devClipBounds);
         devRect = &devClipBounds;
@@ skipping 74 matching lines @@
                          GrGLAttribTypeToLayout(attribType).fCount,
                          GrGLAttribTypeToLayout(attribType).fType,
                          GrGLAttribTypeToLayout(attribType).fNormalized,
                          stride,
                          reinterpret_cast<GrGLvoid*>(
                          vertexOffsetInBytes + vertexAttrib->fOffset));
     }
 
     attribState->disableUnusedAttribArrays(this, usedAttribArraysMask);
 }