commit f6de475e5cbd143f348ff7738919e397b7fe7f57
author tfarina@chromium.org <tfarina@chromium.org@2bbb7eff-a529-9590-31e7-b0007b416f81> Sat Aug 17 00:02:59 2013 +0000
committer tfarina@chromium.org <tfarina@chromium.org@2bbb7eff-a529-9590-31e7-b0007b416f81> Sat Aug 17 00:02:59 2013 +0000
tree 8d8a123db2adbd7cbe6b55651b1c9117d6eafdb8
parent 069975678aaca6dc767e9fef3d743694443223f1

Replace uses of GrAssert by SkASSERT.

R=bsalomon@google.com

Review URL: https://codereview.chromium.org/22850006

git-svn-id: http://skia.googlecode.com/svn/trunk@10789 2bbb7eff-a529-9590-31e7-b0007b416f81

src/gpu/GrMemoryPool.cpp

diff --git a/src/gpu/GrMemoryPool.cpp b/src/gpu/GrMemoryPool.cpp
index fc777e0..a770792 100644
--- a/src/gpu/GrMemoryPool.cpp
+++ b/src/gpu/GrMemoryPool.cpp
@@ -30,9 +30,9 @@
 
 GrMemoryPool::~GrMemoryPool() {
     VALIDATE;
-    GrAssert(0 == fAllocationCnt);
-    GrAssert(fHead == fTail);
-    GrAssert(0 == fHead->fLiveCount);
+    SkASSERT(0 == fAllocationCnt);
+    SkASSERT(fHead == fTail);
+    SkASSERT(0 == fHead->fLiveCount);
     DeleteBlock(fHead);
 };
 
@@ -47,11 +47,11 @@
 
         block->fPrev = fTail;
         block->fNext = NULL;
-        GrAssert(NULL == fTail->fNext);
+        SkASSERT(NULL == fTail->fNext);
         fTail->fNext = block;
         fTail = block;
     }
-    GrAssert(fTail->fFreeSize >= size);
+    SkASSERT(fTail->fFreeSize >= size);
     intptr_t ptr = fTail->fCurrPtr;
     // We stash a pointer to the block header, just before the allocated space,
     // so that we can decrement the live count on delete in constant time.
@@ -80,12 +80,12 @@
         } else {
             BlockHeader* prev = block->fPrev;
             BlockHeader* next = block->fNext;
-            GrAssert(prev);
+            SkASSERT(prev);
             prev->fNext = next;
             if (next) {
                 next->fPrev = prev;
             } else {
-                GrAssert(fTail == block);
+                SkASSERT(fTail == block);
                 fTail = prev;
             }
             DeleteBlock(block);
@@ -106,7 +106,7 @@
     BlockHeader* block =
         reinterpret_cast<BlockHeader*>(GrMalloc(size + kHeaderSize));
     // we assume malloc gives us aligned memory
-    GrAssert(!(reinterpret_cast<intptr_t>(block) % kAlignment));
+    SkASSERT(!(reinterpret_cast<intptr_t>(block) % kAlignment));
     block->fLiveCount = 0;
     block->fFreeSize = size;
     block->fCurrPtr = reinterpret_cast<intptr_t>(block) + kHeaderSize;
@@ -122,13 +122,13 @@
 #ifdef SK_DEBUG
     BlockHeader* block = fHead;
     BlockHeader* prev = NULL;
-    GrAssert(block);
+    SkASSERT(block);
     int allocCount = 0;
     do {
         allocCount += block->fLiveCount;
-        GrAssert(prev == block->fPrev);
+        SkASSERT(prev == block->fPrev);
         if (NULL != prev) {
-            GrAssert(prev->fNext == block);
+            SkASSERT(prev->fNext == block);
         }
 
         intptr_t b = reinterpret_cast<intptr_t>(block);
@@ -137,25 +137,25 @@
         size_t userSize = totalSize - kHeaderSize;
         intptr_t userStart = b + kHeaderSize;
 
-        GrAssert(!(b % kAlignment));
-        GrAssert(!(totalSize % kAlignment));
-        GrAssert(!(userSize % kAlignment));
-        GrAssert(!(block->fCurrPtr % kAlignment));
+        SkASSERT(!(b % kAlignment));
+        SkASSERT(!(totalSize % kAlignment));
+        SkASSERT(!(userSize % kAlignment));
+        SkASSERT(!(block->fCurrPtr % kAlignment));
         if (fHead != block) {
-            GrAssert(block->fLiveCount);
-            GrAssert(userSize >= fMinAllocSize);
+            SkASSERT(block->fLiveCount);
+            SkASSERT(userSize >= fMinAllocSize);
         } else {
-            GrAssert(userSize == fPreallocSize);
+            SkASSERT(userSize == fPreallocSize);
         }
         if (!block->fLiveCount) {
-            GrAssert(ptrOffset ==  kHeaderSize);
-            GrAssert(userStart == block->fCurrPtr);
+            SkASSERT(ptrOffset ==  kHeaderSize);
+            SkASSERT(userStart == block->fCurrPtr);
         } else {
-            GrAssert(block == *reinterpret_cast<BlockHeader**>(userStart));
+            SkASSERT(block == *reinterpret_cast<BlockHeader**>(userStart));
         }
         prev = block;
     } while ((block = block->fNext));
-    GrAssert(allocCount == fAllocationCnt);
-    GrAssert(prev == fTail);
+    SkASSERT(allocCount == fAllocationCnt);
+    SkASSERT(prev == fTail);
 #endif
 }