Remove two varieties of drawNonAARect from GrDrawTarget

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 "GrBatchTest.h"
 #include "GrColor.h"
@@ skipping 196 matching lines @@
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fDrawingManager);
 
         GrPipelineBuilder pipelineBuilder(*paint, fRenderTarget, clip);
-        this->getDrawTarget()->drawNonAARect(pipelineBuilder,
-                                             paint->getColor(),
-                                             SkMatrix::I(),
-                                             r,
-                                             localMatrix);
+        SkAutoTUnref<GrDrawBatch> batch(
+                GrRectBatchFactory::CreateNonAAFill(paint->getColor(), SkMatrix::I(), r, nullptr,
+                                                    &localMatrix));
+        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
     }
 }
 
 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;
 }
 
 static bool view_matrix_ok_for_aa_fill_rect(const SkMatrix& viewMatrix) {
     return viewMatrix.preservesRightAngles();
@@ skipping 49 matching lines @@
                     this->getDrawTarget()->clear(nullptr, clearColor, true, fRenderTarget);
                     return;
                 }
             }
         }
     }
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
     GrColor color = paint.getColor();
 
+    SkAutoTUnref<GrDrawBatch> batch;
     if (should_apply_coverage_aa(paint, fRenderTarget)) {
-        SkAutoTUnref<GrDrawBatch> batch;
         if (width >= 0) {
             // The stroke path needs the rect to remain axis aligned (no rotation or skew).
             if (viewMatrix.rectStaysRect()) {
                 batch.reset(GrRectBatchFactory::CreateAAStroke(color, viewMatrix, rect,
                                                                *strokeInfo));
             }
         } else {
             // The fill path can handle rotation but not skew.
             if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
                 SkRect devBoundRect;
                 viewMatrix.mapRect(&devBoundRect, rect);
                 batch.reset(GrRectBatchFactory::CreateAAFill(color, viewMatrix, rect,
                                                              devBoundRect));
             }
         }
-        if (batch) {
-            this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
-        } else {
+        if (!batch) {
             SkPath path;
             path.setIsVolatile(true);
             path.addRect(rect);
             this->internalDrawPath(&pipelineBuilder, viewMatrix, color, true, path, *strokeInfo);
             SkASSERT(paint.isAntiAlias());
+            return;
         }
-        return;
-    }
-
-    if (width >= 0) {
+    } else if (width >= 0) {
         // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
         bool snapToPixelCenters = (0 == width && !fRenderTarget->isUnifiedMultisampled());
-        SkAutoTUnref<GrDrawBatch> batch(GrRectBatchFactory::CreateNonAAStroke(
-                                        color, viewMatrix, rect, width, snapToPixelCenters));
+        batch.reset(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);
-        this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
     } else {
         // filled BW rect
-        this->getDrawTarget()->drawNonAARect(pipelineBuilder, color, viewMatrix, rect);
+        batch.reset(GrRectBatchFactory::CreateNonAAFill(color, viewMatrix, rect, nullptr, nullptr));
     }
+    this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 void GrDrawContext::fillRectToRect(const GrClip& clip,
                                    const GrPaint& paint,
                                    const SkMatrix& viewMatrix,
                                    const SkRect& rectToDraw,
                                    const SkRect& localRect) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fDrawingManager);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
+    SkAutoTUnref<GrDrawBatch> batch;
     if (should_apply_coverage_aa(paint, fRenderTarget) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
-        SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::CreateWithLocalRect(
-            paint.getColor(), viewMatrix, rectToDraw, localRect));
-        if (batch) {
-            this->drawBatch(&pipelineBuilder, batch);
-        }
+        batch.reset(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(), viewMatrix, rectToDraw,
+                                                           localRect));
     } else {
-        this->getDrawTarget()->drawNonAARect(pipelineBuilder,
-                                             paint.getColor(),
-                                             viewMatrix,
-                                             rectToDraw,
-                                             localRect);
+        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
+                                                        &localRect, nullptr));
+    }
+
+    if (batch) {
+        this->drawBatch(&pipelineBuilder, batch);
     }
 }
 
 void GrDrawContext::fillRectWithLocalMatrix(const GrClip& clip,
                                             const GrPaint& paint,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& rectToDraw,
                                             const SkMatrix& localMatrix) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     AutoCheckFlush acf(fDrawingManager);
 
     GrPipelineBuilder pipelineBuilder(paint, fRenderTarget, clip);
 
+    SkAutoTUnref<GrDrawBatch> batch;
     if (should_apply_coverage_aa(paint, fRenderTarget) &&
         view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
-        SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::Create(
-            paint.getColor(), viewMatrix, localMatrix, rectToDraw));
-        this->drawBatch(&pipelineBuilder, batch);
+        batch.reset(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix, localMatrix,
+                                              rectToDraw));
     } else {
-        this->getDrawTarget()->drawNonAARect(pipelineBuilder,
-                                             paint.getColor(),
-                                             viewMatrix,
-                                             rectToDraw,
-                                             localMatrix);
+        batch.reset(GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rectToDraw,
+                                                        nullptr, &localMatrix));
     }
+    this->getDrawTarget()->drawBatch(pipelineBuilder, batch);
 }
 
 void GrDrawContext::drawVertices(const GrClip& clip,
                                  const GrPaint& paint,
                                  const SkMatrix& viewMatrix,
                                  GrPrimitiveType primitiveType,
                                  int vertexCount,
                                  const SkPoint positions[],
                                  const SkPoint texCoords[],
                                  const GrColor colors[],
@@ skipping 427 matching lines @@
     pr->drawPath(args);
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
 
     this->getDrawTarget()->drawBatch(*pipelineBuilder, batch);
 }