Retract PipelineBuilder from GrClip::apply

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 97 matching lines @@
         return SkToBool(!pr);
     }
 }
 
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
  */
 bool GrClipMaskManager::UseSWOnlyPath(GrContext* context,
-                                      const GrPipelineBuilder& pipelineBuilder,
+                                      bool hasUserStencilSettings,
                                       const GrDrawContext* drawContext,
                                       const SkVector& clipToMaskOffset,
                                       const GrReducedClip::ElementList& elements) {
     // TODO: generalize this function so that when
     // a clip gets complex enough it can just be done in SW regardless
     // of whether it would invoke the GrSoftwarePathRenderer.
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
 
     for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
         const Element* element = iter.get();
 
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         bool needsStencil = invert ||
                             SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op;
 
-        if (PathNeedsSWRenderer(context, pipelineBuilder.hasUserStencilSettings(),
+        if (PathNeedsSWRenderer(context, hasUserStencilSettings,
                                 drawContext, translate, element, nullptr, needsStencil)) {
             return true;
         }
     }
     return false;
 }
 
 static bool get_analytic_clip_processor(const GrReducedClip::ElementList& elements,
                                         bool abortIfAA,
                                         SkVector& clipToRTOffset,
@@ skipping 70 matching lines @@
     if (fps.count()) {
         *resultFP = GrFragmentProcessor::RunInSeries(fps.begin(), fps.count());
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
 bool GrClipMaskManager::SetupClipping(GrContext* context,
-                                      const GrPipelineBuilder& pipelineBuilder,
                                       GrDrawContext* drawContext,
                                       const GrClipStackClip& clip,
                                       const SkRect* origDevBounds,
+                                      bool useHWAA,
+                                      bool hasUserStencilSettings,
                                       GrAppliedClip* out) {
     if (!clip.clipStack() || clip.clipStack()->isWideOpen()) {
         return true;
     }
 
     GrReducedClip::ElementList elements;
     int32_t genID = 0;
     GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA = false;
@@ skipping 43 matching lines @@
     if (elements.count() <= kMaxAnalyticElements) {
         SkVector clipToRTOffset = { SkIntToScalar(-clip.origin().fX),
                                     SkIntToScalar(-clip.origin().fY) };
         // When there are multiple samples we want to do per-sample clipping, not compute a
         // fractional pixel coverage.
         bool disallowAnalyticAA = drawContext->isStencilBufferMultisampled();
         if (disallowAnalyticAA && !drawContext->numColorSamples()) {
             // With a single color sample, any coverage info is lost from color once it hits the
             // color buffer anyway, so we may as well use coverage AA if nothing else in the pipe
             // is multisampled.
-            disallowAnalyticAA = pipelineBuilder.isHWAntialias() ||
-                                 pipelineBuilder.hasUserStencilSettings();
+            disallowAnalyticAA = useHWAA || hasUserStencilSettings;
         }
         sk_sp<GrFragmentProcessor> clipFP;
         if (requiresAA &&
             get_analytic_clip_processor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
                                         &clipFP)) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clip.origin());
             if (!SkRect::Make(scissorSpaceIBounds).contains(devBounds)) {
                 out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
                 return true;
             }
             out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
     if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
         sk_sp<GrTexture> result;
 
         // The top-left of the mask corresponds to the top-left corner of the bounds.
         SkVector clipToMaskOffset = {
             SkIntToScalar(-clipSpaceIBounds.fLeft),
             SkIntToScalar(-clipSpaceIBounds.fTop)
         };
 
-        if (UseSWOnlyPath(context, pipelineBuilder, drawContext,
+        if (UseSWOnlyPath(context, hasUserStencilSettings, drawContext,
                           clipToMaskOffset, elements)) {
             // The clip geometry is complex enough that it will be more efficient to create it
             // entirely in software
             result = CreateSoftwareClipMask(context->textureProvider(),
                                             genID,
                                             initialState,
                                             elements,
                                             clipToMaskOffset,
                                             clipSpaceIBounds);
         } else {
@@ skipping 470 matching lines @@
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }