Remove GrStagedProcessor, remove the word Stage as it applies to FPs

src/gpu/GrClipMaskManager.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrAAConvexPathRenderer.h"
 #include "GrAAHairLinePathRenderer.h"
@@ skipping 28 matching lines @@
 
     SkMatrix mat;
     // We use device coords to compute the texture coordinates. We set our matrix to be a
     // translation to the devBound, and then a scaling matrix to normalized coords.
     mat.setIDiv(result->width(), result->height());
     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
                      SkIntToScalar(-devBound.fTop));
 
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     // This could be a long-lived effect that is cached with the alpha-mask.
-    arfps->addCoverageProcessor(
+    arfps->addCoverageFragmentProcessor(
         GrTextureDomainEffect::Create(arfps->getProcessorDataManager(),
                                       result,
                                       mat,
                                       GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode,
                                       kDevice_GrCoordSet))->unref();
 }
 
 bool path_needs_SW_renderer(GrContext* context,
@@ skipping 133 matching lines @@
                 case SkClipStack::Element::kRect_Type: {
                     SkRect rect = iter.get()->getRect();
                     rect.offset(clipToRTOffset.fX, clipToRTOffset.fY);
                     fp.reset(GrConvexPolyEffect::Create(edgeType, rect));
                     break;
                 }
                 default:
                     break;
             }
             if (fp) {
-                arfps->addCoverageProcessor(fp);
+                arfps->addCoverageFragmentProcessor(fp);
             } else {
                 failed = true;
                 break;
             }
         }
         iter.next();
     }
 
     if (failed) {
         arfps->set(NULL);
@@ skipping 267 matching lines @@
                                   const SkIRect& dstBound,
                                   const SkIRect& srcBound) {
     pipelineBuilder->setRenderTarget(dstMask->asRenderTarget());
 
     // We want to invert the coverage here
     set_coverage_drawing_xpf(op, false, pipelineBuilder);
 
     SkMatrix sampleM;
     sampleM.setIDiv(srcMask->width(), srcMask->height());
 
-    pipelineBuilder->addCoverageProcessor(
+    pipelineBuilder->addCoverageFragmentProcessor(
         GrTextureDomainEffect::Create(pipelineBuilder->getProcessorDataManager(),
                                       srcMask,
                                       sampleM,
                                       GrTextureDomain::MakeTexelDomain(srcMask, srcBound),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode))->unref();
 
     // The color passed in here does not matter since the coverageSetOpXP won't read it.
     fClipTarget->drawNonAARect(*pipelineBuilder,
                                GrColor_WHITE,
@@ skipping 648 matching lines @@
     fAACache.purgeResources();
 }
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }