Replace uses of GrAssert by SkASSERT.

src/gpu/GrTextStrike.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrGpu.h"
 #include "GrRectanizer.h"
@@ skipping 32 matching lines @@
         fAtlasMgr = SkNEW_ARGS(GrAtlasMgr, (fGpu));
     }
     GrTextStrike* strike = SkNEW_ARGS(GrTextStrike,
                                       (this, scaler->getKey(),
                                        scaler->getMaskFormat(), fAtlasMgr));
     fCache.insert(key, strike);
 
     if (fHead) {
         fHead->fPrev = strike;
     } else {
-        GrAssert(NULL == fTail);
+        SkASSERT(NULL == fTail);
         fTail = strike;
     }
     strike->fPrev = NULL;
     strike->fNext = fHead;
     fHead = strike;
 
     return strike;
 }
 
 void GrFontCache::freeAll() {
@@ skipping 11 matching lines @@
         if (strike == preserveStrike) {
             strike = strike->fPrev;
             continue;
         }
         GrTextStrike* strikeToPurge = strike;
         strike = strikeToPurge->fPrev;
         if (purge) {
             // keep purging if we won't free up any atlases with this strike.
             purge = (NULL == strikeToPurge->fAtlas);
             int index = fCache.slowFindIndex(strikeToPurge);
-            GrAssert(index >= 0);
+            SkASSERT(index >= 0);
             fCache.removeAt(index, strikeToPurge->fFontScalerKey->getHash());
             this->detachStrikeFromList(strikeToPurge);
             delete strikeToPurge;
         }
     }
 #if FONT_CACHE_STATS
     ++g_PurgeCount;
 #endif
 }
 
 void GrFontCache::freeAtlasExceptFor(GrTextStrike* preserveStrike) {
     GrTextStrike* strike = fTail;
     while (strike) {
         if (strike == preserveStrike) {
             strike = strike->fPrev;
             continue;
         }
         GrTextStrike* strikeToPurge = strike;
         strike = strikeToPurge->fPrev;
         if (strikeToPurge->removeUnusedAtlases()) {
             if (NULL == strikeToPurge->fAtlas) {
                 int index = fCache.slowFindIndex(strikeToPurge);
-                GrAssert(index >= 0);
+                SkASSERT(index >= 0);
                 fCache.removeAt(index, strikeToPurge->fFontScalerKey->getHash());
                 this->detachStrikeFromList(strikeToPurge);
                 delete strikeToPurge;
             }
             break;
         }
     }
 }
 
 #if GR_DEBUG
 void GrFontCache::validate() const {
     int count = fCache.count();
     if (0 == count) {
-        GrAssert(!fHead);
-        GrAssert(!fTail);
+        SkASSERT(!fHead);
+        SkASSERT(!fTail);
     } else if (1 == count) {
-        GrAssert(fHead == fTail);
+        SkASSERT(fHead == fTail);
     } else {
-        GrAssert(fHead != fTail);
+        SkASSERT(fHead != fTail);
     }
 
     int count2 = 0;
     const GrTextStrike* strike = fHead;
     while (strike) {
         count2 += 1;
         strike = strike->fNext;
     }
-    GrAssert(count == count2);
+    SkASSERT(count == count2);
 
     count2 = 0;
     strike = fTail;
     while (strike) {
         count2 += 1;
         strike = strike->fPrev;
     }
-    GrAssert(count == count2);
+    SkASSERT(count == count2);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if GR_DEBUG
     static int gCounter;
 #endif
 
 /*
@@ skipping 61 matching lines @@
     return GrAtlas::RemoveUnusedAtlases(fAtlasMgr, &fAtlas);
 }
 
 bool GrTextStrike::getGlyphAtlas(GrGlyph* glyph, GrFontScaler* scaler,
                                  GrDrawTarget::DrawToken currentDrawToken) {
 #if 0   // testing hack to force us to flush our cache often
     static int gCounter;
     if ((++gCounter % 10) == 0) return false;
 #endif
 
-    GrAssert(glyph);
-    GrAssert(scaler);
-    GrAssert(fCache.contains(glyph));
+    SkASSERT(glyph);
+    SkASSERT(scaler);
+    SkASSERT(fCache.contains(glyph));
     if (glyph->fAtlas) {
         glyph->fAtlas->setDrawToken(currentDrawToken);
         return true;
     }
 
     GrAutoRef ar(scaler);
 
     int bytesPerPixel = GrMaskFormatBytesPerPixel(fMaskFormat);
     size_t size = glyph->fBounds.area() * bytesPerPixel;
     SkAutoSMalloc<1024> storage(size);
     if (!scaler->getPackedGlyphImage(glyph->fPackedID, glyph->width(),
                                      glyph->height(),
                                      glyph->width() * bytesPerPixel,
                                      storage.get())) {
         return false;
     }
 
     GrAtlas* atlas = fAtlasMgr->addToAtlas(&fAtlas, glyph->width(),
                                            glyph->height(), storage.get(),
                                            fMaskFormat,
                                            &glyph->fAtlasLocation);
     if (NULL == atlas) {
         return false;
     }
 
     glyph->fAtlas = atlas;
     atlas->setDrawToken(currentDrawToken);
     return true;
 }