Use constexpr constructors of GrStencilSettings rather than hacky macro system

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 657 matching lines @@
             if (Element::kRect_Type != element->getType() && !pr) {
                 // UseSWOnlyPath should now filter out all cases where gpu-side mask merging would
                 // be performed (i.e., pr would be NULL for a non-rect path).
                 // See https://bug.skia.org/4519 for rationale and details.
                 SkASSERT(0);
             }
 #endif
 
             // draw directly into the result with the stencil set to make the pixels affected
             // by the clip shape be non-zero.
-            GR_STATIC_CONST_SAME_STENCIL(kStencilInElement,
-                                         kReplace_StencilOp,
-                                         kReplace_StencilOp,
-                                         kAlways_StencilFunc,
-                                         0xffff,
-                                         0xffff,
-                                         0xffff)
+            static constexpr GrStencilSettings kStencilInElement(
+                 kReplace_StencilOp,
+                 kReplace_StencilOp,
+                 kAlways_StencilFunc,
+                 0xffff,
+                 0xffff,
+                 0xffff);
             if (!stencil_element(dc.get(), &maskSpaceIBounds, kStencilInElement,
                                  translate, element)) {
                 texture->resourcePriv().removeUniqueKey();
                 return nullptr;
             }
 
             // Draw to the exterior pixels (those with a zero stencil value).
