OptState owns program descriptor

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 13 matching lines @@
 
 struct GrGpuGL::ProgramCache::Entry {
     SK_DECLARE_INST_COUNT_ROOT(Entry);
     Entry() : fProgram(NULL), fLRUStamp(0) {}
 
     SkAutoTUnref<GrGLProgram>   fProgram;
     unsigned int                fLRUStamp;
 };
 
 struct GrGpuGL::ProgramCache::ProgDescLess {
-    bool operator() (const GrGLProgramDesc& desc, const Entry* entry) {
+    bool operator() (const GrProgramDesc& desc, const Entry* entry) {
         SkASSERT(entry->fProgram.get());
-        return GrGLProgramDesc::Less(desc, entry->fProgram->getDesc());
+        return GrProgramDesc::Less(desc, entry->fProgram->getDesc());
     }
 
-    bool operator() (const Entry* entry, const GrGLProgramDesc& desc) {
+    bool operator() (const Entry* entry, const GrProgramDesc& desc) {
         SkASSERT(entry->fProgram.get());
-        return GrGLProgramDesc::Less(entry->fProgram->getDesc(), desc);
+        return GrProgramDesc::Less(entry->fProgram->getDesc(), desc);
     }
 };
 
 GrGpuGL::ProgramCache::ProgramCache(GrGpuGL* gpu)
     : fCount(0)
     , fCurrLRUStamp(0)
     , fGpu(gpu)
 #ifdef PROGRAM_CACHE_STATS
     , fTotalRequests(0)
     , fCacheMisses(0)
@@ skipping 27 matching lines @@
 
 void GrGpuGL::ProgramCache::abandon() {
     for (int i = 0; i < fCount; ++i) {
         SkASSERT(fEntries[i]->fProgram.get());
         fEntries[i]->fProgram->abandon();
         SkDELETE(fEntries[i]);
     }
     fCount = 0;
 }
 
-int GrGpuGL::ProgramCache::search(const GrGLProgramDesc& desc) const {
+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,
-                                               const GrGLProgramDesc& desc,
-                                               DrawType type) {
+GrGLProgram* GrGpuGL::ProgramCache::getProgram(const GrOptDrawState& optState, DrawType type) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
     Entry* entry = NULL;
 
-    uint32_t hashIdx = desc.getChecksum();
+    uint32_t hashIdx = optState.desc().getChecksum();
     hashIdx ^= hashIdx >> 16;
     if (kHashBits <= 8) {
         hashIdx ^= hashIdx >> 8;
     }
     hashIdx &=((1 << kHashBits) - 1);
     Entry* hashedEntry = fHashTable[hashIdx];
-    if (hashedEntry && hashedEntry->fProgram->getDesc() == desc) {
+    if (hashedEntry && hashedEntry->fProgram->getDesc() == optState.desc()) {
         SkASSERT(hashedEntry->fProgram);
         entry = hashedEntry;
     }
 
     int entryIdx;
     if (NULL == entry) {
-        entryIdx = this->search(desc);
+        entryIdx = this->search(optState.desc());
         if (entryIdx >= 0) {
             entry = fEntries[entryIdx];
 #ifdef PROGRAM_CACHE_STATS
             ++fHashMisses;
 #endif
         }
     }
 
     if (NULL == entry) {
         // We have a cache miss
 #ifdef PROGRAM_CACHE_STATS
         ++fCacheMisses;
 #endif
-        GrGLProgram* program = GrGLProgramBuilder::CreateProgram(optState, desc, type, fGpu);
+        GrGLProgram* program = GrGLProgramBuilder::CreateProgram(optState, type, 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 29 matching lines @@
             //  we rearrange it to look like this:
             //       aaaabbbbbPEccccc
             size_t copySize = (entryIdx - purgeIdx - 1) * sizeof(Entry*);
             memmove(fEntries + purgeIdx, fEntries + purgeIdx + 1, copySize);
             fEntries[entryIdx - 1] = entry;
         }
 #ifdef SK_DEBUG
         SkASSERT(fEntries[0]->fProgram.get());
         for (int i = 0; i < fCount - 1; ++i) {
             SkASSERT(fEntries[i + 1]->fProgram.get());
-            const GrGLProgramDesc& a = fEntries[i]->fProgram->getDesc();
-            const GrGLProgramDesc& b = fEntries[i + 1]->fProgram->getDesc();
-            SkASSERT(GrGLProgramDesc::Less(a, b));
-            SkASSERT(!GrGLProgramDesc::Less(b, a));
+            const GrProgramDesc& a = fEntries[i]->fProgram->getDesc();
+            const GrProgramDesc& b = fEntries[i + 1]->fProgram->getDesc();
+            SkASSERT(GrProgramDesc::Less(a, b));
+            SkASSERT(!GrProgramDesc::Less(b, a));
         }
 #endif
     }
 
     fHashTable[hashIdx] = entry;
     entry->fLRUStamp = fCurrLRUStamp;
 
     if (SK_MaxU32 == fCurrLRUStamp) {
         // wrap around! just trash our LRU, one time hit.
         for (int i = 0; i < fCount; ++i) {
             fEntries[i]->fLRUStamp = 0;
         }
     }
     ++fCurrLRUStamp;
     return entry->fProgram;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define GL_CALL(X) GR_GL_CALL(this->glInterface(), X)
 
 bool GrGpuGL::flushGraphicsState(DrawType type, const GrDeviceCoordTexture* dstCopy) {
     SkAutoTUnref<GrOptDrawState> optState(GrOptDrawState::Create(this->getDrawState(),
-                                                                 *this->caps(),
+                                                                 this,
+                                                                 dstCopy,
                                                                  type));
 
     if (!optState) {
         return false;
     }
 
     // GrGpu::setupClipAndFlushState should have already checked this and bailed if not true.
     SkASSERT(optState->getRenderTarget());
 
     if (kStencilPath_DrawType == type) {
         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;
         }
 
-        GrGLProgramDesc desc;
-        if (!GrGLProgramDesc::Build(*optState.get(), type, this, dstCopy, &desc)) {
-            SkDEBUGFAIL("Failed to generate GL program descriptor");
-            return false;
-        }
-
-        fCurrentProgram.reset(fProgramCache->getProgram(*optState.get(), desc, type));
+        fCurrentProgram.reset(fProgramCache->getProgram(*optState.get(), type));
         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));
@@ skipping 18 matching lines @@
     }
     // 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, devRect);
 
     return true;
 }
 
 void GrGpuGL::setupGeometry(const DrawInfo& info, size_t* indexOffsetInBytes) {
     SkAutoTUnref<GrOptDrawState> optState(
-        GrOptDrawState::Create(this->getDrawState(), *this->caps(),
+        GrOptDrawState::Create(this->getDrawState(), this, info.getDstCopy(),
                                PrimTypeToDrawType(info.primitiveType())));
 
     // If the optState would is NULL it should have been caught in flushGraphicsState before getting
     // here.
     SkASSERT(optState);
 
     GrGLsizei stride = static_cast<GrGLsizei>(optState->getVertexStride());
 
     size_t vertexOffsetInBytes = stride * info.startVertex();
 
@@ skipping 61 matching lines @@
                              GrGLAttribTypeToLayout(attribType).fCount,
                              GrGLAttribTypeToLayout(attribType).fType,
                              GrGLAttribTypeToLayout(attribType).fNormalized,
                              stride,
                              reinterpret_cast<GrGLvoid*>(
                                  vertexOffsetInBytes + vertexAttrib->fOffset));
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }
+
+void GrGpuGL::buildKey(const GrOptDrawState* optState,
+                       GrGpu::DrawType drawType,
+                       const GrDeviceCoordTexture* dstCopy,
+                       GrProgramDesc* desc) {
+    SkASSERT(optState);
+    if (!GrGLProgramDesc::Build(*optState, drawType, this, dstCopy, desc)) {
+        SkDEBUGFAIL("Failed to generate GL program descriptor");
+    }
+}