Default geometry processor

src/gpu/gl/GrGLProgramDesc.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramDesc_DEFINED
 #define GrGLProgramDesc_DEFINED
 
@@ skipping 29 matching lines @@
      * the caps of the GrGpuGL are also inputs. It also outputs the color and coverage stages
      * referenced by the generated descriptor. Coverage stages from the drawState may be treated as
      * color stages in the output.
      */
     static bool Build(const GrOptDrawState&,
                       GrGpu::DrawType,
                       GrGpuGL*,
                       const GrDeviceCoordTexture*,
                       GrGLProgramDesc*);
 
-    bool hasGeometryProcessor() const {
-        return SkToBool(this->getHeader().fHasGeometryProcessor);
-    }
-
     int numColorEffects() const {
         return this->getHeader().fColorEffectCnt;
     }
 
     int numCoverageEffects() const {
         return this->getHeader().fCoverageEffectCnt;
     }
 
     int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); }
 
@@ skipping 37 matching lines @@
         ColorInput                       fCoverageInput : 8;
 
         GrOptDrawState::PrimaryOutputType    fPrimaryOutputType : 8;
         GrOptDrawState::SecondaryOutputType  fSecondaryOutputType : 8;
 
         int8_t                      fPositionAttributeIndex;
         int8_t                      fLocalCoordAttributeIndex;
         int8_t                      fColorAttributeIndex;
         int8_t                      fCoverageAttributeIndex;
 
-        SkBool8                     fHasGeometryProcessor;
         int8_t                      fColorEffectCnt;
         int8_t                      fCoverageEffectCnt;
     };
 
     // The key, stored in fKey, is composed of five parts:
     // 1. uint32_t for total key length.
     // 2. uint32_t for a checksum.
     // 3. Header struct defined above.
     // 4. An array of offsets to effect keys and their sizes (see 5). uint16_t for each
     //    offset and size.
@@ skipping 41 matching lines @@
         };
 
         ProcKeyProvider(const GrGLProgramDesc* desc, ProcessorType type)
             : fDesc(desc), fBaseIndex(0) {
             switch (type) {
                 case kGeometry_ProcessorType:
                     // there can be only one
                     fBaseIndex = 0;
                     break;
                 case kFragment_ProcessorType:
-                    fBaseIndex = desc->hasGeometryProcessor() ? 1 : 0;
+                    fBaseIndex = desc->getHeader().fUseFragShaderOnly ? 0 : 1;
                     break;
             }
         }
 
         GrProcessorKey get(int index) const {
             const uint16_t* offsetsAndLengths = reinterpret_cast<const uint16_t*>(
                 fDesc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset);
             // We store two uint16_ts per effect, one for the offset to the effect's key and one for
             // its length. Here we just need the offset.
             uint16_t offset = offsetsAndLengths[2 * (fBaseIndex + index) + 0];
@@ skipping 15 matching lines @@
                         kMaxPreallocEffects * sizeof(uint32_t) * kIntsPerEffect,
     };
 
     SkSTArray<kPreAllocSize, uint8_t, true> fKey;
 
     // GrGLProgram and GrGLShaderBuilder read the private fields to generate code. TODO: Split out
     // part of GrGLShaderBuilder that is used by effects so that this header doesn't need to be
     // visible to GrGLProcessors. Then make public accessors as necessary and remove friends.
     friend class GrGLProgram;
     friend class GrGLProgramBuilder;
+    friend class GrGLNvprProgramBuilderBase;
     friend class GrGLLegacyNvprProgramBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 
 #endif