Encapsulate GrReducedClip result in class members

src/gpu/GrClipStackClip.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipStackClip.h"
 
 #include "GrDrawingManager.h"
 #include "GrDrawContextPriv.h"
 #include "GrGpuResourcePriv.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef SkClipStack::Element Element;
 typedef GrReducedClip::InitialState InitialState;
+typedef GrReducedClip::ElementList ElementList;
 
 static const int kMaxAnalyticElements = 4;
 
 bool GrClipStackClip::quickContains(const SkRect& rect) const {
     if (!fStack) {
         return true;
     }
     return fStack->quickContains(rect.makeOffset(SkIntToScalar(fOrigin.x()),
                                                  SkIntToScalar(fOrigin.y())));
 }
@@ skipping 96 matching lines @@
 
 /*
  * 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 GrClipStackClip::UseSWOnlyPath(GrContext* context,
                                     bool hasUserStencilSettings,
                                     const GrDrawContext* drawContext,
                                     const SkVector& clipToMaskOffset,
-                                    const GrReducedClip::ElementList& elements) {
+                                    const 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()) {
+    for (ElementList::Iter iter(elements); 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, hasUserStencilSettings,
                                 drawContext, translate, element, nullptr, needsStencil)) {
             return true;
         }
     }
     return false;
 }
 
-static bool get_analytic_clip_processor(const GrReducedClip::ElementList& elements,
+static bool get_analytic_clip_processor(const ElementList& elements,
                                         bool abortIfAA,
                                         const SkVector& clipToRTOffset,
                                         const SkRect& drawBounds,
                                         sk_sp<GrFragmentProcessor>* resultFP) {
     SkRect boundsInClipSpace;
     boundsInClipSpace = drawBounds.makeOffset(-clipToRTOffset.fX, -clipToRTOffset.fY);
     SkASSERT(elements.count() <= kMaxAnalyticElements);
     SkSTArray<kMaxAnalyticElements, sk_sp<GrFragmentProcessor>> fps;
-    GrReducedClip::ElementList::Iter iter(elements);
+    ElementList::Iter iter(elements);
     while (iter.get()) {
         SkRegion::Op op = iter.get()->getOp();
         bool invert;
         bool skip = false;
         switch (op) {
             case SkRegion::kReplace_Op:
                 SkASSERT(iter.get() == elements.head());
                 // Fallthrough, handled same as intersect.
             case SkRegion::kIntersect_Op:
                 invert = false;
@@ skipping 70 matching lines @@
     }
 
     SkRect devBounds = SkRect::MakeIWH(drawContext->width(), drawContext->height());
     if (origDevBounds && !devBounds.intersect(*origDevBounds)) {
         return false;
     }
 
     const SkScalar clipX = SkIntToScalar(fOrigin.x()),
                    clipY = SkIntToScalar(fOrigin.y());
 
-    GrReducedClip::ElementList elements;
-    int32_t genID = 0;
-    SkIRect clipSpaceIBounds;
-    bool requiresAA = false;
+    SkRect clipSpaceDevBounds = devBounds.makeOffset(clipX, clipY);
+    const GrReducedClip reducedClip(*fStack, clipSpaceDevBounds);
 
-    InitialState initialState = GrReducedClip::ReduceClipStack(*fStack,
-                                                               devBounds.makeOffset(clipX, clipY),
-                                                               &elements,
-                                                               &genID,
-                                                               &clipSpaceIBounds,
-                                                               &requiresAA);
-    if (elements.isEmpty()) {
-        if (GrReducedClip::kAllOut_InitialState == initialState || clipSpaceIBounds.isEmpty()) {
+    if (reducedClip.elements().isEmpty()) {
+        if (GrReducedClip::InitialState::kAllOut == reducedClip.initialState()) {
             return false;
-        } else {
-            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
+        }
+        if (!GrClip::IsInsideClip(reducedClip.iBounds(), clipSpaceDevBounds)) {
+            SkIRect scissorSpaceIBounds(reducedClip.iBounds());
             scissorSpaceIBounds.offset(-fOrigin);
-            if (!GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
-                out->makeScissored(scissorSpaceIBounds);
-            }
-            return true;
+            out->makeScissored(scissorSpaceIBounds);
         }
+        return true;
     }
 
     // An element count of 4 was chosen because of the common pattern in Blink of:
     //   isect RR
     //   diff  RR
     //   isect convex_poly
     //   isect convex_poly
     // when drawing rounded div borders. This could probably be tuned based on a
     // configuration's relative costs of switching RTs to generate a mask vs
     // longer shaders.
-    if (elements.count() <= kMaxAnalyticElements) {
+    if (reducedClip.elements().count() <= kMaxAnalyticElements) {
         // 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 = useHWAA || hasUserStencilSettings;
         }
         sk_sp<GrFragmentProcessor> clipFP;
-        if (requiresAA &&
-            get_analytic_clip_processor(elements, disallowAnalyticAA, {-clipX, -clipY}, devBounds,
-                                        &clipFP)) {
-            SkIRect scissorSpaceIBounds(clipSpaceIBounds);
+        if (reducedClip.requiresAA() &&
+            get_analytic_clip_processor(reducedClip.elements(), disallowAnalyticAA,
+                                        {-clipX, -clipY}, devBounds, &clipFP)) {
+            SkIRect scissorSpaceIBounds(reducedClip.iBounds());
             scissorSpaceIBounds.offset(-fOrigin);
             if (GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
                 out->makeFPBased(std::move(clipFP), SkRect::Make(scissorSpaceIBounds));
             } else {
                 out->makeScissoredFPBased(std::move(clipFP), scissorSpaceIBounds);
             }
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
-    if (!drawContext->isStencilBufferMultisampled() && requiresAA) {
+    if (!drawContext->isStencilBufferMultisampled() && reducedClip.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)
+            SkIntToScalar(-reducedClip.left()),
+            SkIntToScalar(-reducedClip.top())
         };
 
         if (UseSWOnlyPath(context, hasUserStencilSettings, drawContext,
-                          clipToMaskOffset, elements)) {
+                          clipToMaskOffset, reducedClip.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);
+            result = CreateSoftwareClipMask(context->textureProvider(), reducedClip,
+                                            clipToMaskOffset);
         } else {
-            result = CreateAlphaClipMask(context,
-                                         genID,
-                                         initialState,
-                                         elements,
-                                         clipToMaskOffset,
-                                         clipSpaceIBounds);
+            result = CreateAlphaClipMask(context, reducedClip, clipToMaskOffset);
             // If createAlphaClipMask fails it means UseSWOnlyPath has a bug
             SkASSERT(result);
         }
 
         if (result) {
             // The mask's top left coord should be pinned to the rounded-out top left corner of
             // clipSpace bounds. We determine the mask's position WRT to the render target here.
-            SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
+            SkIRect rtSpaceMaskBounds = reducedClip.iBounds();
             rtSpaceMaskBounds.offset(-fOrigin);
             out->makeFPBased(create_fp_for_mask(result.get(), rtSpaceMaskBounds),
                              SkRect::Make(rtSpaceMaskBounds));
             return true;
         }
         // if alpha clip mask creation fails fall through to the non-AA code paths
     }
 
     // use the stencil clip if we can't represent the clip as a rectangle.
     SkIPoint clipSpaceToStencilSpaceOffset = -fOrigin;
-    CreateStencilClipMask(context,
-                          drawContext,
-                          genID,
-                          initialState,
-                          elements,
-                          clipSpaceIBounds,
-                          clipSpaceToStencilSpaceOffset);
+    CreateStencilClipMask(context, drawContext, reducedClip, clipSpaceToStencilSpaceOffset);
 
     // This must occur after createStencilClipMask. That function may change the scissor. Also, it
     // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
     // use both stencil and scissor test to the bounds for the final draw.
-    SkIRect scissorSpaceIBounds(clipSpaceIBounds);
-    scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
-    if (GrClip::IsInsideClip(scissorSpaceIBounds, devBounds)) {
+    if (GrClip::IsInsideClip(reducedClip.iBounds(), clipSpaceDevBounds)) {
         out->makeStencil(true, devBounds);
     } else {
+        SkIRect scissorSpaceIBounds(reducedClip.iBounds());
+        scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
         out->makeScissoredStencil(scissorSpaceIBounds);
     }
     return true;
 }
 
 static bool stencil_element(GrDrawContext* dc,
                             const GrFixedClip& clip,
                             const GrUserStencilSettings* ss,
                             const SkMatrix& viewMatrix,
                             const SkClipStack::Element* element) {
@@ skipping 60 matching lines @@
 
 static void GetClipMaskKey(int32_t clipGenID, const SkIRect& bounds, GrUniqueKey* key) {
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(key, kDomain, 3);
     builder[0] = clipGenID;
     builder[1] = SkToU16(bounds.fLeft) | (SkToU16(bounds.fRight) << 16);
     builder[2] = SkToU16(bounds.fTop) | (SkToU16(bounds.fBottom) << 16);
 }
 
 sk_sp<GrTexture> GrClipStackClip::CreateAlphaClipMask(GrContext* context,
-                                                      int32_t elementsGenID,
-                                                      GrReducedClip::InitialState initialState,
-                                                      const GrReducedClip::ElementList& elements,
-                                                      const SkVector& clipToMaskOffset,
-                                                      const SkIRect& clipSpaceIBounds) {
+                                                      const GrReducedClip& reducedClip,
+                                                      const SkVector& clipToMaskOffset) {
     GrResourceProvider* resourceProvider = context->resourceProvider();
     GrUniqueKey key;
-    GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
+    GetClipMaskKey(reducedClip.genID(), reducedClip.iBounds(), &key);
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
         return sk_sp<GrTexture>(texture);
     }
 
     // There's no texture in the cache. Let's try to allocate it then.
     GrPixelConfig config = kRGBA_8888_GrPixelConfig;
     if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         config = kAlpha_8_GrPixelConfig;
     }
 
     sk_sp<GrDrawContext> dc(context->makeDrawContext(SkBackingFit::kApprox,
-                                                     clipSpaceIBounds.width(),
-                                                     clipSpaceIBounds.height(),
+                                                     reducedClip.width(),
+                                                     reducedClip.height(),
                                                      config, nullptr));
     if (!dc) {
         return nullptr;
     }
     
     // The texture may be larger than necessary, this rect represents the part of the texture
     // we populate with a rasterization of the clip.
-    SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
+    SkIRect maskSpaceIBounds = SkIRect::MakeWH(reducedClip.width(), reducedClip.height());
 
     // The scratch texture that we are drawing into can be substantially larger than the mask. Only
     // clear the part that we care about.
     dc->clear(&maskSpaceIBounds,
-              GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
+              GrReducedClip::InitialState::kAllIn == reducedClip.initialState() ? -1 : 0,
               true);
 
     // 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);
 
     // It is important that we use maskSpaceIBounds as the stencil rect in the below loop.
     // The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first
     // pass must not set values outside of this bounds or stencil values outside the rect won't be
     // cleared.
 
     // walk through each clip element and perform its set op
-    for (GrReducedClip::ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
+    for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             GrFixedClip clip(maskSpaceIBounds);
 
             // draw directly into the result with the stencil set to make the pixels affected
             // by the clip shape be non-zero.
             static constexpr GrUserStencilSettings kStencilInElement(
                  GrUserStencilSettings::StaticInit<
@@ skipping 15 matching lines @@
                      0x0000,
                      GrUserStencilTest::kEqual,
                      0xffff,
                      GrUserStencilOp::kZero,
                      GrUserStencilOp::kZero,
                      0xffff>()
             );
             if (!dc->drawContextPriv().drawAndStencilRect(clip, &kDrawOutsideElement,
                                                           op, !invert, false,
                                                           translate,
-                                                          SkRect::Make(clipSpaceIBounds))) {
+                                                          SkRect::Make(reducedClip.iBounds()))) {
                 return nullptr;
             }
         } else {
             // all the remaining ops can just be directly draw into the accumulation buffer
             GrPaint paint;
             paint.setAntiAlias(element->isAA());
             paint.setCoverageSetOpXPFactory(op, false);
 
             draw_element(dc.get(), GrNoClip(), paint, translate, element);
         }
     }
 
     sk_sp<GrTexture> texture(dc->asTexture());
     SkASSERT(texture);
     texture->resourcePriv().setUniqueKey(key);
     return texture;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
 bool GrClipStackClip::CreateStencilClipMask(GrContext* context,
                                             GrDrawContext* drawContext,
-                                            int32_t elementsGenID,
-                                            GrReducedClip::InitialState initialState,
-                                            const GrReducedClip::ElementList& elements,
-                                            const SkIRect& clipSpaceIBounds,
+                                            const GrReducedClip& reducedClip,
                                             const SkIPoint& clipSpaceToStencilOffset) {
     SkASSERT(drawContext);
 
     GrStencilAttachment* stencilAttachment = context->resourceProvider()->attachStencilAttachment(
                                                     drawContext->accessRenderTarget());
     if (nullptr == stencilAttachment) {
         return false;
     }
 
     // TODO: these need to be swapped over to using a StencilAttachmentProxy
-    if (stencilAttachment->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
-        stencilAttachment->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
+    if (stencilAttachment->mustRenderClip(reducedClip.genID(), reducedClip.iBounds(),
+                                          clipSpaceToStencilOffset)) {
+        stencilAttachment->setLastClip(reducedClip.genID(), reducedClip.iBounds(),
+                                       clipSpaceToStencilOffset);
         // Set the matrix so that rendered clip elements are transformed from clip to stencil space.
         SkVector translate = {
             SkIntToScalar(clipSpaceToStencilOffset.fX),
             SkIntToScalar(clipSpaceToStencilOffset.fY)
         };
         SkMatrix viewMatrix;
         viewMatrix.setTranslate(translate);
 
         // We set the current clip to the bounds so that our recursive draws are scissored to them.
-        SkIRect stencilSpaceIBounds(clipSpaceIBounds);
+        SkIRect stencilSpaceIBounds(reducedClip.iBounds());
         stencilSpaceIBounds.offset(clipSpaceToStencilOffset);
         GrFixedClip clip(stencilSpaceIBounds);
 
-        drawContext->drawContextPriv().clearStencilClip(
-                                            stencilSpaceIBounds,
-                                            GrReducedClip::kAllIn_InitialState == initialState);
+        bool insideClip = GrReducedClip::InitialState::kAllIn == reducedClip.initialState();
+        drawContext->drawContextPriv().clearStencilClip(stencilSpaceIBounds, insideClip);
 
         // 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()) {
+        for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
             const Element* element = iter.get();
             bool useHWAA = element->isAA() && drawContext->isStencilBufferMultisampled();
 
             bool fillInverted = false;
             // enabled at bottom of loop
             clip.disableStencilClip();
 
             // This will be used to determine whether the clip shape can be rendered into the
             // stencil with arbitrary stencil settings.
             GrPathRenderer::StencilSupport stencilSupport;
@@ skipping 113 matching lines @@
                         args.fClip = &clip;
                         args.fViewMatrix = &viewMatrix;
                         args.fShape = &shape;
                         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.
-                    SkRect bounds = SkRect::Make(clipSpaceIBounds);
+                    SkRect bounds = SkRect::Make(reducedClip.iBounds());
                     bounds.offset(translate.fX, translate.fY);
                     clip.enableStencilClip(bounds);
                     drawContext->drawContextPriv().stencilRect(clip, *pass, false, viewMatrix,
-                                                               SkRect::Make(clipSpaceIBounds));
+                                                               SkRect::Make(reducedClip.iBounds()));
                 }
             }
         }
     }
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texProvider,
-                                                         int32_t elementsGenID,
-                                                         GrReducedClip::InitialState initialState,
-                                                         const GrReducedClip::ElementList& elements,
-                                                         const SkVector& clipToMaskOffset,
-                                                         const SkIRect& clipSpaceIBounds) {
+                                                         const GrReducedClip& reducedClip,
+                                                         const SkVector& clipToMaskOffset) {
     GrUniqueKey key;
-    GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
+    GetClipMaskKey(reducedClip.genID(), reducedClip.iBounds(), &key);
     if (GrTexture* texture = texProvider->findAndRefTextureByUniqueKey(key)) {
         return sk_sp<GrTexture>(texture);
     }
 
     // The mask texture may be larger than necessary. We round out the clip space bounds and pin
     // the top left corner of the resulting rect to the top left of the texture.
-    SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
+    SkIRect maskSpaceIBounds = SkIRect::MakeWH(reducedClip.width(), reducedClip.height());
 
     GrSWMaskHelper helper(texProvider);
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     SkMatrix translate;
     translate.setTranslate(clipToMaskOffset);
 
     helper.init(maskSpaceIBounds, &translate);
-    helper.clear(GrReducedClip::kAllIn_InitialState == initialState ? 0xFF : 0x00);
+    helper.clear(GrReducedClip::InitialState::kAllIn == reducedClip.initialState() ? 0xFF : 0x00);
 
-    for (GrReducedClip::ElementList::Iter iter(elements.headIter()) ; iter.get(); iter.next()) {
+    for (ElementList::Iter iter(reducedClip.elements()); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
 
         if (SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             // Intersect and reverse difference require modifying pixels outside of the geometry
             // that is being "drawn". In both cases we erase all the pixels outside of the geometry
             // but leave the pixels inside the geometry alone. For reverse difference we invert all
             // the pixels before clearing the ones outside the geometry.
             if (SkRegion::kReverseDifference_Op == op) {
-                SkRect temp = SkRect::Make(clipSpaceIBounds);
+                SkRect temp = SkRect::Make(reducedClip.iBounds());
                 // invert the entire scene
                 helper.drawRect(temp, SkRegion::kXOR_Op, false, 0xFF);
             }
             SkPath clipPath;
             element->asPath(&clipPath);
             clipPath.toggleInverseFillType();
             GrShape shape(clipPath, GrStyle::SimpleFill());
             helper.drawShape(shape, SkRegion::kReplace_Op, element->isAA(), 0x00);
             continue;
         }
 
         // The other ops (union, xor, diff) only affect pixels inside
         // the geometry so they can just be drawn normally
         if (Element::kRect_Type == element->getType()) {
             helper.drawRect(element->getRect(), op, element->isAA(), 0xFF);
         } else {
             SkPath path;
             element->asPath(&path);
             GrShape shape(path, GrStyle::SimpleFill());
             helper.drawShape(shape, op, element->isAA(), 0xFF);
         }
     }
 
     // Allocate clip mask texture
     GrSurfaceDesc desc;
-    desc.fWidth = clipSpaceIBounds.width();
-    desc.fHeight = clipSpaceIBounds.height();
+    desc.fWidth = reducedClip.width();
+    desc.fHeight = reducedClip.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
     return result;
 }