Some cleanup in processor header files.

src/gpu/effects/GrBezierEffect.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 GrBezierEffect_DEFINED
 #define GrBezierEffect_DEFINED
 
@@ skipping 41 matching lines @@
  * were "not too thin" curves and ellipses then 2nd order may have an advantage since
  * only one geometry would need to be rendered. However no benches were run comparing
  * chopped first order and non chopped 2nd order.
  */
 class GrGLConicEffect;
 
 class GrConicEffect : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(const GrPrimitiveEdgeType edgeType,
                                        const GrDrawTargetCaps& caps) {
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gConicFillAA, GrConicEffect,
-                                            (kFillAA_GrProcessorEdgeType));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gConicHairAA, GrConicEffect,
-                                            (kHairlineAA_GrProcessorEdgeType));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gConicFillBW, GrConicEffect,
-                                            (kFillBW_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gConicFillAA, GrConicEffect, (kFillAA_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gConicHairAA, GrConicEffect, (kHairlineAA_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gConicFillBW, GrConicEffect, (kFillBW_GrProcessorEdgeType));
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
                 gConicFillAA->ref();
                 return gConicFillAA;
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
@@ skipping 46 matching lines @@
  * the Quadratic, u, v have the values {0,0}, {1/2, 0}, and {1, 1} respectively.
  * Coverage for AA is min(0, 1-distance). 3rd & 4th cimponent unused.
  * Requires shader derivative instruction support.
  */
 class GrGLQuadEffect;
 
 class GrQuadEffect : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(const GrPrimitiveEdgeType edgeType,
                                        const GrDrawTargetCaps& caps) {
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gQuadFillAA, GrQuadEffect,
-                                            (kFillAA_GrProcessorEdgeType));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gQuadHairAA, GrQuadEffect,
-                                            (kHairlineAA_GrProcessorEdgeType));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gQuadFillBW, GrQuadEffect,
-                                            (kFillBW_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gQuadFillAA, GrQuadEffect, (kFillAA_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gQuadHairAA, GrQuadEffect, (kHairlineAA_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gQuadFillBW, GrQuadEffect, (kFillBW_GrProcessorEdgeType));
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
                 gQuadFillAA->ref();
                 return gQuadFillAA;
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
@@ skipping 48 matching lines @@
  * the fourth value is not used. Distance is calculated using a
  * first order approximation from the taylor series.
  * Coverage for AA is max(0, 1-distance).
  */
 class GrGLCubicEffect;
 
 class GrCubicEffect : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(const GrPrimitiveEdgeType edgeType,
                                        const GrDrawTargetCaps& caps) {
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gCubicFillAA, GrCubicEffect,
-                                            (kFillAA_GrProcessorEdgeType));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gCubicHairAA, GrCubicEffect,
-                                            (kHairlineAA_GrProcessorEdgeType));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gCubicFillBW, GrCubicEffect,
-                                            (kFillBW_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gCubicFillAA, GrCubicEffect, (kFillAA_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gCubicHairAA, GrCubicEffect, (kHairlineAA_GrProcessorEdgeType));
+        GR_CREATE_STATIC_PROCESSOR(gCubicFillBW, GrCubicEffect, (kFillBW_GrProcessorEdgeType));
         switch (edgeType) {
             case kFillAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
                 }
                 gCubicFillAA->ref();
                 return gCubicFillAA;
             case kHairlineAA_GrProcessorEdgeType:
                 if (!caps.shaderDerivativeSupport()) {
                     return NULL;
@@ skipping 32 matching lines @@
 
     GrPrimitiveEdgeType   fEdgeType;
     const GrShaderVar& fInCubicCoeffs;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 #endif