Replace uses of GrAssert by SkASSERT.

src/gpu/GrTHashCache.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 90 matching lines @@
             low = index + 1;
         } else {
             high = index;
         }
     }
 
     // check if we found it
     if (Key::EQ(*array[high], key)) {
         // above search should have found the first occurrence if there
         // are multiple.
-        GrAssert(0 == high || Key::LT(*array[high - 1], key));
+        SkASSERT(0 == high || Key::LT(*array[high - 1], key));
         return high;
     }
 
     // now return the ~ of where we should insert it
     if (Key::LT(*array[high], key)) {
         high += 1;
     }
     return ~high;
 }
 
@@ skipping 18 matching lines @@
     // bsearch for the key in our sorted array
     int index = this->searchArray(key);
     if (index < 0) {
         return NULL;
     }
 
     const T* const* array = fSorted.begin();
 
     // above search should have found the first occurrence if there
     // are multiple.
-    GrAssert(0 == index || Key::LT(*array[index - 1], key));
+    SkASSERT(0 == index || Key::LT(*array[index - 1], key));
 
     for ( ; index < count() && Key::EQ(*array[index], key); ++index) {
         if (findFunc(fSorted[index])) {
             // update the hash
             fHash[hashIndex] = fSorted[index];
             return fSorted[index];
         }
     }
 
     return NULL;
@@ skipping 16 matching lines @@
 
 template <typename T, typename Key, size_t kHashBits>
 void GrTHashTable<T, Key, kHashBits>::remove(const Key& key, const T* elem) {
     int index = hash2Index(key.getHash());
     if (fHash[index] == elem) {
         fHash[index] = NULL;
     }
 
     // remove from our sorted array
     index = this->searchArray(key);
-    GrAssert(index >= 0);
+    SkASSERT(index >= 0);
     // if there are multiple matches searchArray will give us the first match
     // march forward until we find elem.
     while (elem != fSorted[index]) {
         ++index;
-        GrAssert(index < fSorted.count());
+        SkASSERT(index < fSorted.count());
     }
-    GrAssert(elem == fSorted[index]);
+    SkASSERT(elem == fSorted[index]);
     fSorted.remove(index);
 }
 
 template <typename T, typename Key, size_t kHashBits>
 T* GrTHashTable<T, Key, kHashBits>::removeAt(int elemIndex, uint32_t hash) {
     int hashIndex = hash2Index(hash);
     if (fHash[hashIndex] == fSorted[elemIndex]) {
         fHash[hashIndex] = NULL;
     }
     // remove from our sorted array
@@ skipping 18 matching lines @@
 void GrTHashTable<T, Key, kHashBits>::unrefAll() {
     fSorted.unrefAll();
     Gr_bzero(fHash, sizeof(fHash));
 }
 
 #if GR_DEBUG
 template <typename T, typename Key, size_t kHashBits>
 void GrTHashTable<T, Key, kHashBits>::validate() const {
     int count = fSorted.count();
     for (int i = 1; i < count; i++) {
-        GrAssert(Key::LT(*fSorted[i - 1], *fSorted[i]) ||
+        SkASSERT(Key::LT(*fSorted[i - 1], *fSorted[i]) ||
                  Key::EQ(*fSorted[i - 1], *fSorted[i]));
     }
 }
 
 template <typename T, typename Key, size_t kHashBits>
 bool GrTHashTable<T, Key, kHashBits>::contains(T* elem) const {
     int index = fSorted.find(elem);
     return index >= 0;
 }
 
 #endif
 
 #endif