Remove ClipMaskType from GrCMM

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 "GrDrawContext.h"
@@ skipping 50 matching lines @@
     // last (false) parameter disallows use of the SW path renderer
     GrPathRendererChain::DrawType type = doAA ?
                                          GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
 
     return nullptr == context->getPathRenderer(gpu, &pipelineBuilder, viewMatrix, *path, stroke,
                                             false, type);
 }
 
 GrClipMaskManager::GrClipMaskManager(GrDrawTarget* drawTarget)
-    : fCurrClipMaskType(kNone_ClipMaskType)
-    , fDrawTarget(drawTarget)
+    : fDrawTarget(drawTarget)
     , fClipMode(kIgnoreClip_StencilClipMode) {
 }
 
 GrContext* GrClipMaskManager::getContext() { return fDrawTarget->cmmAccess().context(); }
 
 /*
  * 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.
  */
@@ skipping 119 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
 bool GrClipMaskManager::setupClipping(const GrPipelineBuilder& pipelineBuilder,
                                       GrPipelineBuilder::AutoRestoreStencil* ars,
                                       GrScissorState* scissorState,
                                       const SkRect* devBounds,
                                       GrAppliedClip* out) {
-    fCurrClipMaskType = kNone_ClipMaskType;
     if (kRespectClip_StencilClipMode == fClipMode) {
         fClipMode = kIgnoreClip_StencilClipMode;
     }
 
     GrReducedClip::ElementList elements(16);
     int32_t genID = 0;
     GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA = false;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
@@ skipping 305 matching lines @@
     }
     texture->resourcePriv().setUniqueKey(key);
     return texture;
 }
 
 GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID,
                                                   GrReducedClip::InitialState initialState,
                                                   const GrReducedClip::ElementList& elements,
                                                   const SkVector& clipToMaskOffset,
                                                   const SkIRect& clipSpaceIBounds) {
-    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
     GrResourceProvider* resourceProvider = fDrawTarget->cmmAccess().resourceProvider();
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
-        fCurrClipMaskType = kAlpha_ClipMaskType;
         return texture;
     }
 
     SkAutoTUnref<GrTexture> texture(this->createCachedMask(
         clipSpaceIBounds.width(), clipSpaceIBounds.height(), key, true));
 
     // There's no texture in the cache. Let's try to allocate it then.
     if (!texture) {
         return nullptr;
     }
@@ skipping 117 matching lines @@
         } else {
             GrPipelineBuilder pipelineBuilder;
 
             // all the remaining ops can just be directly draw into the accumulation buffer
             set_coverage_drawing_xpf(op, false, &pipelineBuilder);
             // The color passed in here does not matter since the coverageSetOpXP won't read it.
             this->drawElement(&pipelineBuilder, translate, texture, element);
         }
     }
 
-    fCurrClipMaskType = kAlpha_ClipMaskType;
     return texture.detach();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
 bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt,
                                               int32_t elementsGenID,
                                               GrReducedClip::InitialState initialState,
                                               const GrReducedClip::ElementList& elements,
                                               const SkIRect& clipSpaceIBounds,
                                               const SkIPoint& clipSpaceToStencilOffset) {
-    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
     SkASSERT(rt);
 
     GrStencilAttachment* stencilAttachment =
         fDrawTarget->cmmAccess().resourceProvider()->attachStencilAttachment(rt);
     if (nullptr == stencilAttachment) {
         return false;
     }
 
     if (stencilAttachment->mustRenderClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
         stencilAttachment->setLastClip(elementsGenID, clipSpaceIBounds, clipSpaceToStencilOffset);
@@ skipping 159 matching lines @@
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
                     fDrawTarget->drawNonAARect(pipelineBuilder,
                                                GrColor_WHITE,
                                                viewMatrix,
                                                SkRect::Make(clipSpaceIBounds));
                 }
             }
         }
     }
-    // set this last because recursive draws may overwrite it back to kNone.
-    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
-    fCurrClipMaskType = kStencil_ClipMaskType;
     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] = {
     {// Stencil-Clipping is DISABLED,  we are effectively always inside the clip
         // In the Clip Funcs
@@ skipping 105 matching lines @@
         uint16_t funcMask = settings->funcMask(face);
         uint16_t funcRef = settings->funcRef(face);
 
         SkASSERT((unsigned) func < kStencilFuncCount);
 
         writeMask &= userBits;
 
         if (func >= kBasicStencilFuncCount) {
             int respectClip = kRespectClip_StencilClipMode == mode;
             if (respectClip) {
-                // The GrGpu class should have checked this
-                SkASSERT(this->isClipInStencil());
                 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;
@@ skipping 34 matching lines @@
         settings->copyFrontSettingsToBack();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrTexture* GrClipMaskManager::createSoftwareClipMask(int32_t elementsGenID,
                                                      GrReducedClip::InitialState initialState,
                                                      const GrReducedClip::ElementList& elements,
                                                      const SkVector& clipToMaskOffset,
                                                      const SkIRect& clipSpaceIBounds) {
-    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
     GrResourceProvider* resourceProvider = fDrawTarget->cmmAccess().resourceProvider();
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
         return 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());
@@ skipping 42 matching lines @@
     }
 
     // Allocate clip mask texture
     GrTexture* result = this->createCachedMask(clipSpaceIBounds.width(), clipSpaceIBounds.height(),
                                                key, false);
     if (nullptr == result) {
         return nullptr;
     }
     helper.toTexture(result);
 
-    fCurrClipMaskType = kAlpha_ClipMaskType;
     return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }