Some cleanup in processor header files.

src/gpu/GrOvalRenderer.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOvalRenderer.h"
 
 #include "gl/builders/GrGLProgramBuilder.h"
@@ skipping 45 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * The output of this effect is a modulation of the input color and coverage for a circle,
  * specified as offset_x, offset_y (both from center point), outer radius and inner radius.
  */
 
 class CircleEdgeEffect : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(bool stroke) {
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gCircleStrokeEdge, CircleEdgeEffect, (true));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gCircleFillEdge, CircleEdgeEffect, (false));
+        GR_CREATE_STATIC_PROCESSOR(gCircleStrokeEdge, CircleEdgeEffect, (true));
+        GR_CREATE_STATIC_PROCESSOR(gCircleFillEdge, CircleEdgeEffect, (false));
 
         if (stroke) {
             gCircleStrokeEdge->ref();
             return gCircleStrokeEdge;
         } else {
             gCircleFillEdge->ref();
             return gCircleFillEdge;
         }
     }
 
@@ skipping 94 matching lines @@
  * The output of this effect is a modulation of the input color and coverage for an axis-aligned
  * ellipse, specified as a 2D offset from center, and the reciprocals of the outer and inner radii,
  * in both x and y directions.
  *
  * We are using an implicit function of x^2/a^2 + y^2/b^2 - 1 = 0.
  */
 
 class EllipseEdgeEffect : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(bool stroke) {
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gEllipseStrokeEdge, EllipseEdgeEffect, (true));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gEllipseFillEdge, EllipseEdgeEffect, (false));
+        GR_CREATE_STATIC_PROCESSOR(gEllipseStrokeEdge, EllipseEdgeEffect, (true));
+        GR_CREATE_STATIC_PROCESSOR(gEllipseFillEdge, EllipseEdgeEffect, (false));
 
         if (stroke) {
             gEllipseStrokeEdge->ref();
             return gEllipseStrokeEdge;
         } else {
             gEllipseFillEdge->ref();
             return gEllipseFillEdge;
         }
     }
 
@@ skipping 122 matching lines @@
  * using differentials.
  *
  * The result is device-independent and can be used with any affine matrix.
  */
 
 class DIEllipseEdgeEffect : public GrGeometryProcessor {
 public:
     enum Mode { kStroke = 0, kHairline, kFill };
 
     static GrGeometryProcessor* Create(Mode mode) {
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gEllipseStrokeEdge, DIEllipseEdgeEffect, (kStroke));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gEllipseHairlineEdge, DIEllipseEdgeEffect, (kHairline));
-        GR_CREATE_STATIC_GEOMETRY_PROCESSOR(gEllipseFillEdge, DIEllipseEdgeEffect, (kFill));
+        GR_CREATE_STATIC_PROCESSOR(gEllipseStrokeEdge, DIEllipseEdgeEffect, (kStroke));
+        GR_CREATE_STATIC_PROCESSOR(gEllipseHairlineEdge, DIEllipseEdgeEffect, (kHairline));
+        GR_CREATE_STATIC_PROCESSOR(gEllipseFillEdge, DIEllipseEdgeEffect, (kFill));
 
         if (kStroke == mode) {
             gEllipseStrokeEdge->ref();
             return gEllipseStrokeEdge;
         } else if (kHairline == mode) {
             gEllipseHairlineEdge->ref();
             return gEllipseHairlineEdge;
         } else {
             gEllipseFillEdge->ref();
             return gEllipseFillEdge;
@@ skipping 895 matching lines @@
 
         // drop out the middle quad if we're stroked
         int indexCnt = isStrokeOnly ? SK_ARRAY_COUNT(gRRectIndices) - 6 :
                                       SK_ARRAY_COUNT(gRRectIndices);
         target->setIndexSourceToBuffer(indexBuffer);
         target->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 16, indexCnt, &bounds);
     }
 
     return true;
 }