Replace uses of GrAssert by SkASSERT.

src/gpu/GrAllocator.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.
  */
 
 
 
@@ skipping 17 matching lines @@
      * @param   itemsPerBlock   the number of items to allocate at once
      * @param   initialBlock    optional memory to use for the first block.
      *                          Must be at least itemSize*itemsPerBlock sized.
      *                          Caller is responsible for freeing this memory.
      */
     GrAllocator(size_t itemSize, int itemsPerBlock, void* initialBlock) :
             fItemSize(itemSize),
             fItemsPerBlock(itemsPerBlock),
             fOwnFirstBlock(NULL == initialBlock),
             fCount(0) {
-        GrAssert(itemsPerBlock > 0);
+        SkASSERT(itemsPerBlock > 0);
         fBlockSize = fItemSize * fItemsPerBlock;
         fBlocks.push_back() = initialBlock;
         GR_DEBUGCODE(if (!fOwnFirstBlock) {*((char*)initialBlock+fBlockSize-1)='a';} );
     }
 
     /**
      * Adds an item and returns pointer to it.
      *
      * @return pointer to the added item.
      */
@@ skipping 39 matching lines @@
 
     /**
      * is the count 0
      */
     bool empty() const { return fCount == 0; }
 
     /**
      * access last item, only call if count() != 0
      */
     void* back() {
-        GrAssert(fCount);
+        SkASSERT(fCount);
         return (*this)[fCount-1];
     }
 
     /**
      * access last item, only call if count() != 0
      */
     const void* back() const {
-        GrAssert(fCount);
+        SkASSERT(fCount);
         return (*this)[fCount-1];
     }
 
     /**
      * access item by index.
      */
     void* operator[] (int i) {
-        GrAssert(i >= 0 && i < fCount);
+        SkASSERT(i >= 0 && i < fCount);
         return (char*)fBlocks[i / fItemsPerBlock] +
                fItemSize * (i % fItemsPerBlock);
     }
 
     /**
      * access item by index.
      */
     const void* operator[] (int i) const {
-        GrAssert(i >= 0 && i < fCount);
+        SkASSERT(i >= 0 && i < fCount);
         return (const char*)fBlocks[i / fItemsPerBlock] +
                fItemSize * (i % fItemsPerBlock);
     }
 
 private:
     static const int NUM_INIT_BLOCK_PTRS = 8;
 
     SkSTArray<NUM_INIT_BLOCK_PTRS, void*>   fBlocks;
     size_t                                  fBlockSize;
     size_t                                  fItemSize;
@@ skipping 21 matching lines @@
     explicit GrTAllocator(int itemsPerBlock)
         : fAllocator(sizeof(T), itemsPerBlock, NULL) {}
 
     /**
      * Adds an item and returns it.
      *
      * @return the added item.
      */
     T& push_back() {
         void* item = fAllocator.push_back();
-        GrAssert(NULL != item);
+        SkASSERT(NULL != item);
         SkNEW_PLACEMENT(item, T);
         return *(T*)item;
     }
 
     T& push_back(const T& t) {
         void* item = fAllocator.push_back();
-        GrAssert(NULL != item);
+        SkASSERT(NULL != item);
         SkNEW_PLACEMENT_ARGS(item, T, (t));
         return *(T*)item;
     }
 
     /**
      * removes all added items
      */
     void reset() {
         int c = fAllocator.count();
         for (int i = 0; i < c; ++i) {
@@ skipping 58 matching lines @@
 
 public:
     GrSTAllocator() : INHERITED(N, fStorage.get()) {
     }
 
 private:
     SkAlignedSTStorage<N, T> fStorage;
 };
 
 #endif