Standardize BW to NonAA

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextContext.h"
 #include "GrBatchTest.h"
@@ skipping 177 matching lines @@
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fContext);
         if (!this->prepareToDraw(rt)) {
             return;
         }
 
         GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
-        fDrawTarget->drawBWRect(pipelineBuilder,
-                                paint->getColor(),
-                                SkMatrix::I(),
-                                r,
-                                localMatrix);
+        fDrawTarget->drawNonAARect(pipelineBuilder,
+                                   paint->getColor(),
+                                   SkMatrix::I(),
+                                   r,
+                                   localMatrix);
     }
 }
 
 static inline bool rect_contains_inclusive(const SkRect& rect, const SkPoint& point) {
     return point.fX >= rect.fLeft && point.fX <= rect.fRight &&
            point.fY >= rect.fTop && point.fY <= rect.fBottom;
 }
 
 void GrDrawContext::drawRect(GrRenderTarget* rt,
                              const GrClip& clip,
@@ skipping 61 matching lines @@
     // The stroke path needs the rect to remain axis aligned (no rotation or skew)
     // None of our draw rect calls can handle perspective yet
     SkASSERT(!viewMatrix.hasPerspective());
     bool canApplyAA = width >=0 ? viewMatrix.rectStaysRect() : viewMatrix.preservesRightAngles();
 
     if (needAA && canApplyAA) {
         SkRect devBoundRect;
         viewMatrix.mapRect(&devBoundRect, rect);
         SkAutoTUnref<GrDrawBatch> batch;
         if (width >= 0) {
-            batch.reset(GrRectBatchFactory::CreateStrokeAA(color, viewMatrix, rect, devBoundRect,
+            batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect, devBoundRect,
                                                            *strokeInfo));
         } else {
-            batch.reset(GrRectBatchFactory::CreateFillAA(color, viewMatrix, rect, devBoundRect));
+            batch.reset(GrRectBatchFactory::CreateAAFill(color, viewMatrix, rect, devBoundRect));
         }
         fDrawTarget->drawBatch(pipelineBuilder, batch);
         return;
     }
 
     if (width >= 0) {
         // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
         bool snapToPixelCenters = (0 == width && !rt->isUnifiedMultisampled());
-        SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateStrokeBW(
+        SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAStroke(
                                         color, viewMatrix, rect, width, snapToPixelCenters));
 
         // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
         // hairline rects. We jam all the vertices to pixel centers to avoid this, but not when MSAA
         // is enabled because it can cause ugly artifacts.
         pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                  snapToPixelCenters);
         fDrawTarget->drawBatch(pipelineBuilder, batch);
     } else {
         // filled BW rect
-        fDrawTarget->drawBWRect(pipelineBuilder, color, viewMatrix, rect);
+        fDrawTarget->drawNonAARect(pipelineBuilder, color, viewMatrix, rect);
     }
 }
 
 void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt,
                                         const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkRect& rectToDraw,
                                         const SkRect& localRect) {
     RETURN_IF_ABANDONED
     AutoCheckFlush acf(fContext);
     if (!this->prepareToDraw(rt)) {
         return;
     }
 
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
-    fDrawTarget->drawBWRect(pipelineBuilder,
-                            paint.getColor(),
-                            viewMatrix,
-                            rectToDraw,
-                            localRect);
+    fDrawTarget->drawNonAARect(pipelineBuilder,
+                               paint.getColor(),
+                               viewMatrix,
+                               rectToDraw,
+                               localRect);
 }
 
 void GrDrawContext::drawNonAARectWithLocalMatrix(GrRenderTarget* rt,
                                                  const GrClip& clip,
                                                  const GrPaint& paint,
                                                  const SkMatrix& viewMatrix,
                                                  const SkRect& rectToDraw,
                                                  const SkMatrix& localMatrix) {
     RETURN_IF_ABANDONED
     AutoCheckFlush acf(fContext);
     if (!this->prepareToDraw(rt)) {
         return;
     }
 
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
-    fDrawTarget->drawBWRect(pipelineBuilder,
-                            paint.getColor(),
-                            viewMatrix,
-                            rectToDraw,
-                            localMatrix);
+    fDrawTarget->drawNonAARect(pipelineBuilder,
+                               paint.getColor(),
+                               viewMatrix,
+                               rectToDraw,
+                               localMatrix);
 }
 
 void GrDrawContext::drawVertices(GrRenderTarget* rt,
                                  const GrClip& clip,
                                  const GrPaint& paint,
                                  const SkMatrix& viewMatrix,
                                  GrPrimitiveType primitiveType,
                                  int vertexCount,
                                  const SkPoint positions[],
                                  const SkPoint texCoords[],
@@ skipping 276 matching lines @@
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     if (!strokeInfo.isDashed()) {
         bool useCoverageAA = paint.isAntiAlias() &&
                 !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
         if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
             if (is_nested_rects(viewMatrix, path, strokeInfo, rects)) {
-                SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateFillNestedRectsAA(
+                SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateAAFillNestedRects(
                     color, viewMatrix, rects));
                 fDrawTarget->drawBatch(pipelineBuilder, batch);
                 return;
             }
         }
         SkRect ovalRect;
         bool isOval = path.isOval(&ovalRect);
 
         if (isOval && !path.isInverseFillType()) {
             if (GrOvalRenderer::DrawOval(fDrawTarget,
@@ skipping 104 matching lines @@
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     fDrawTarget->drawBatch(*pipelineBuilder, batch);
 }