Update how we send draws to gpu backend to reduce state setting.

src/gpu/gl/GrGLGpuProgramCache.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 "GrGLGpu.h"
 
 #include "builders/GrGLProgramBuilder.h"
@@ skipping 90 matching lines @@
 
 void GrGLGpu::ProgramCache::abandon() {
     this->reset();
 }
 
 int GrGLGpu::ProgramCache::search(const GrProgramDesc& desc) const {
     ProgDescLess less;
     return SkTSearch(fEntries, fCount, desc, sizeof(Entry*), less);
 }
 
-GrGLProgram* GrGLGpu::ProgramCache::refProgram(const DrawArgs& args) {
+GrGLProgram* GrGLGpu::ProgramCache::refProgram(const GrGLGpu* gpu,
+                                               const GrPipeline& pipeline,
+                                               const GrPrimitiveProcessor& primProc) {
 #ifdef PROGRAM_CACHE_STATS
     ++fTotalRequests;
 #endif
 
+    // Get GrGLProgramDesc
+    GrGLProgramDesc desc;
+    if (!GrGLProgramDescBuilder::Build(&desc, primProc, pipeline, *gpu->glCaps().glslCaps())) {
+        GrCapsDebugf(gpu->caps(), "Failed to gl program descriptor!\n");
+        return nullptr;
+    }
+
     Entry* entry = nullptr;
 
-    uint32_t hashIdx = args.fDesc->getChecksum();
+    uint32_t hashIdx = desc.getChecksum();
     hashIdx ^= hashIdx >> 16;
     if (kHashBits <= 8) {
         hashIdx ^= hashIdx >> 8;
     }
     hashIdx &=((1 << kHashBits) - 1);
     Entry* hashedEntry = fHashTable[hashIdx];
-    if (hashedEntry && hashedEntry->fProgram->getDesc() == *args.fDesc) {
+    if (hashedEntry && hashedEntry->fProgram->getDesc() == desc) {
         SkASSERT(hashedEntry->fProgram);
         entry = hashedEntry;
     }
 
     int entryIdx;
     if (nullptr == entry) {
-        entryIdx = this->search(*args.fDesc);
+        entryIdx = this->search(desc);
         if (entryIdx >= 0) {
             entry = fEntries[entryIdx];
 #ifdef PROGRAM_CACHE_STATS
             ++fHashMisses;
 #endif
         }
     }
 
     if (nullptr == entry) {
         // We have a cache miss
 #ifdef PROGRAM_CACHE_STATS
         ++fCacheMisses;
 #endif
-        GrGLProgram* program = GrGLProgramBuilder::CreateProgram(args, fGpu);
+        GrGLProgram* program = GrGLProgramBuilder::CreateProgram(pipeline, primProc, desc, fGpu);
         if (nullptr == program) {
             return nullptr;
         }
         int purgeIdx = 0;
         if (fCount < kMaxEntries) {
             entry = new Entry;
             purgeIdx = fCount++;
             fEntries[purgeIdx] = entry;
         } else {
             SkASSERT(fCount == kMaxEntries);
@@ skipping 49 matching lines @@
 
     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 SkRef(entry->fProgram.get());
 }