-            GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
-                                         kZero_StencilOp,
-                                         kZero_StencilOp,
-                                         kEqual_StencilFunc,
-                                         0xffff,
-                                         0x0000,
-                                         0xffff);
+            static constexpr GrStencilSettings kDrawOutsideElement(
+                 kZero_StencilOp,
+                 kZero_StencilOp,
+                 kEqual_StencilFunc,
+                 0xffff,
+                 0x0000,
+                 0xffff);
             if (!dc->drawContextPriv().drawAndStencilRect(&maskSpaceIBounds, kDrawOutsideElement,
                                                           op, !invert, false,
                                                           translate,
                                                           SkRect::Make(clipSpaceIBounds))) {
                 texture->resourcePriv().removeUniqueKey();
                 return nullptr;
             }
         } else {
             // all the remaining ops can just be directly draw into the accumulation buffer
             GrPaint paint;
@@ skipping 114 matching lines @@
                                       // stencil bit used for clipping.
             canDrawDirectToClip = GrStencilSettings::GetClipPasses(op,
                                                                    canRenderDirectToStencil,
                                                                    clipBit,
                                                                    fillInverted,
                                                                    &passes,
                                                                    stencilSettings);
 
             // draw the element to the client stencil bits if necessary
             if (!canDrawDirectToClip) {
-                GR_STATIC_CONST_SAME_STENCIL(gDrawToStencil,
-                                             kIncClamp_StencilOp,
-                                             kIncClamp_StencilOp,
-                                             kAlways_StencilFunc,
-                                             0xffff,
-                                             0x0000,
-                                             0xffff);
+                static constexpr GrStencilSettings kDrawToStencil(
+                     kIncClamp_StencilOp,
+                     kIncClamp_StencilOp,
+                     kAlways_StencilFunc,
+                     0xffff,
+                     0x0000,
+                     0xffff);
                 if (Element::kRect_Type == element->getType()) {
-                    *pipelineBuilder.stencil() = gDrawToStencil;
+                    *pipelineBuilder.stencil() = kDrawToStencil;
 
                     draw_non_aa_rect(fDrawTarget, pipelineBuilder, GrColor_WHITE, viewMatrix,
                                      element->getRect());
                 } else {
                     if (!clipPath.isEmpty()) {
                         if (canRenderDirectToStencil) {
-                            *pipelineBuilder.stencil() = gDrawToStencil;
+                            *pipelineBuilder.stencil() = kDrawToStencil;
 
                             GrPathRenderer::DrawPathArgs args;
                             args.fTarget = fDrawTarget;
                             args.fResourceProvider = this->getContext()->resourceProvider();
                             args.fPipelineBuilder = &pipelineBuilder;
                             args.fColor = GrColor_WHITE;
                             args.fViewMatrix = &viewMatrix;
                             args.fPath = &clipPath;
                             args.fStroke = &stroke;
                             args.fAntiAlias = false;
@@ skipping 45 matching lines @@
             }
         }
     }
     fClipMode = kRespectClip_StencilClipMode;
     return true;
 }
 
 // mapping of clip-respecting stencil funcs to normal stencil funcs
 // mapping depends on whether stencil-clipping is in effect.
 static const GrStencilFunc
-    gSpecialToBasicStencilFunc[2][kClipStencilFuncCount] = {
+    gSpecialToBasicStencilFunc[2][kClipStencilFuncCnt] = {
     {// Stencil-Clipping is DISABLED,  we are effectively always inside the clip
         // In the Clip Funcs
         kAlways_StencilFunc,          // kAlwaysIfInClip_StencilFunc
         kEqual_StencilFunc,           // kEqualIfInClip_StencilFunc
         kLess_StencilFunc,            // kLessIfInClip_StencilFunc
         kLEqual_StencilFunc,          // kLEqualIfInClip_StencilFunc
         // Special in the clip func that forces user's ref to be 0.
         kNotEqual_StencilFunc,        // kNonZeroIfInClip_StencilFunc
                                       // make ref 0 and do normal nequal.
     },
@@ skipping 12 matching lines @@
                                       // the clip bit to the mask and
                                       // ref and compare as normal
         // Special in the clip func that forces user's ref to be 0.
         kLess_StencilFunc,            // kNonZeroIfInClip_StencilFunc
                                       // make ref have only the clip bit set
                                       // and make comparison be less
                                       // 10..0 < 1..user_bits..
     }
 };
 
-namespace {
-// Sets the settings to clip against the stencil buffer clip while ignoring the
-// client bits.
-const GrStencilSettings& basic_apply_stencil_clip_settings() {
-    // stencil settings to use when clip is in stencil
-    GR_STATIC_CONST_SAME_STENCIL_STRUCT(gSettings,
-        kKeep_StencilOp,
-        kKeep_StencilOp,
-        kAlwaysIfInClip_StencilFunc,
-        0x0000,
-        0x0000,
-        0x0000);
-    return *GR_CONST_STENCIL_SETTINGS_PTR_FROM_STRUCT_PTR(&gSettings);
-}
-}
-
 void GrClipMaskManager::setPipelineBuilderStencil(const GrPipelineBuilder& pipelineBuilder,
                                                   GrPipelineBuilder::AutoRestoreStencil* ars) {
     // We make two copies of the StencilSettings here (except in the early
     // exit scenario. One copy from draw state to the stack var. Then another
     // from the stack var to the gpu. We could make this class hold a ptr to
     // GrGpu's fStencilSettings and eliminate the stack copy here.
 
     // use stencil for clipping if clipping is enabled and the clip
     // has been written into the stencil.
     GrStencilSettings settings;
 
     // The GrGpu client may not be using the stencil buffer but we may need to
     // enable it in order to respect a stencil clip.
     if (pipelineBuilder.getStencil().isDisabled()) {
         if (GrClipMaskManager::kRespectClip_StencilClipMode == fClipMode) {
-            settings = basic_apply_stencil_clip_settings();
+            static constexpr GrStencilSettings kBasicApplyClipSettings(
+                kKeep_StencilOp,
+                kKeep_StencilOp,
+                kAlwaysIfInClip_StencilFunc,
+                0x0000,
+                0x0000,
+                0x0000);
+            settings = kBasicApplyClipSettings;
         } else {
             return;
         }
     } else {
         settings = pipelineBuilder.getStencil();
     }
 
     int stencilBits = 0;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
     GrStencilAttachment* stencilAttachment = this->resourceProvider()->attachStencilAttachment(rt);
@@ skipping 25 matching lines @@
     GrStencilSettings::Face face = GrStencilSettings::kFront_Face;
     bool twoSided = this->caps()->twoSidedStencilSupport();
 
     bool finished = false;
     while (!finished) {
         GrStencilFunc func = settings->func(face);
         uint16_t writeMask = settings->writeMask(face);
         uint16_t funcMask = settings->funcMask(face);
         uint16_t funcRef = settings->funcRef(face);
 
-        SkASSERT((unsigned) func < kStencilFuncCount);
+        SkASSERT((unsigned) func < kStencilFuncCnt);
 
         writeMask &= userBits;
 
-        if (func >= kBasicStencilFuncCount) {
+        if (func >= kBasicStencilFuncCnt) {
             int respectClip = kRespectClip_StencilClipMode == mode;
             if (respectClip) {
                 switch (func) {
                     case kAlwaysIfInClip_StencilFunc:
                         funcMask = clipBit;
                         funcRef = clipBit;
                         break;
                     case kEqualIfInClip_StencilFunc:
                     case kLessIfInClip_StencilFunc:
                     case kLEqualIfInClip_StencilFunc:
                         funcMask = (funcMask & userBits) | clipBit;
                         funcRef  = (funcRef  & userBits) | clipBit;
                         break;
                     case kNonZeroIfInClip_StencilFunc:
                         funcMask = (funcMask & userBits) | clipBit;
                         funcRef = clipBit;
                         break;
                     default:
                         SkFAIL("Unknown stencil func");
                 }
             } else {
                 funcMask &= userBits;
                 funcRef &= userBits;
             }
             const GrStencilFunc* table =
                 gSpecialToBasicStencilFunc[respectClip];
-            func = table[func - kBasicStencilFuncCount];
-            SkASSERT(func >= 0 && func < kBasicStencilFuncCount);
+            func = table[func - kBasicStencilFuncCnt];
+            SkASSERT(func >= 0 && func < kBasicStencilFuncCnt);
         } else {
             funcMask &= userBits;
             funcRef &= userBits;
         }
 
         settings->setFunc(face, func);
         settings->setWriteMask(face, writeMask);
         settings->setFuncMask(face, funcMask);
         settings->setFuncRef(face, funcRef);
 
@@ skipping 89 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }