move GrMalloc, GrFree, Gr_bzero to their sk equivalents

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 16 matching lines @@
  *  Key needs
  *      static bool EQ(const Entry&, const HashKey&);
  *      static bool LT(const Entry&, const HashKey&);
  *      uint32_t getHash() const;
  *
  *  Allows duplicate key entries but on find you may get
  *  any of the duplicate entries returned.
  */
 template <typename T, typename Key, size_t kHashBits> class GrTHashTable {
 public:
-    GrTHashTable() { Gr_bzero(fHash, sizeof(fHash)); }
+    GrTHashTable() { sk_bzero(fHash, sizeof(fHash)); }
     ~GrTHashTable() {}
 
     int count() const { return fSorted.count(); }
     T*  find(const Key&) const;
     template <typename FindFuncType> T*  find(const Key&, const FindFuncType&) const;
     // return true if key was unique when inserted.
     bool insert(const Key&, T*);
     void remove(const Key&, const T*);
     T* removeAt(int index, uint32_t hash);
     void removeAll();
@@ skipping 155 matching lines @@
     }
     // remove from our sorted array
     T* elem = fSorted[elemIndex];
     fSorted.remove(elemIndex);
     return elem;
 }
 
 template <typename T, typename Key, size_t kHashBits>
 void GrTHashTable<T, Key, kHashBits>::removeAll() {
     fSorted.reset();
-    Gr_bzero(fHash, sizeof(fHash));
+    sk_bzero(fHash, sizeof(fHash));
 }
 
 template <typename T, typename Key, size_t kHashBits>
 void GrTHashTable<T, Key, kHashBits>::deleteAll() {
     fSorted.deleteAll();
-    Gr_bzero(fHash, sizeof(fHash));
+    sk_bzero(fHash, sizeof(fHash));
 }
 
 template <typename T, typename Key, size_t kHashBits>
 void GrTHashTable<T, Key, kHashBits>::unrefAll() {
     fSorted.unrefAll();
-    Gr_bzero(fHash, sizeof(fHash));
+    sk_bzero(fHash, sizeof(fHash));
 }
 
 #ifdef SK_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++) {
         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