One SkTSearch to rule them all. Allow key to be of different type than the array.

src/core/SkBitmapHeap.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapHeap.h"
 
@@ skipping 20 matching lines @@
         // will be the only one able to modify it, so it does not
         // need to be an atomic operation.
         fRefCount = count;
     } else {
         sk_atomic_add(&fRefCount, count);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-int SkBitmapHeap::LookupEntry::Compare(const SkBitmapHeap::LookupEntry *a,
-                                       const SkBitmapHeap::LookupEntry *b) {
-    if (a->fGenerationId < b->fGenerationId) {
-        return -1;
-    } else if (a->fGenerationId > b->fGenerationId) {
-        return 1;
-    } else if (a->fPixelOffset < b->fPixelOffset) {
-        return -1;
-    } else if (a->fPixelOffset > b->fPixelOffset) {
-        return 1;
-    } else if (a->fWidth < b->fWidth) {
-        return -1;
-    } else if (a->fWidth > b->fWidth) {
-        return 1;
-    } else if (a->fHeight < b->fHeight) {
-        return -1;
-    } else if (a->fHeight > b->fHeight) {
-        return 1;
+bool SkBitmapHeap::LookupEntry::Less(const SkBitmapHeap::LookupEntry& a,
+                                     const SkBitmapHeap::LookupEntry& b) {
+    if (a.fGenerationId < b.fGenerationId) {
+        return true;
+    } else if (a.fGenerationId > b.fGenerationId) {
+        return false;
+    } else if (a.fPixelOffset < b.fPixelOffset) {
+        return true;
+    } else if (a.fPixelOffset > b.fPixelOffset) {
+        return false;
+    } else if (a.fWidth < b.fWidth) {
+        return true;
+    } else if (a.fWidth > b.fWidth) {
+        return false;
+    } else if (a.fHeight < b.fHeight) {
+        return true;
     }
-    return 0;
+    return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBitmapHeap::SkBitmapHeap(int32_t preferredSize, int32_t ownerCount)
     : INHERITED()
     , fExternalStorage(NULL)
     , fMostRecentlyUsed(NULL)
     , fLeastRecentlyUsed(NULL)
     , fPreferredCount(preferredSize)
@@ skipping 153 matching lines @@
             SkASSERT(0 == fBytesAllocated);
         } else {
             fLeastRecentlyUsed->fLessRecentlyUsed = NULL;
         }
     }
 
     return origBytesAllocated - fBytesAllocated;
 }
 
 int SkBitmapHeap::findInLookupTable(const LookupEntry& indexEntry, SkBitmapHeapEntry** entry) {
-    int index = SkTSearch<const LookupEntry>((const LookupEntry**)fLookupTable.begin(),
+    int index = SkTSearch<const LookupEntry, LookupEntry::Less>(
+                                             (const LookupEntry**)fLookupTable.begin(),
                                              fLookupTable.count(),
-                                             &indexEntry, sizeof(void*), LookupEntry::Compare);
+                                             &indexEntry, sizeof(void*));
 
     if (index < 0) {
         // insert ourselves into the bitmapIndex
         index = ~index;
         *fLookupTable.insert(index) = SkNEW_ARGS(LookupEntry, (indexEntry));
     } else if (entry != NULL) {
         // populate the entry if needed
         *entry = fStorage[fLookupTable[index]->fStorageSlot];
     }
 
@@ skipping 147 matching lines @@
         for (int i = 0; i < fDeferredEntries.count(); i++) {
             SkASSERT(fOwnerCount != IGNORE_OWNERS);
             SkBitmapHeapEntry* heapEntry = this->getEntry(fDeferredEntries[i]);
             SkASSERT(heapEntry != NULL);
             heapEntry->addReferences(fOwnerCount);
         }
     }
     fDeferAddingOwners = false;
     fDeferredEntries.reset();
 }