make imagecache's Key more general purpose

src/core/SkScaledImageCache.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkScaledImageCache_DEFINED
 #define SkScaledImageCache_DEFINED
 
 #include "SkBitmap.h"
 
 class SkDiscardableMemory;
 class SkMipMap;
 
 /**
  *  Cache object for bitmaps (with possible scale in X Y as part of the key).
  *
  *  Multiple caches can be instantiated, but each instance is not implicitly
  *  thread-safe, so if a given instance is to be shared across threads, the
  *  caller must manage the access itself (e.g. via a mutex).
  *
  *  As a convenience, a global instance is also defined, which can be safely
  *  access across threads via the static methods (e.g. FindAndLock, etc.).
  */
 class SkScaledImageCache {
 public:
     struct ID;
 
+    struct Key {
+        // Call this to access your private contents. Must not use the address after calling init()
+        void* writableContents() { return this + 1; }
+
+        // must call this after your private data has been written.
+        // length must be a multiple of 4
+        void init(size_t length);
+
+        // This is only valid after having called init().
+        uint32_t hash() const { return fHash; }
+
+        bool operator==(const Key& other) const {
+            const uint32_t* a = this->as32();
+            const uint32_t* b = other.as32();
+            for (int i = 0; i < fCount32; ++i) {
+                if (a[i] != b[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // delete using sk_free
+        Key* clone() const;
+
+    private:
+        // store fCount32 first, so we don't consider it in operator<
+        int32_t  fCount32;  // 2 + user contents count32
+        uint32_t fHash;
+        /* uint32_t fContents32[] */
+
+        const uint32_t* as32() const { return (const uint32_t*)this; }
+        const uint32_t* as32SkipCount() const { return this->as32() + 1; }
+    };
+
     /**
      *  Returns a locked/pinned SkDiscardableMemory instance for the specified
      *  number of bytes, or NULL on failure.
      */
     typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
 
     /*
      *  The following static methods are thread-safe wrappers around a global
      *  instance of this cache.
      */
@@ skipping 126 matching lines @@
 
     SkBitmap::Allocator* allocator() const { return fAllocator; };
 
     /**
      *  Call SkDebugf() with diagnostic information about the state of the cache
      */
     void dump() const;
 
 public:
     struct Rec;
-    struct Key;
 private:
     Rec*    fHead;
     Rec*    fTail;
 
     class Hash;
     Hash*   fHash;
 
     DiscardableFactory  fDiscardableFactory;
     // the allocator is NULL or one that matches discardables
     SkBitmap::Allocator* fAllocator;
@@ skipping 18 matching lines @@
 
     void init();    // called by constructors
 
 #ifdef SK_DEBUG
     void validate() const;
 #else
     void validate() const {}
 #endif
 };
 #endif