Rename GrOptDrawState to GrPipeline and GrDrawState to GrPipelineBuilder

src/gpu/GrBitmapTextContext.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 "GrBitmapTextContext.h"
 #include "GrAtlas.h"
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 511 matching lines @@
     }
     fCurrVertex += 4;
 }
 
 void GrBitmapTextContext::flush() {
     if (NULL == fDrawTarget) {
         return;
     }
 
     if (fCurrVertex > 0) {
-        GrDrawState drawState;
-        drawState.setFromPaint(fPaint, fContext->getRenderTarget());
+        GrPipelineBuilder pipelineBuilder;
+        pipelineBuilder.setFromPaint(fPaint, fContext->getRenderTarget());
 
         // setup our sampler state for our text texture/atlas
         SkASSERT(SkIsAlign4(fCurrVertex));
         SkASSERT(fCurrTexture);
 
         SkASSERT(fStrike);
         GrColor color = fPaint.getColor();
         switch (fCurrMaskFormat) {
                 // Color bitmap text
             case kARGB_GrMaskFormat: {
                 int a = fSkPaint.getAlpha();
                 color = SkColorSetARGB(a, a, a, a);
                 break;
             }
                 // LCD text
             case kA565_GrMaskFormat: {
                 // TODO: move supportsRGBCoverage check to setupCoverageEffect and only add LCD
                 // processor if the xp can support it. For now we will simply assume that if
                 // fUseLCDText is true, then we have a known color output.
-                if (!drawState.getXPFactory()->supportsRGBCoverage(0, kRGBA_GrColorComponentFlags)) {
+                const GrXPFactory* xpFactory = pipelineBuilder.getXPFactory();
+                if (!xpFactory->supportsRGBCoverage(0, kRGBA_GrColorComponentFlags)) {
                     SkDebugf("LCD Text will not draw correctly.\n");
                 }
                 break;
             }
                 // Grayscale/BW text
             case kA8_GrMaskFormat:
                 break;
             default:
                 SkFAIL("Unexpected mask format.");
         }
 
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kNone_FilterMode);
         if (kARGB_GrMaskFormat == fCurrMaskFormat) {
             uint32_t textureUniqueID = fCurrTexture->getUniqueID();
             if (textureUniqueID != fEffectTextureUniqueID ||
                 fCachedGeometryProcessor->color() != color) {
                 uint32_t flags = GrDefaultGeoProcFactory::kLocalCoord_GPType;
                 fCachedGeometryProcessor.reset(GrDefaultGeoProcFactory::Create(flags, color));
                 fCachedTextureProcessor.reset(GrSimpleTextureEffect::Create(fCurrTexture,
                                                                             SkMatrix::I(),
                                                                             params));
                 fEffectTextureUniqueID = textureUniqueID;
             }
-            drawState.addColorProcessor(fCachedTextureProcessor.get());
+            pipelineBuilder.addColorProcessor(fCachedTextureProcessor.get());
         } else {
             uint32_t textureUniqueID = fCurrTexture->getUniqueID();
             if (textureUniqueID != fEffectTextureUniqueID ||
                 fCachedGeometryProcessor->color() != color ||
                 !fCachedGeometryProcessor->localMatrix().cheapEqualTo(fLocalMatrix)) {
                 bool hasColor = kA8_GrMaskFormat == fCurrMaskFormat;
                 bool opaqueVertexColors = GrColorIsOpaque(fPaint.getColor());
                 fCachedGeometryProcessor.reset(GrBitmapTextGeoProc::Create(color,
                                                                            fCurrTexture,
                                                                            params,
                                                                            hasColor,
                                                                            opaqueVertexColors,
                                                                            fLocalMatrix));
                 fEffectTextureUniqueID = textureUniqueID;
             }
         }
 
         int nGlyphs = fCurrVertex / kVerticesPerGlyph;
         fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
-        fDrawTarget->drawIndexedInstances(&drawState,
+        fDrawTarget->drawIndexedInstances(&pipelineBuilder,
                                           fCachedGeometryProcessor.get(),
                                           kTriangles_GrPrimitiveType,
                                           nGlyphs,
                                           kVerticesPerGlyph,
                                           kIndicesPerGlyph,
                                           &fVertexBounds);
 
         fDrawTarget->resetVertexSource();
         fVertices = NULL;
         fAllocVertexCount = 0;
         // reset to be those that are left
         fTotalVertexCount -= fCurrVertex;
         fCurrVertex = 0;
         fVertexBounds.setLargestInverted();
         SkSafeSetNull(fCurrTexture);
     }
 }
 
 inline void GrBitmapTextContext::finish() {
     this->flush();
     fTotalVertexCount = 0;
 
     GrTextContext::finish();
 }