Replace uses of GrAssert by SkASSERT.

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
@@ skipping 660 matching lines @@
     class AutoMatrix : GrNoncopyable {
     public:
         AutoMatrix() : fContext(NULL) {}
 
         ~AutoMatrix() { this->restore(); }
 
         /**
          * Initializes by pre-concat'ing the context's current matrix with the preConcat param.
          */
         void setPreConcat(GrContext* context, const SkMatrix& preConcat, GrPaint* paint = NULL) {
-            GrAssert(NULL != context);
+            SkASSERT(NULL != context);
 
             this->restore();
 
             fContext = context;
             fMatrix = context->getMatrix();
             this->preConcat(preConcat, paint);
         }
 
         /**
          * Sets the context's matrix to identity. Returns false if the inverse matrix is required to
          * update a paint but the matrix cannot be inverted.
          */
         bool setIdentity(GrContext* context, GrPaint* paint = NULL) {
-            GrAssert(NULL != context);
+            SkASSERT(NULL != context);
 
             this->restore();
 
             if (NULL != paint) {
                 if (!paint->localCoordChangeInverse(context->getMatrix())) {
                     return false;
                 }
             }
             fMatrix = context->getMatrix();
             fContext = context;
@@ skipping 59 matching lines @@
     public:
         // This enum exists to require a caller of the constructor to acknowledge that the clip will
         // initially be wide open. It also could be extended if there are other desirable initial
         // clip states.
         enum InitialClip {
             kWideOpen_InitialClip,
         };
 
         AutoClip(GrContext* context, InitialClip initialState)
         : fContext(context) {
-            GrAssert(kWideOpen_InitialClip == initialState);
+            SkASSERT(kWideOpen_InitialClip == initialState);
             fNewClipData.fClipStack = &fNewClipStack;
 
             fOldClip = context->getClip();
             context->setClip(&fNewClipData);
         }
 
         AutoClip(GrContext* context, const SkRect& newClipRect)
         : fContext(context)
         , fNewClipStack(newClipRect) {
             fNewClipData.fClipStack = &fNewClipStack;
@@ skipping 15 matching lines @@
         GrClipData        fNewClipData;
     };
 
     class AutoWideOpenIdentityDraw {
     public:
         AutoWideOpenIdentityDraw(GrContext* ctx, GrRenderTarget* rt)
             : fAutoClip(ctx, AutoClip::kWideOpen_InitialClip)
             , fAutoRT(ctx, rt) {
             fAutoMatrix.setIdentity(ctx);
             // should never fail with no paint param.
-            GrAssert(fAutoMatrix.succeeded());
+            SkASSERT(fAutoMatrix.succeeded());
         }
 
     private:
         AutoClip fAutoClip;
         AutoRenderTarget fAutoRT;
         AutoMatrix fAutoMatrix;
     };
 
     ///////////////////////////////////////////////////////////////////////////
     // Functions intended for internal use only.
@@ skipping 158 matching lines @@
         if (NULL == fTexture) {
             return NULL;
         }
         GrTexture* texture = fTexture;
         fTexture = NULL;
 
         // This GrAutoScratchTexture has a ref from lockAndRefScratchTexture, which we give up now.
         // The cache also has a ref which we are lending to the caller of detach(). When the caller
         // lets go of the ref and the ref count goes to 0 internal_dispose will see this flag is
         // set and re-ref the texture, thereby restoring the cache's ref.
-        GrAssert(texture->getRefCnt() > 1);
+        SkASSERT(texture->getRefCnt() > 1);
         texture->setFlag((GrTextureFlags) GrTexture::kReturnToCache_FlagBit);
         texture->unref();
-        GrAssert(NULL != texture->getCacheEntry());
+        SkASSERT(NULL != texture->getCacheEntry());
 
         return texture;
     }
 
     GrTexture* set(GrContext* context,
                    const GrTextureDesc& desc,
                    GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch) {
         this->reset();
 
         fContext = context;
         if (NULL != fContext) {
             fTexture = fContext->lockAndRefScratchTexture(desc, match);
             if (NULL == fTexture) {
                 fContext = NULL;
             }
             return fTexture;
         } else {
             return NULL;
         }
     }
 
     GrTexture* texture() { return fTexture; }
 
 private:
     GrContext*                    fContext;
     GrTexture*                    fTexture;
 };
 
 #endif