Remove GrStencilSettings from GrPipeline

src/gpu/GrPipeline.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPipeline.h"
 
 #include "GrCaps.h"
 #include "GrRenderTargetContext.h"
 #include "GrGpu.h"
 #include "GrPipelineBuilder.h"
 #include "GrProcOptInfo.h"
 #include "GrRenderTargetOpList.h"
 #include "GrRenderTargetPriv.h"
 #include "GrXferProcessor.h"
 
 #include "batches/GrBatch.h"
 
 GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
                                  GrXPOverridesForBatch* overrides) {
     const GrPipelineBuilder& builder = *args.fPipelineBuilder;
+    const GrUserStencilSettings* userStencil = builder.getUserStencil();
+    GrRenderTarget* rt = args.fRenderTargetContext->accessRenderTarget();
 
     GrPipeline* pipeline = new (memory) GrPipeline;
-    GrRenderTarget* rt = args.fRenderTargetContext->accessRenderTarget();
     pipeline->fRenderTarget.reset(rt);
     SkASSERT(pipeline->fRenderTarget);
     pipeline->fScissorState = *args.fScissor;
     pipeline->fWindowRectsState = *args.fWindowRectsState;
-    if (builder.hasUserStencilSettings() || args.fHasStencilClip) {
-        const GrRenderTargetPriv& rtPriv = rt->renderTargetPriv();
-        pipeline->fStencilSettings.reset(*builder.getUserStencil(), args.fHasStencilClip,
-                                         rtPriv.numStencilBits());
-        SkASSERT(!pipeline->fStencilSettings.usesWrapOp() || args.fCaps->stencilWrapOpsSupport());
-    }
+    pipeline->fUserStencilSettings = userStencil;
     pipeline->fDrawFace = builder.getDrawFace();
 
     pipeline->fFlags = 0;
     if (builder.isHWAntialias()) {
         pipeline->fFlags |= kHWAA_Flag;
     }
     if (builder.snapVerticesToPixelCenters()) {
         pipeline->fFlags |= kSnapVertices_Flag;
     }
     if (builder.getDisableOutputConversionToSRGB()) {
         pipeline->fFlags |= kDisableOutputConversionToSRGB_Flag;
     }
     if (builder.getAllowSRGBInputs()) {
         pipeline->fFlags |= kAllowSRGBInputs_Flag;
     }
     if (builder.getUsesDistanceVectorField()) {
         pipeline->fFlags |= kUsesDistanceVectorField_Flag;
     }
     if (args.fHasStencilClip) {
         pipeline->fFlags |= kHasStencilClip_Flag;
     }
+    if (!userStencil->isDisabled(args.fHasStencilClip)) {
+        pipeline->fFlags |= kStencilEnabled_Flag;
+    }
 
     // Create XferProcessor from DS's XPFactory
     bool hasMixedSamples = args.fRenderTargetContext->hasMixedSamples() &&
-                           (builder.isHWAntialias() || !pipeline->fStencilSettings.isDisabled());
+                           (builder.isHWAntialias() || pipeline->isStencilEnabled());
     const GrXPFactory* xpFactory = builder.getXPFactory();
     SkAutoTUnref<GrXferProcessor> xferProcessor;
     if (xpFactory) {
         xferProcessor.reset(xpFactory->createXferProcessor(args.fOpts,
                                                            hasMixedSamples,
                                                            &args.fDstTexture,
                                                            *args.fCaps));
         if (!xferProcessor) {
             pipeline->~GrPipeline();
             return nullptr;
         }
     } else {
         // This may return nullptr in the common case of src-over implemented using hw blending.
         xferProcessor.reset(GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
                                                                         *args.fCaps,
                                                                         args.fOpts,
                                                                         hasMixedSamples,
                                                                         &args.fDstTexture));
     }
     GrColor overrideColor = GrColor_ILLEGAL;
     if (args.fOpts.fColorPOI.firstEffectiveProcessorIndex() != 0) {
         overrideColor = args.fOpts.fColorPOI.inputColorToFirstEffectiveProccesor();
     }
 
     GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
 
     const GrXferProcessor* xpForOpts = xferProcessor ? xferProcessor.get() :
                                                        &GrPorterDuffXPFactory::SimpleSrcOverXP();
     optFlags = xpForOpts->getOptimizations(args.fOpts,
-                                           pipeline->fStencilSettings.doesWrite(),
+                                           userStencil->doesWrite(args.fHasStencilClip),
                                            &overrideColor,
                                            *args.fCaps);
 
     // When path rendering the stencil settings are not always set on the GrPipelineBuilder
     // so we must check the draw type. In cases where we will skip drawing we simply return a
     // null GrPipeline.
     if (GrXferProcessor::kSkipDraw_OptFlag & optFlags) {
         pipeline->~GrPipeline();
         return nullptr;
     }
@@ skipping 117 matching lines @@
 
 bool GrPipeline::AreEqual(const GrPipeline& a, const GrPipeline& b) {
     SkASSERT(&a != &b);
 
     if (a.getRenderTarget() != b.getRenderTarget() ||
         a.fFragmentProcessors.count() != b.fFragmentProcessors.count() ||
         a.fNumColorProcessors != b.fNumColorProcessors ||
         a.fScissorState != b.fScissorState ||
         !a.fWindowRectsState.cheapEqualTo(b.fWindowRectsState) ||
         a.fFlags != b.fFlags ||
-        a.fStencilSettings != b.fStencilSettings ||
+        a.fUserStencilSettings != b.fUserStencilSettings ||
         a.fDrawFace != b.fDrawFace ||
         a.fIgnoresCoverage != b.fIgnoresCoverage) {
         return false;
     }
 
     // Most of the time both are nullptr
     if (a.fXferProcessor.get() || b.fXferProcessor.get()) {
         if (!a.getXferProcessor().isEqual(b.getXferProcessor())) {
             return false;
         }
     }
 
     for (int i = 0; i < a.numFragmentProcessors(); i++) {
         if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i))) {
             return false;
         }
     }
     return true;
 }