Rename GrOptDrawState to GrPipeline and GrDrawState to GrPipelineBuilder

src/gpu/GrAARectRenderer.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 "GrAARectRenderer.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpu.h"
 #include "GrInvariantOutput.h"
 #include "SkColorPriv.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
 // Should the coverage be multiplied into the color attrib or use a separate attrib.
 enum CoverageAttribType {
     kUseColor_CoverageAttribType,
     kUseCoverage_CoverageAttribType,
 };
 }
 
-static const GrGeometryProcessor* create_rect_gp(const GrDrawState& drawState,
+static const GrGeometryProcessor* create_rect_gp(const GrPipelineBuilder& pipelineBuilder,
                                                  GrColor color,
                                                  CoverageAttribType* type,
                                                  const SkMatrix& localMatrix) {
     uint32_t flags = GrDefaultGeoProcFactory::kColor_GPType;
     const GrGeometryProcessor* gp;
-    if (drawState.canTweakAlphaForCoverage()) {
+    if (pipelineBuilder.canTweakAlphaForCoverage()) {
         gp = GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), localMatrix);
         SkASSERT(gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
         *type = kUseColor_CoverageAttribType;
     } else {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
         gp = GrDefaultGeoProcFactory::Create(flags, color, SkMatrix::I(), localMatrix,
                                              GrColorIsOpaque(color));
         SkASSERT(gp->getVertexStride()==sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
         *type = kUseCoverage_CoverageAttribType;
     }
@@ skipping 127 matching lines @@
                     fGpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
                                                      kIndicesPerBevelStrokeRect,
                                                      kNumBevelStrokeRectsInIndexBuffer,
                                                      kVertsPerBevelStrokeRect);
         }
         return fAABevelStrokeRectIndexBuffer;
     }
 }
 
 void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
-                                          GrDrawState* drawState,
+                                          GrPipelineBuilder* pipelineBuilder,
                                           GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkRect& rect,
                                           const SkRect& devRect) {
-    GrDrawState::AutoRestoreEffects are(drawState);
+    GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder);
 
     SkMatrix localMatrix;
     if (!viewMatrix.invert(&localMatrix)) {
         SkDebugf("Cannot invert\n");
         return;
     }
 
     CoverageAttribType type;
-    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type,
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*pipelineBuilder, color, &type,
                                                               localMatrix));
 
     size_t vertexStride = gp->getVertexStride();
     GrDrawTarget::AutoReleaseGeometry geo(target, 8, vertexStride, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return;
     }
 
     if (NULL == fAAFillRectIndexBuffer) {
@@ skipping 92 matching lines @@
     for (int i = 0; i < 4; ++i) {
         if (kUseCoverage_CoverageAttribType == type) {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
             *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) = innerCoverage;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
         }
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
-    target->drawIndexedInstances(drawState,
+    target->drawIndexedInstances(pipelineBuilder,
                                  gp,
                                  kTriangles_GrPrimitiveType,
                                  1,
                                  kVertsPerAAFillRect,
                                  kIndicesPerAAFillRect);
     target->resetIndexSource();
 }
 
 void GrAARectRenderer::strokeAARect(GrDrawTarget* target,
-                                    GrDrawState* drawState,
+                                    GrPipelineBuilder* pipelineBuilder,
                                     GrColor color,
                                     const SkMatrix& viewMatrix,
                                     const SkRect& rect,
                                     const SkRect& devRect,
                                     const SkStrokeRec& stroke) {
     SkVector devStrokeSize;
     SkScalar width = stroke.getWidth();
     if (width > 0) {
         devStrokeSize.set(width, width);
         viewMatrix.mapVectors(&devStrokeSize, 1);
@@ skipping 27 matching lines @@
 
     bool miterStroke = true;
     // For hairlines, make bevel and round joins appear the same as mitered ones.
     // small miter limit means right angles show bevel...
     if ((width > 0) && (stroke.getJoin() != SkPaint::kMiter_Join ||
                         stroke.getMiter() < SK_ScalarSqrt2)) {
         miterStroke = false;
     }
 
     if (spare <= 0 && miterStroke) {
-        this->fillAARect(target, drawState, color, viewMatrix, devOutside,
+        this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
                          devOutside);
         return;
     }
 
     SkRect devInside(devRect);
     devInside.inset(rx, ry);
 
     SkRect devOutsideAssist(devRect);
 
     // For bevel-stroke, use 2 SkRect instances(devOutside and devOutsideAssist)
     // to draw the outer of the rect. Because there are 8 vertices on the outer
     // edge, while vertex number of inner edge is 4, the same as miter-stroke.
     if (!miterStroke) {
         devOutside.inset(0, ry);
         devOutsideAssist.outset(0, ry);
     }
 
-    this->geometryStrokeAARect(target, drawState, color, viewMatrix, devOutside, devOutsideAssist,
+    this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutsideAssist,
                                devInside, miterStroke);
 }
 
 void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
-                                            GrDrawState* drawState,
+                                            GrPipelineBuilder* pipelineBuilder,
                                             GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
                                             bool miterStroke) {
-    GrDrawState::AutoRestoreEffects are(drawState);
+    GrPipelineBuilder::AutoRestoreEffects are(pipelineBuilder);
 
     SkMatrix localMatrix;
     if (!viewMatrix.invert(&localMatrix)) {
         SkDebugf("Cannot invert\n");
         return;
     }
 
     CoverageAttribType type;
-    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*drawState, color, &type,
+    SkAutoTUnref<const GrGeometryProcessor> gp(create_rect_gp(*pipelineBuilder, color, &type,
                                                               localMatrix));
 
     int innerVertexNum = 4;
     int outerVertexNum = miterStroke ? 4 : 8;
     int totalVertexNum = (outerVertexNum + innerVertexNum) * 2;
 
     size_t vstride = gp->getVertexStride();
     GrDrawTarget::AutoReleaseGeometry geo(target, totalVertexNum, vstride, 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
@@ skipping 93 matching lines @@
     for (int i = 0; i < innerVertexNum; ++i) {
         if (kUseCoverage_CoverageAttribType == type) {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = color;
             *reinterpret_cast<GrColor*>(verts + i * vstride + sizeof(GrColor)) = 0;
         } else {
             *reinterpret_cast<GrColor*>(verts + i * vstride) = 0;
         }
     }
 
     target->setIndexSourceToBuffer(indexBuffer);
-    target->drawIndexedInstances(drawState,
+    target->drawIndexedInstances(pipelineBuilder,
                                  gp,
                                  kTriangles_GrPrimitiveType,
                                  1,
                                  totalVertexNum,
                                  aa_stroke_rect_index_count(miterStroke));
     target->resetIndexSource();
 }
 
 void GrAARectRenderer::fillAANestedRects(GrDrawTarget* target,
-                                         GrDrawState* drawState,
+                                         GrPipelineBuilder* pipelineBuilder,
                                          GrColor color,
                                          const SkMatrix& viewMatrix,
                                          const SkRect rects[2]) {
     SkASSERT(viewMatrix.rectStaysRect());
     SkASSERT(!rects[1].isEmpty());
 
     SkRect devOutside, devOutsideAssist, devInside;
     viewMatrix.mapRect(&devOutside, rects[0]);
     // can't call mapRect for devInside since it calls sort
     viewMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
-        this->fillAARect(target, drawState, color, viewMatrix, devOutside,
+        this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
                          devOutside);
         return;
     }
 
-    this->geometryStrokeAARect(target, drawState, color, viewMatrix, devOutside, devOutsideAssist,
-                               devInside, true);
+    this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
+                               devOutsideAssist, devInside, true);
 }