Standardize BW to NonAA

src/gpu/GrClipMaskManager.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 "GrClipMaskManager.h"
 #include "GrAAConvexPathRenderer.h"
 #include "GrAAHairLinePathRenderer.h"
@@ skipping 392 matching lines @@
         case Element::kRect_Type:
             // TODO: Do rects directly to the accumulator using a aa-rect GrProcessor that covers
             // the entire mask bounds and writes 0 outside the rect.
             if (element->isAA()) {
                 SkRect devRect = element->getRect();
                 viewMatrix.mapRect(&devRect);
 
                 fClipTarget->drawAARect(*pipelineBuilder, color, viewMatrix,
                                         element->getRect(), devRect);
             } else {
-                fClipTarget->drawBWRect(*pipelineBuilder, color, viewMatrix,
-                                        element->getRect());
+                fClipTarget->drawNonAARect(*pipelineBuilder, color, viewMatrix,
+                                           element->getRect());
             }
             return true;
         default: {
             SkPath path;
             element->asPath(&path);
             path.setIsVolatile(true);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
             }
             GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
@@ skipping 65 matching lines @@
 
     pipelineBuilder->addCoverageProcessor(
         GrTextureDomainEffect::Create(pipelineBuilder->getProcessorDataManager(),
                                       srcMask,
                                       sampleM,
                                       GrTextureDomain::MakeTexelDomain(srcMask, srcBound),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode))->unref();
 
     // The color passed in here does not matter since the coverageSetOpXP won't read it.
-    fClipTarget->drawBWRect(*pipelineBuilder,
-                            GrColor_WHITE,
-                            SkMatrix::I(),
-                            SkRect::Make(dstBound));
+    fClipTarget->drawNonAARect(*pipelineBuilder,
+                               GrColor_WHITE,
+                               SkMatrix::I(),
+                               SkRect::Make(dstBound));
 }
 
 GrTexture* GrClipMaskManager::createTempMask(int width, int height) {
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = width;
     desc.fHeight = height;
     if (this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         desc.fConfig = kAlpha_8_GrPixelConfig;
     } else {
@@ skipping 169 matching lines @@
                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
                                              kZero_StencilOp,
                                              kZero_StencilOp,
                                              kEqual_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 backgroundPipelineBuilder.setStencil(kDrawOutsideElement);
 
                 // The color passed in here does not matter since the coverageSetOpXP won't read it.
-                fClipTarget->drawSimpleRect(backgroundPipelineBuilder, GrColor_WHITE, translate,
-                                            clipSpaceIBounds);
+                fClipTarget->drawNonAARect(backgroundPipelineBuilder, GrColor_WHITE, translate,
+                                           clipSpaceIBounds);
             }
         } else {
             GrPipelineBuilder pipelineBuilder;
 
             // all the remaining ops can just be directly draw into the accumulation buffer
             set_coverage_drawing_xpf(op, false, &pipelineBuilder);
             // The color passed in here does not matter since the coverageSetOpXP won't read it.
             this->drawElement(&pipelineBuilder, translate, result, element);
         }
     }
@@ skipping 115 matching lines @@
                                              kIncClamp_StencilOp,
                                              kIncClamp_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 if (Element::kRect_Type == element->getType()) {
                     *pipelineBuilder.stencil() = gDrawToStencil;
 
                     // We need this AGP until everything is in GrBatch
-                    fClipTarget->drawBWRect(pipelineBuilder,
-                                            GrColor_WHITE,
-                                            viewMatrix,
-                                            element->getRect());
+                    fClipTarget->drawNonAARect(pipelineBuilder,
+                                               GrColor_WHITE,
+                                               viewMatrix,
+                                               element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
                             *pipelineBuilder.stencil() = gDrawToStencil;
 
                             GrPathRenderer::DrawPathArgs args;
                             args.fTarget = fClipTarget;
                             args.fResourceProvider = this->getContext()->resourceProvider();
                             args.fPipelineBuilder = &pipelineBuilder;
                             args.fColor = GrColor_WHITE;
@@ skipping 18 matching lines @@
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             fClipMode = kModifyClip_StencilClipMode;
             for (int p = 0; p < passes; ++p) {
                 *pipelineBuilder.stencil() = stencilSettings[p];
 
                 if (canDrawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
                         // We need this AGP until everything is in GrBatch
-                        fClipTarget->drawBWRect(pipelineBuilder,
-                                                GrColor_WHITE,
-                                                viewMatrix,
-                                                element->getRect());
+                        fClipTarget->drawNonAARect(pipelineBuilder,
+                                                   GrColor_WHITE,
+                                                   viewMatrix,
+                                                   element->getRect());
                     } else {
                         GrPathRenderer::DrawPathArgs args;
                         args.fTarget = fClipTarget;
                         args.fResourceProvider = this->getContext()->resourceProvider();
                         args.fPipelineBuilder = &pipelineBuilder;
                         args.fColor = GrColor_WHITE;
                         args.fViewMatrix = &viewMatrix;
                         args.fPath = &clipPath;
                         args.fStroke = &stroke;
                         args.fAntiAlias = false;
                         pr->drawPath(args);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
-                    fClipTarget->drawBWRect(pipelineBuilder,
-                                            GrColor_WHITE,
-                                            viewMatrix,
-                                            SkRect::Make(clipSpaceIBounds));
+                    fClipTarget->drawNonAARect(pipelineBuilder,
+                                               GrColor_WHITE,
+                                               viewMatrix,
+                                               SkRect::Make(clipSpaceIBounds));
                 }
             }
         }
     }
     // set this last because recursive draws may overwrite it back to kNone.
     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
     fCurrClipMaskType = kStencil_ClipMaskType;
     fClipMode = kRespectClip_StencilClipMode;
     return true;
 }
@@ skipping 245 matching lines @@
     fAACache.purgeResources();
 }
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }