Move program descriptor and primitive processor off of optstate

src/gpu/GrGeometryProcessor.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGeometryProcessor.h"
 
 #include "GrCoordTransform.h"
@@ skipping 223 matching lines @@
                 } else {
                     vb->codeAppendf("%s = %s * vec3(%s, 1);", v.vsOut(), uniName, localCoords);
                 }
             }
         }
     }
 }
 
 
 void
-GrGLGeometryProcessor::setTransformData(const GrPrimitiveProcessor* primProc,
+GrGLGeometryProcessor::setTransformData(const GrPrimitiveProcessor& primProc,
                                         const GrGLProgramDataManager& pdman,
                                         int index,
                                         const SkTArray<const GrCoordTransform*, true>& transforms) {
     SkSTArray<2, Transform, true>& procTransforms = fInstalledTransforms[index];
     int numTransforms = transforms.count();
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(procTransforms[t].fHandle.isValid());
-        const SkMatrix& transform = GetTransformMatrix(primProc->localMatrix(), *transforms[t]);
+        const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), *transforms[t]);
         if (!procTransforms[t].fCurrentValue.cheapEqualTo(transform)) {
             pdman.setSkMatrix(procTransforms[t].fHandle.convertToUniformHandle(), transform);
             procTransforms[t].fCurrentValue = transform;
         }
     }
 }
 
 void GrGLGeometryProcessor::SetupPosition(GrGLVertexBuilder* vsBuilder,
                                           GrGPArgs* gpArgs,
                                           const char* posName,
@@ skipping 107 matching lines @@
             for (int t = 0; t < coordTransforms.count(); ++t) {
                 GrSLType type = coordTransforms[t]->getMatrix().hasPerspective() ? kVec3f_GrSLType :
                                                                                    kVec2f_GrSLType;
 
                 name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++);
                 SkNEW_APPEND_TO_TARRAY(&(*tout)[i], GrGLProcessor::TransformedCoords, (name, type));
             }
         }
     }
 
-    void setTransformData(const GrPrimitiveProcessor* primProc,
+    void setTransformData(const GrPrimitiveProcessor& primProc,
                           int index,
                           const SkTArray<const GrCoordTransform*, true>& transforms,
                           GrGLPathRendering* glpr,
                           GrGLuint) SK_OVERRIDE {
         // We've hidden the texcoord index in the first entry of the transforms array for each
         // effect
         int texCoordIndex = fInstalledTransforms[index][0].fHandle.handle();
         for (int t = 0; t < transforms.count(); ++t) {
-            const SkMatrix& transform = GetTransformMatrix(primProc->localMatrix(), *transforms[t]);
+            const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(), *transforms[t]);
             GrGLPathRendering::PathTexGenComponents components =
                     GrGLPathRendering::kST_PathTexGenComponents;
             if (transform.hasPerspective()) {
                 components = GrGLPathRendering::kSTR_PathTexGenComponents;
             }
             glpr->enablePathTexGen(texCoordIndex++, components, transform);
         }
     }
 
     void didSetData(GrGLPathRendering* glpr) SK_OVERRIDE {
@@ skipping 48 matching lines @@
             GrGLint location;
             GR_GL_CALL_RET(gpu->glInterface(),
                            location,
                            GetProgramResourceLocation(programId,
                                                       GR_GL_FRAGMENT_INPUT,
                                                       fSeparableVaryingInfos[i].fVariable.c_str()));
             fSeparableVaryingInfos[i].fLocation = location;
         }
     }
 
-    void setTransformData(const GrPrimitiveProcessor* primProc,
+    void setTransformData(const GrPrimitiveProcessor& primProc,
                           int index,
                           const SkTArray<const GrCoordTransform*, true>& coordTransforms,
                           GrGLPathRendering* glpr,
                           GrGLuint programID) SK_OVERRIDE {
         SkSTArray<2, Transform, true>& transforms = fInstalledTransforms[index];
         int numTransforms = transforms.count();
         for (int t = 0; t < numTransforms; ++t) {
             SkASSERT(transforms[t].fHandle.isValid());
-            const SkMatrix& transform = GetTransformMatrix(primProc->localMatrix(),
+            const SkMatrix& transform = GetTransformMatrix(primProc.localMatrix(),
                                                            *coordTransforms[t]);
             if (transforms[t].fCurrentValue.cheapEqualTo(transform)) {
                 continue;
             }
             transforms[t].fCurrentValue = transform;
             const SeparableVaryingInfo& fragmentInput =
                     fSeparableVaryingInfos[transforms[t].fHandle.handle()];
             SkASSERT(transforms[t].fType == kVec2f_GrSLType ||
                      transforms[t].fType == kVec3f_GrSLType);
             unsigned components = transforms[t].fType == kVec2f_GrSLType ? 2 : 3;
@@ skipping 82 matching lines @@
                                                           const GrGLCaps& caps) const {
     SkASSERT(caps.nvprSupport() != GrGLCaps::kNone_NvprSupport);
     if (caps.nvprSupport() == GrGLCaps::kLegacy_NvprSupport) {
         return SkNEW_ARGS(GrGLLegacyPathProcessor, (*this, bt,
                                                     caps.maxFixedFunctionTextureCoords()));
     } else {
         return SkNEW_ARGS(GrGLNormalPathProcessor, (*this, bt));
     }
 }