make imagecache's Key more general purpose

src/core/SkScaledImageCache.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkChecksum.h"
 #include "SkScaledImageCache.h"
 #include "SkMipMap.h"
@@ skipping 12 matching lines @@
 #endif
 
 static inline SkScaledImageCache::ID* rec_to_id(SkScaledImageCache::Rec* rec) {
     return reinterpret_cast<SkScaledImageCache::ID*>(rec);
 }
 
 static inline SkScaledImageCache::Rec* id_to_rec(SkScaledImageCache::ID* id) {
     return reinterpret_cast<SkScaledImageCache::Rec*>(id);
 }
 
-struct SkScaledImageCache::Key {
-    Key(uint32_t genID,
-        SkScalar scaleX,
-        SkScalar scaleY,
-        SkIRect  bounds)
-        : fGenID(genID)
-        , fScaleX(scaleX)
-        , fScaleY(scaleY)
-        , fBounds(bounds) {
-        fHash = SkChecksum::Murmur3(&fGenID, 28);
-    }
+void SkScaledImageCache::Key::init(size_t length) {
+    SkASSERT(SkAlign4(length) == length);
+    // 2 is fCount32 and fHash
+    fCount32 = SkToS32(2 + (length >> 2));
+    // skip both of our fields whe computing the murmur
+    fHash = SkChecksum::Murmur3(this->as32() + 2, (fCount32 - 2) << 2);
+}
 
-    bool operator<(const Key& other) const {
-        const uint32_t* a = &fGenID;
-        const uint32_t* b = &other.fGenID;
-        for (int i = 0; i < 7; ++i) {
-            if (a[i] < b[i]) {
-                return true;
-            }
-            if (a[i] > b[i]) {
-                return false;
-            }
-        }
-        return false;
-    }
-
-    bool operator==(const Key& other) const {
-        const uint32_t* a = &fHash;
-        const uint32_t* b = &other.fHash;
-        for (int i = 0; i < 8; ++i) {
-            if (a[i] != b[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    uint32_t    fHash;
-    uint32_t    fGenID;
-    float       fScaleX;
-    float       fScaleY;
-    SkIRect     fBounds;
-};
+SkScaledImageCache::Key* SkScaledImageCache::Key::clone() const {
+    size_t size = fCount32 << 2;
+    void* copy = sk_malloc_throw(size);
+    memcpy(copy, this, size);
+    return (Key*)copy;
+}
 
 struct SkScaledImageCache::Rec {
-    Rec(const Key& key, const SkBitmap& bm) : fKey(key), fBitmap(bm) {
+    Rec(const Key& key, const SkBitmap& bm) : fKey(key.clone()), fBitmap(bm) {
         fLockCount = 1;
         fMip = NULL;
     }
 
-    Rec(const Key& key, const SkMipMap* mip) : fKey(key) {
+    Rec(const Key& key, const SkMipMap* mip) : fKey(key.clone()) {
         fLockCount = 1;
         fMip = mip;
         mip->ref();
     }
 
     ~Rec() {
         SkSafeUnref(fMip);
+        sk_free(fKey);
     }
 
-    static const Key& GetKey(const Rec& rec) { return rec.fKey; }
-    static uint32_t Hash(const Key& key) { return key.fHash; }
+    static const Key& GetKey(const Rec& rec) { return *rec.fKey; }
+    static uint32_t Hash(const Key& key) { return key.hash(); }
 
     size_t bytesUsed() const {
         return fMip ? fMip->getSize() : fBitmap.getSize();
     }
 
     Rec*    fNext;
     Rec*    fPrev;
 
     // this guy wants to be 64bit aligned
-    Key     fKey;
+    Key*    fKey;
 
     int32_t fLockCount;
 
     // we use either fBitmap or fMip, but not both
     SkBitmap fBitmap;
     const SkMipMap* fMip;
 };
 
 #include "SkTDynamicHash.h"
 
@@ skipping 166 matching lines @@
     while (rec) {
         Rec* next = rec->fNext;
         SkDELETE(rec);
         rec = next;
     }
     delete fHash;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+struct GenWHKey : public SkScaledImageCache::Key {
+public:
+    GenWHKey(uint32_t genID, SkScalar scaleX, SkScalar scaleY, const SkIRect& bounds)
+    : fGenID(genID)
+    , fScaleX(scaleX)
+    , fScaleY(scaleY)
+    , fBounds(bounds) {
+        this->init(7 * sizeof(uint32_t));
+    }
+
+    uint32_t    fGenID;
+    SkScalar    fScaleX;
+    SkScalar    fScaleY;
+    SkIRect     fBounds;
+};
 
 SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(uint32_t genID,
                                                         SkScalar scaleX,
                                                         SkScalar scaleY,
                                                         const SkIRect& bounds) {
-    const Key key(genID, scaleX, scaleY, bounds);
-    return this->findAndLock(key);
+    return this->findAndLock(GenWHKey(genID, scaleX, scaleY, bounds));
 }
 
 /**
    This private method is the fully general record finder. All other
    record finders should call this function or the one above. */
 SkScaledImageCache::Rec* SkScaledImageCache::findAndLock(const SkScaledImageCache::Key& key) {
-    if (key.fBounds.isEmpty()) {
-        return NULL;
-    }
 #ifdef USE_HASH
     Rec* rec = fHash->find(key);
 #else
     Rec* rec = find_rec_in_list(fHead, key);
 #endif
     if (rec) {
         this->moveToHead(rec);  // for our LRU
         rec->fLockCount += 1;
     }
     return rec;
@@ skipping 58 matching lines @@
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 /**
    This private method is the fully general record adder. All other
    record adders should call this funtion. */
 SkScaledImageCache::ID* SkScaledImageCache::addAndLock(SkScaledImageCache::Rec* rec) {
     SkASSERT(rec);
     // See if we already have this key (racy inserts, etc.)
-    Rec* existing = this->findAndLock(rec->fKey);
+    Rec* existing = this->findAndLock(*rec->fKey);
     if (NULL != existing) {
         // Since we already have a matching entry, just delete the new one and return.
         // Call sites cannot assume the passed in object will live past this call.
         existing->fBitmap = rec->fBitmap;
         SkDELETE(rec);
         return rec_to_id(existing);
     }
 
     this->addToHead(rec);
     SkASSERT(1 == rec->fLockCount);
 #ifdef USE_HASH
     SkASSERT(fHash);
     fHash->add(rec);
 #endif
     // We may (now) be overbudget, so see if we need to purge something.
     this->purgeAsNeeded();
     return rec_to_id(rec);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::addAndLock(uint32_t genID,
                                                        int32_t width,
                                                        int32_t height,
                                                        const SkBitmap& bitmap) {
-    Key key(genID, SK_Scalar1, SK_Scalar1, SkIRect::MakeWH(width, height));
+    GenWHKey key(genID, SK_Scalar1, SK_Scalar1, SkIRect::MakeWH(width, height));
     Rec* rec = SkNEW_ARGS(Rec, (key, bitmap));
     return this->addAndLock(rec);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::addAndLock(const SkBitmap& orig,
                                                        SkScalar scaleX,
                                                        SkScalar scaleY,
                                                        const SkBitmap& scaled) {
     if (0 == scaleX || 0 == scaleY) {
         // degenerate, and the key we use for mipmaps
         return NULL;
     }
     SkIRect bounds = get_bounds_from_bitmap(orig);
     if (bounds.isEmpty()) {
         return NULL;
     }
-    Key key(orig.getGenerationID(), scaleX, scaleY, bounds);
+    GenWHKey key(orig.getGenerationID(), scaleX, scaleY, bounds);
     Rec* rec = SkNEW_ARGS(Rec, (key, scaled));
     return this->addAndLock(rec);
 }
 
 SkScaledImageCache::ID* SkScaledImageCache::addAndLockMip(const SkBitmap& orig,
                                                           const SkMipMap* mip) {
     SkIRect bounds = get_bounds_from_bitmap(orig);
     if (bounds.isEmpty()) {
         return NULL;
     }
-    Key key(orig.getGenerationID(), 0, 0, bounds);
+    GenWHKey key(orig.getGenerationID(), 0, 0, bounds);
     Rec* rec = SkNEW_ARGS(Rec, (key, mip));
     return this->addAndLock(rec);
 }
 
 void SkScaledImageCache::unlock(SkScaledImageCache::ID* id) {
     SkASSERT(id);
 
 #ifdef SK_DEBUG
     {
         bool found = false;
@@ skipping 39 matching lines @@
         if (bytesUsed < byteLimit && countUsed < countLimit) {
             break;
         }
 
         Rec* prev = rec->fPrev;
         if (0 == rec->fLockCount) {
             size_t used = rec->bytesUsed();
             SkASSERT(used <= bytesUsed);
             this->detach(rec);
 #ifdef USE_HASH
-            fHash->remove(rec->fKey);
+            fHash->remove(*rec->fKey);
 #endif
 
             SkDELETE(rec);
 
             bytesUsed -= used;
             countUsed -= 1;
         }
         rec = prev;
     }
 
@@ skipping 279 matching lines @@
 }
 
 size_t SkGraphics::GetImageCacheSingleAllocationByteLimit() {
     return SkScaledImageCache::GetSingleAllocationByteLimit();
 }
 
 size_t SkGraphics::SetImageCacheSingleAllocationByteLimit(size_t newLimit) {
     return SkScaledImageCache::SetSingleAllocationByteLimit(newLimit);
 }