Fix GrDrawContextPriv::stencilRect

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"
 #include "GrDrawContext.h"
@@ skipping 259 matching lines @@
         this->drawRect(clip, *paint, viewMatrix, r);
     } else {
         SkMatrix localMatrix;
         if (!viewMatrix.invert(&localMatrix)) {
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fDrawingManager);
 
-        this->drawNonAAFilledRect(clip, *paint, SkMatrix::I(), r, nullptr, &localMatrix, nullptr);
+        this->drawNonAAFilledRect(clip, *paint, SkMatrix::I(), r, nullptr, &localMatrix, nullptr,
+                                  false /* useHWAA */);
     }
 }
 
 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 101 matching lines @@
             if (batch) {
                 GrPipelineBuilder pipelineBuilder(paint, useHWAA);
                 if (ss) {
                     pipelineBuilder.setUserStencil(ss);
                 }
                 this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
                 return true;
             }
         }
     } else {
-        this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, nullptr, ss);
+        this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr, nullptr, ss,
+                                  useHWAA);
         return true;
     }
 
     return false;
 }
 
 void GrDrawContext::drawRect(const GrClip& clip,
                              const GrPaint& paint,
                              const SkMatrix& viewMatrix,
                              const SkRect& rect,
@@ skipping 146 matching lines @@
     RETURN_IF_ABANDONED_PRIV
     SkDEBUGCODE(fDrawContext->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fDrawContext->fAuditTrail, "GrDrawContext::stencilRect");
 
     AutoCheckFlush acf(fDrawContext->fDrawingManager);
 
     GrPaint paint;
     paint.setAntiAlias(useHWAA);
     paint.setXPFactory(GrDisableColorXPFactory::Make());
 
-    SkASSERT(!useHWAA || fDrawContext->isStencilBufferMultisampled());
-
-    fDrawContext->drawFilledRect(clip, paint, viewMatrix, rect, ss);
+    fDrawContext->drawNonAAFilledRect(clip, paint, viewMatrix, rect, nullptr, nullptr, ss, useHWAA);
 }
 
 bool GrDrawContextPriv::drawAndStencilRect(const GrFixedClip& clip,
                                            const GrUserStencilSettings* ss,
                                            SkRegion::Op op,
                                            bool invert,
                                            bool doAA,
                                            const SkMatrix& viewMatrix,
                                            const SkRect& rect) {
     ASSERT_SINGLE_OWNER_PRIV
@@ skipping 42 matching lines @@
                                                        fInstancedPipelineInfo, &useHWAA));
         if (batch) {
             GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
             return;
         }
     }
 
     if (!should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA)) {
         this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, &croppedLocalRect,
-                                  nullptr, nullptr);
+                                  nullptr, nullptr, useHWAA);
         return;
     }
 
     if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::CreateWithLocalRect(paint.getColor(),
                                                                                viewMatrix,
                                                                                croppedRect,
                                                                                croppedLocalRect));
         GrPipelineBuilder pipelineBuilder(paint, useHWAA);
         this->drawBatch(pipelineBuilder, clip, batch);
@@ skipping 37 matching lines @@
                                                        fInstancedPipelineInfo, &useHWAA));
         if (batch) {
             GrPipelineBuilder pipelineBuilder(paint, useHWAA);
             this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
             return;
         }
     }
 
     if (!should_apply_coverage_aa(paint, fRenderTarget.get(), &useHWAA)) {
         this->drawNonAAFilledRect(clip, paint, viewMatrix, croppedRect, nullptr,
-                                  &localMatrix, nullptr);
+                                  &localMatrix, nullptr, useHWAA);
         return;
     }
 
     if (view_matrix_ok_for_aa_fill_rect(viewMatrix)) {
         SkAutoTUnref<GrDrawBatch> batch(GrAAFillRectBatch::Create(paint.getColor(), viewMatrix,
                                                                   localMatrix, croppedRect));
         GrPipelineBuilder pipelineBuilder(paint, useHWAA);
         this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
         return;
     }
@@ skipping 315 matching lines @@
 
     fDrawingManager->getContext()->prepareSurfaceForExternalIO(fRenderTarget.get());
 }
 
 void GrDrawContext::drawNonAAFilledRect(const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkRect& rect,
                                         const SkRect* localRect,
                                         const SkMatrix* localMatrix,
-                                        const GrUserStencilSettings* ss) {
+                                        const GrUserStencilSettings* ss,
+                                        bool useHWAA) {
+    SkASSERT(!useHWAA || this->isStencilBufferMultisampled());
     SkAutoTUnref<GrDrawBatch> batch(
             GrRectBatchFactory::CreateNonAAFill(paint.getColor(), viewMatrix, rect, localRect,
                                                 localMatrix));
-    GrPipelineBuilder pipelineBuilder(paint, this->mustUseHWAA(paint));
+    GrPipelineBuilder pipelineBuilder(paint, useHWAA);
     if (ss) {
         pipelineBuilder.setUserStencil(ss);
     }
     this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool fills_as_nested_rects(const SkMatrix& viewMatrix, const SkPath& path, SkRect rects[2]) {
 
     if (path.isInverseFillType()) {
@@ skipping 239 matching lines @@
 
 void GrDrawContext::drawBatch(const GrPipelineBuilder& pipelineBuilder, const GrClip& clip,
                               GrDrawBatch* batch) {
     ASSERT_SINGLE_OWNER
     RETURN_IF_ABANDONED
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(fAuditTrail, "GrDrawContext::drawBatch");
 
     this->getDrawTarget()->drawBatch(pipelineBuilder, this, clip, batch);
 }