move program descriptor generation to flush

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 "builders/GrGLProgramBuilder.h"
@@ skipping 73 matching lines @@
         SkDELETE(fEntries[i]);
     }
     fCount = 0;
 }
 
 int GrGpuGL::ProgramCache::search(const GrProgramDesc& desc) const {
     ProgDescLess less;
     return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
 }
 
-GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState, DrawType type) {
+GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
     Entry* entry = NULL;
 
     uint32_t hashIdx = optState.programDesc().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 = GrGLProgramBuilder::CreateProgram(optState, type, fGpu);
+        GrGLProgram* program = GrGLProgramBuilder::CreateProgram(optState, fGpu);
         if (NULL == program) {
             return NULL;
         }
         int purgeIdx = 0;
         if (fCount < kMaxEntries) {
             entry = SkNEW(Entry);
             purgeIdx = fCount++;
             fEntries[purgeIdx] = entry;
         } else {
             SkASSERT(fCount == kMaxEntries);
@@ skipping 54 matching lines @@
         }
     }
     ++fCurrLRUStamp;
     return entry->fProgram;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
 
-bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState, DrawType type) {
+bool GrGpuGL::flushGraphicsState(const GrOptDrawState& optState) {
     // GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
     SkASSERT(optState.getRenderTarget());
 
-    if (kStencilPath_DrawType == type) {
+    if (kStencilPath_DrawType == optState.drawType()) {
         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);
 
         GrBlendCoeff srcCoeff = optState.getSrcBlendCoeff();
         GrBlendCoeff dstCoeff = optState.getDstBlendCoeff();
 
-        fCurrentProgram.reset(fProgramCache->getProgram(optState, type));
+        fCurrentProgram.reset(fProgramCache->getProgram(optState));
         if (NULL == fCurrentProgram.get()) {
             SkDEBUGFAIL("Failed to create program!");
             return false;
         }
 
         fCurrentProgram.get()->ref();
 
         GrGLuint programID = fCurrentProgram->programID();
         if (fHWProgramID != programID) {
             GL_CALL(UseProgram(programID));
             fHWProgramID = programID;
         }
 
-        this->flushBlend(optState, kDrawLines_DrawType == type, srcCoeff, dstCoeff);
+        this->flushBlend(optState, kDrawLines_DrawType == optState.drawType(), srcCoeff, dstCoeff);
 
-        fCurrentProgram->setData(optState, type);
+        fCurrentProgram->setData(optState);
     }
 
     GrGLRenderTarget* glRT = static_cast<GrGLRenderTarget*>(optState.getRenderTarget());
-    this->flushStencil(optState.getStencil(), type);
+    this->flushStencil(optState.getStencil(), optState.drawType());
     this->flushScissor(optState.getScissorState(), glRT->getViewport(), glRT->origin());
-    this->flushAAState(optState, type);
+    this->flushAAState(optState);
 
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
     this->flushRenderTarget(glRT, NULL);
 
     return true;
 }
 
 void GrGpuGL::setupGeometry(const GrOptDrawState& optState,
                             const GrDrawTarget::DrawInfo& info,
@@ skipping 50 matching lines @@
 }
 
 void GrGpuGL::buildProgramDesc(const GrOptDrawState& optState,
                                const GrProgramDesc::DescInfo& descInfo,
                                GrGpu::DrawType drawType,
                                GrProgramDesc* desc) {
     if (!GrGLProgramDescBuilder::Build(optState, descInfo, drawType, this, desc)) {
         SkDEBUGFAIL("Failed to generate GL program descriptor");
     }
 }