Fix GrDrawContextPriv::stencilRect

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 "GrCaps.h"
 #include "GrDrawingManager.h"
@@ skipping 33 matching lines @@
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     return sk_sp<GrFragmentProcessor>(GrTextureDomainEffect::Make(
                                          result,
                                          mat,
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
                                          kDevice_GrCoordSet));
 }
 
-void GrClipMaskManager::DrawNonAARect(GrDrawContext* drawContext,
-                                      const GrFixedClip& clip,
-                                      const SkMatrix& viewMatrix,
-                                      const SkRect& rect,
-                                      bool doAA,
-                                      const GrUserStencilSettings* stencilSettings) {
-    drawContext->drawContextPriv().stencilRect(clip, stencilSettings, doAA, viewMatrix, rect);
-}
-
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
 bool GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
                                             bool hasUserStencilSettings,
                                             const GrDrawContext* drawContext,
                                             const SkMatrix& viewMatrix,
                                             const Element* element,
                                             GrPathRenderer** prOut,
                                             bool needsStencil) {
@@ skipping 520 matching lines @@
         GrFixedClip clip(stencilSpaceIBounds);
 
         drawContext->drawContextPriv().clearStencilClip(
                                             stencilSpaceIBounds,
                                             GrReducedClip::kAllIn_InitialState == initialState);
 
         // walk through each clip element and perform its set op
         // with the existing clip.
         for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
             const Element* element = iter.get();
+            bool useHWAA = element->isAA() && drawContext->isStencilBufferMultisampled();
 
             bool fillInverted = false;
             // enabled at bottom of loop
             clip.enableStencilClip(false);
 
             // This will be used to determine whether the clip shape can be rendered into the
             // stencil with arbitrary stencil settings.
             GrPathRenderer::StencilSupport stencilSupport;
 
             SkRegion::Op op = element->getOp();
@@ skipping 42 matching lines @@
                 static constexpr GrUserStencilSettings kDrawToStencil(
                      GrUserStencilSettings::StaticInit<
                          0x0000,
                          GrUserStencilTest::kAlways,
                          0xffff,
                          GrUserStencilOp::kIncMaybeClamp,
                          GrUserStencilOp::kIncMaybeClamp,
                          0xffff>()
                 );
                 if (Element::kRect_Type == element->getType()) {
-                    DrawNonAARect(drawContext, clip, viewMatrix,
-                                  element->getRect(), element->isAA(), &kDrawToStencil);
+                    drawContext->drawContextPriv().stencilRect(clip, &kDrawToStencil, useHWAA,
+                                                               viewMatrix, element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
                             GrPaint paint;
                             paint.setXPFactory(GrDisableColorXPFactory::Make());
                             paint.setAntiAlias(element->isAA());
 
                             GrPathRenderer::DrawPathArgs args;
                             args.fResourceProvider = context->resourceProvider();
                             args.fPaint = &paint;
@@ skipping 21 matching lines @@
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             clip.enableStencilClip(true);
             for (GrUserStencilSettings const* const* pass = stencilPasses; *pass; ++pass) {
 
                 if (drawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
-                        DrawNonAARect(drawContext, clip,
-                                      viewMatrix, element->getRect(), element->isAA(), *pass);
+                        drawContext->drawContextPriv().stencilRect(clip, *pass, useHWAA, viewMatrix,
+                                                                   element->getRect());
                     } else {
                         GrPaint paint;
                         paint.setXPFactory(GrDisableColorXPFactory::Make());
                         paint.setAntiAlias(element->isAA());
 
                         GrPathRenderer::DrawPathArgs args;
                         args.fResourceProvider = context->resourceProvider();
                         args.fPaint = &paint;
                         args.fUserStencilSettings = *pass;
                         args.fDrawContext = drawContext;
                         args.fClip = &clip;
                         args.fColor = GrColor_WHITE;
                         args.fViewMatrix = &viewMatrix;
                         args.fPath = &clipPath;
                         args.fStyle = &GrStyle::SimpleFill();
                         args.fAntiAlias = false;
                         args.fGammaCorrect = false;
                         pr->drawPath(args);
                     }
                 } else {
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
-                    DrawNonAARect(drawContext, clip, viewMatrix,
-                                  SkRect::Make(clipSpaceIBounds), false, *pass);
+                    drawContext->drawContextPriv().stencilRect(clip, *pass, false, viewMatrix,
+                                                               SkRect::Make(clipSpaceIBounds));
                 }
             }
         }
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 sk_sp<GrTexture> GrClipMaskManager::CreateSoftwareClipMask(
                                                     GrTextureProvider* texProvider,
@@ skipping 64 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }