Replace uses of GrAssert by SkASSERT.

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 "GrAAConvexPathRenderer.h"
@@ skipping 17 matching lines @@
 using namespace GrReducedClip;
 
 ////////////////////////////////////////////////////////////////////////////////
 namespace {
 // set up the draw state to enable the aa clipping mask. Besides setting up the
 // stage matrix this also alters the vertex layout
 void setup_drawstate_aaclip(GrGpu* gpu,
                             GrTexture* result,
                             const SkIRect &devBound) {
     GrDrawState* drawState = gpu->drawState();
-    GrAssert(drawState);
+    SkASSERT(drawState);
 
     SkMatrix mat;
     // We want to use device coords to compute the texture coordinates. We set our matrix to be
     // equal to the view matrix followed by an offset to the devBound, and then a scaling matrix to
     // normalized coords. We apply this matrix to the vertex positions rather than local coords.
     mat.setIDiv(result->width(), result->height());
     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
                      SkIntToScalar(-devBound.fTop));
     mat.preConcat(drawState->getViewMatrix());
 
@@ skipping 65 matching lines @@
     ElementList elements(16);
     InitialState initialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA;
     bool isRect = false;
 
     GrDrawState* drawState = fGpu->drawState();
 
     const GrRenderTarget* rt = drawState->getRenderTarget();
     // GrDrawTarget should have filtered this for us
-    GrAssert(NULL != rt);
+    SkASSERT(NULL != rt);
 
     bool ignoreClip = !drawState->isClipState() || clipDataIn->fClipStack->isWideOpen();
 
     if (!ignoreClip) {
         SkIRect clipSpaceRTIBounds = SkIRect::MakeWH(rt->width(), rt->height());
         clipSpaceRTIBounds.offset(clipDataIn->fOrigin);
         ReduceClipStack(*clipDataIn->fClipStack,
                         clipSpaceRTIBounds,
                         &elements,
                         &initialState,
@@ skipping 116 matching lines @@
         case SkRegion::kXOR_Op:
             drawState->setBlendFunc(kIDC_GrBlendCoeff, kISC_GrBlendCoeff);
             break;
         case SkRegion::kDifference_Op:
             drawState->setBlendFunc(kZero_GrBlendCoeff, kISC_GrBlendCoeff);
             break;
         case SkRegion::kReverseDifference_Op:
             drawState->setBlendFunc(kIDC_GrBlendCoeff, kZero_GrBlendCoeff);
             break;
         default:
-            GrAssert(false);
+            SkASSERT(false);
             break;
     }
 }
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 bool GrClipMaskManager::drawElement(GrTexture* target,
                                     const SkClipStack::Element* element,
                                     GrPathRenderer* pr) {
@@ skipping 144 matching lines @@
     *result = fAACache.getLastMask();
     return cached;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 8-bit clip mask in alpha
 GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t clipStackGenID,
                                                   InitialState initialState,
                                                   const ElementList& elements,
                                                   const SkIRect& clipSpaceIBounds) {
-    GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
 
     GrTexture* result;
     if (this->getMaskTexture(clipStackGenID, clipSpaceIBounds, &result)) {
         fCurrClipMaskType = kAlpha_ClipMaskType;
         return result;
     }
 
     if (NULL == result) {
         fAACache.reset();
         return NULL;
@@ skipping 126 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
 bool GrClipMaskManager::createStencilClipMask(InitialState initialState,
                                               const ElementList& elements,
                                               const SkIRect& clipSpaceIBounds,
                                               const SkIPoint& clipSpaceToStencilOffset) {
 
-    GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
 
     GrDrawState* drawState = fGpu->drawState();
-    GrAssert(drawState->isClipState());
+    SkASSERT(drawState->isClipState());
 
     GrRenderTarget* rt = drawState->getRenderTarget();
-    GrAssert(NULL != rt);
+    SkASSERT(NULL != rt);
 
     // TODO: dynamically attach a SB when needed.
     GrStencilBuffer* stencilBuffer = rt->getStencilBuffer();
     if (NULL == stencilBuffer) {
         return false;
     }
     int32_t genID = elements.tail()->getGenID();
 
     if (stencilBuffer->mustRenderClip(genID, clipSpaceIBounds, clipSpaceToStencilOffset)) {
 
@@ skipping 46 matching lines @@
             SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
 
             SkRegion::Op op = element->getOp();
 
             GrPathRenderer* pr = NULL;
             SkTCopyOnFirstWrite<SkPath> clipPath;
             if (Element::kRect_Type == element->getType()) {
                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
                 fillInverted = false;
             } else {
-                GrAssert(Element::kPath_Type == element->getType());
+                SkASSERT(Element::kPath_Type == element->getType());
                 clipPath.init(element->getPath());
                 fillInverted = clipPath->isInverseFillType();
                 if (fillInverted) {
                     clipPath.writable()->toggleInverseFillType();
                 }
                 pr = this->getContext()->getPathRenderer(*clipPath,
                                                          stroke,
                                                          fGpu,
                                                          false,
                                                          GrPathRendererChain::kStencilOnly_DrawType,
@@ skipping 26 matching lines @@
                                              kIncClamp_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 SET_RANDOM_COLOR
                 if (Element::kRect_Type == element->getType()) {
                     *drawState->stencil() = gDrawToStencil;
                     fGpu->drawSimpleRect(element->getRect(), NULL);
                 } else {
-                    GrAssert(Element::kPath_Type == element->getType());
+                    SkASSERT(Element::kPath_Type == element->getType());
                     if (!clipPath->isEmpty()) {
                         if (canRenderDirectToStencil) {
                             *drawState->stencil() = gDrawToStencil;
                             pr->drawPath(*clipPath, stroke, fGpu, false);
                         } else {
                             pr->stencilPath(*clipPath, stroke, fGpu);
                         }
                     }
                 }
             }
 
             // now we modify the clip bit by rendering either the clip
             // element directly or a bounding rect of the entire clip.
             drawState->enableState(GrGpu::kModifyStencilClip_StateBit);
             for (int p = 0; p < passes; ++p) {
                 *drawState->stencil() = stencilSettings[p];
                 if (canDrawDirectToClip) {
                     if (Element::kRect_Type == element->getType()) {
                         SET_RANDOM_COLOR
                         fGpu->drawSimpleRect(element->getRect(), NULL);
                     } else {
-                        GrAssert(Element::kPath_Type == element->getType());
+                        SkASSERT(Element::kPath_Type == element->getType());
                         SET_RANDOM_COLOR
                         pr->drawPath(*clipPath, stroke, fGpu, false);
                     }
                 } else {
                     SET_RANDOM_COLOR
                     // The view matrix is setup to do clip space -> stencil space translation, so
                     // draw rect in clip space.
                     fGpu->drawSimpleRect(SkRect::MakeFromIRect(clipSpaceIBounds), NULL);
                 }
             }
         }
     }
     // set this last because recursive draws may overwrite it back to kNone.
-    GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
     fCurrClipMaskType = kStencil_ClipMaskType;
     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
@@ skipping 51 matching lines @@
     // GrGpu's fStencilSettings and eliminate the stack copy here.
 
     const GrDrawState& drawState = fGpu->getDrawState();
 
     // use stencil for clipping if clipping is enabled and the clip
     // has been written into the stencil.
     GrClipMaskManager::StencilClipMode clipMode;
     if (this->isClipInStencil() && drawState.isClipState()) {
         clipMode = GrClipMaskManager::kRespectClip_StencilClipMode;
         // We can't be modifying the clip and respecting it at the same time.
-        GrAssert(!drawState.isStateFlagEnabled(
+        SkASSERT(!drawState.isStateFlagEnabled(
                     GrGpu::kModifyStencilClip_StateBit));
     } else if (drawState.isStateFlagEnabled(
                     GrGpu::kModifyStencilClip_StateBit)) {
         clipMode = GrClipMaskManager::kModifyClip_StencilClipMode;
     } else {
         clipMode = GrClipMaskManager::kIgnoreClip_StencilClipMode;
     }
 
     GrStencilSettings settings;
     // The GrGpu client may not be using the stencil buffer but we may need to
@@ skipping 10 matching lines @@
     }
 
     // TODO: dynamically attach a stencil buffer
     int stencilBits = 0;
     GrStencilBuffer* stencilBuffer =
         drawState.getRenderTarget()->getStencilBuffer();
     if (NULL != stencilBuffer) {
         stencilBits = stencilBuffer->bits();
     }
 
-    GrAssert(fGpu->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp());
-    GrAssert(fGpu->caps()->twoSidedStencilSupport() || !settings.isTwoSided());
+    SkASSERT(fGpu->caps()->stencilWrapOpsSupport() || !settings.usesWrapOp());
+    SkASSERT(fGpu->caps()->twoSidedStencilSupport() || !settings.isTwoSided());
     this->adjustStencilParams(&settings, clipMode, stencilBits);
     fGpu->setStencilSettings(settings);
 }
 
 void GrClipMaskManager::adjustStencilParams(GrStencilSettings* settings,
                                             StencilClipMode mode,
                                             int stencilBitCnt) {
-    GrAssert(stencilBitCnt > 0);
+    SkASSERT(stencilBitCnt > 0);
 
     if (kModifyClip_StencilClipMode == mode) {
         // We assume that this clip manager itself is drawing to the GrGpu and
         // has already setup the correct values.
         return;
     }
 
     unsigned int clipBit = (1 << (stencilBitCnt - 1));
     unsigned int userBits = clipBit - 1;
 
     GrStencilSettings::Face face = GrStencilSettings::kFront_Face;
     bool twoSided = fGpu->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);
 
-        GrAssert((unsigned) func < kStencilFuncCount);
+        SkASSERT((unsigned) func < kStencilFuncCount);
 
         writeMask &= userBits;
 
         if (func >= kBasicStencilFuncCount) {
             int respectClip = kRespectClip_StencilClipMode == mode;
             if (respectClip) {
                 // The GrGpu class should have checked this
-                GrAssert(this->isClipInStencil());
+                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;
                         break;
                     case kNonZeroIfInClip_StencilFunc:
                         funcMask = (funcMask & userBits) | clipBit;
                         funcRef = clipBit;
                         break;
                     default:
                         GrCrash("Unknown stencil func");
                 }
             } else {
                 funcMask &= userBits;
                 funcRef &= userBits;
             }
             const GrStencilFunc* table =
                 gSpecialToBasicStencilFunc[respectClip];
             func = table[func - kBasicStencilFuncCount];
-            GrAssert(func >= 0 && func < kBasicStencilFuncCount);
+            SkASSERT(func >= 0 && func < kBasicStencilFuncCount);
         } else {
             funcMask &= userBits;
             funcRef &= userBits;
         }
 
         settings->setFunc(face, func);
         settings->setWriteMask(face, writeMask);
         settings->setFuncMask(face, funcMask);
         settings->setFuncRef(face, funcRef);
 
         if (GrStencilSettings::kFront_Face == face) {
             face = GrStencilSettings::kBack_Face;
             finished = !twoSided;
         } else {
             finished = true;
         }
     }
     if (!twoSided) {
         settings->copyFrontSettingsToBack();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrTexture* GrClipMaskManager::createSoftwareClipMask(int32_t clipStackGenID,
                                                      GrReducedClip::InitialState initialState,
                                                      const GrReducedClip::ElementList& elements,
                                                      const SkIRect& clipSpaceIBounds) {
-    GrAssert(kNone_ClipMaskType == fCurrClipMaskType);
+    SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
 
     GrTexture* result;
     if (this->getMaskTexture(clipStackGenID, clipSpaceIBounds, &result)) {
         return result;
     }
 
     if (NULL == result) {
         fAACache.reset();
         return NULL;
     }
@@ skipping 32 matching lines @@
             if (Element::kRect_Type == element->getType()) {
                 // convert the rect to a path so we can invert the fill
                 SkPath temp;
                 temp.addRect(element->getRect());
                 temp.setFillType(SkPath::kInverseEvenOdd_FillType);
 
                 helper.draw(temp, stroke, SkRegion::kReplace_Op,
                             element->isAA(),
                             0x00);
             } else {
-                GrAssert(Element::kPath_Type == element->getType());
+                SkASSERT(Element::kPath_Type == element->getType());
                 SkPath clipPath = element->getPath();
                 clipPath.toggleInverseFillType();
                 helper.draw(clipPath, stroke,
                             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.draw(element->getRect(), op, element->isAA(), 0xFF);
         } else {
-            GrAssert(Element::kPath_Type == element->getType());
+            SkASSERT(Element::kPath_Type == element->getType());
             helper.draw(element->getPath(), stroke, op, element->isAA(), 0xFF);
         }
     }
 
     helper.toTexture(result);
 
     fCurrClipMaskType = kAlpha_ClipMaskType;
     return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void GrClipMaskManager::releaseResources() {
     fAACache.releaseResources();
 }
 
 void GrClipMaskManager::setGpu(GrGpu* gpu) {
     fGpu = gpu;
     fAACache.setContext(gpu->getContext());
 }