diff --git a/bench/FontCacheBench.cpp b/bench/FontCacheBench.cpp
index 697bde6..0e75c9c 100644
--- a/bench/FontCacheBench.cpp
+++ b/bench/FontCacheBench.cpp
@@ -7,7 +7,6 @@
 
 #include "Benchmark.h"
 #include "SkCanvas.h"
-#include "SkChecksum.h"
 #include "SkFontHost.h"
 #include "SkPaint.h"
 #include "SkString.h"
@@ -65,12 +64,23 @@
     return value ^ (value >> 8);
 }
 
+static uint32_t hasher2(uint32_t h) {
+    h ^= h >> 16;
+    h *= 0x85ebca6b;
+    h ^= h >> 13;
+    h *= 0xc2b2ae35;
+    h ^= h >> 16;
+
+    h ^= (h >> 8);
+    return h;
+}
+
 static const struct {
     const char* fName;
     HasherProc  fHasher;
 } gRec[] = {
     { "hasher0",  hasher0 },
-    { "hasher2",  SkChecksum::Mix },
+    { "hasher2",  hasher2 },
 };
 
 #define kMaxHashBits   12
diff --git a/src/core/SkChecksum.h b/src/core/SkChecksum.h
index fe1e958..bf3228f 100644
--- a/src/core/SkChecksum.h
+++ b/src/core/SkChecksum.h
@@ -36,20 +36,6 @@
     }
 
 public:
-    /**
-     * uint32_t -> uint32_t hash, useful for when you're about to trucate this hash but you
-     * suspect its low bits aren't well mixed.
-     *
-     * This is the Murmur3 finalizer.
-     */
-    static uint32_t Mix(uint32_t hash) {
-        hash ^= hash >> 16;
-        hash *= 0x85ebca6b;
-        hash ^= hash >> 13;
-        hash *= 0xc2b2ae35;
-        hash ^= hash >> 16;
-        return hash;
-    }
 
     /**
      * Calculate 32-bit Murmur hash (murmur3).
@@ -62,7 +48,7 @@
      *  @return hash result
      */
     static uint32_t Murmur3(const uint32_t* data, size_t bytes, uint32_t seed=0) {
-        SkASSERTF(SkIsAlign4(bytes), "Expected 4-byte multiple, got %zu", bytes);
+        SkASSERT(SkIsAlign4(bytes));
         const size_t words = bytes/4;
 
         uint32_t hash = seed;
@@ -78,7 +64,12 @@
             hash += 0xe6546b64;
         }
         hash ^= bytes;
-        return Mix(hash);
+        hash ^= hash >> 16;
+        hash *= 0x85ebca6b;
+        hash ^= hash >> 13;
+        hash *= 0xc2b2ae35;
+        hash ^= hash >> 16;
+        return hash;
     }
 
     /**
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index 8a0e734..64603b4 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -8,7 +8,6 @@
 #include "SkImageFilter.h"
 
 #include "SkBitmap.h"
-#include "SkChecksum.h"
 #include "SkDevice.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ -335,6 +334,31 @@
 }
 #endif
 
+static uint32_t compute_hash(const uint32_t* data, int count) {
+    uint32_t hash = 0;
+
+    for (int i = 0; i < count; ++i) {
+        uint32_t k = data[i];
+        k *= 0xcc9e2d51;
+        k = (k << 15) | (k >> 17);
+        k *= 0x1b873593;
+
+        hash ^= k;
+        hash = (hash << 13) | (hash >> 19);
+        hash *= 5;
+        hash += 0xe6546b64;
+    }
+
+    //    hash ^= size;
+    hash ^= hash >> 16;
+    hash *= 0x85ebca6b;
+    hash ^= hash >> 13;
+    hash *= 0xc2b2ae35;
+    hash ^= hash >> 16;
+
+    return hash;
+}
+
 class CacheImpl : public SkImageFilter::Cache {
 public:
     explicit CacheImpl(int minChildren) : fMinChildren(minChildren) {
@@ -357,7 +381,7 @@
             return v.fKey;
         }
         static uint32_t Hash(Key key) {
-            return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&key), sizeof(Key));
+            return compute_hash(reinterpret_cast<const uint32_t*>(&key), sizeof(Key) / sizeof(uint32_t));
         }
     };
     SkTDynamicHash<Value, Key> fData;
diff --git a/src/core/SkScaledImageCache.cpp b/src/core/SkScaledImageCache.cpp
index 1e7f51d..eda4871 100644
--- a/src/core/SkScaledImageCache.cpp
+++ b/src/core/SkScaledImageCache.cpp
@@ -5,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-#include "SkChecksum.h"
 #include "SkScaledImageCache.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
@@ -30,6 +29,32 @@
     return reinterpret_cast<SkScaledImageCache::Rec*>(id);
 }
 
+ // Implemented from en.wikipedia.org/wiki/MurmurHash.
+static uint32_t compute_hash(const uint32_t data[], int count) {
+    uint32_t hash = 0;
+
+    for (int i = 0; i < count; ++i) {
+        uint32_t k = data[i];
+        k *= 0xcc9e2d51;
+        k = (k << 15) | (k >> 17);
+        k *= 0x1b873593;
+
+        hash ^= k;
+        hash = (hash << 13) | (hash >> 19);
+        hash *= 5;
+        hash += 0xe6546b64;
+    }
+
+    //    hash ^= size;
+    hash ^= hash >> 16;
+    hash *= 0x85ebca6b;
+    hash ^= hash >> 13;
+    hash *= 0xc2b2ae35;
+    hash ^= hash >> 16;
+
+    return hash;
+}
+
 struct SkScaledImageCache::Key {
     Key(uint32_t genID,
         SkScalar scaleX,
@@ -39,7 +64,7 @@
         , fScaleX(scaleX)
         , fScaleY(scaleY)
         , fBounds(bounds) {
-        fHash = SkChecksum::Murmur3(&fGenID, 28);
+        fHash = compute_hash(&fGenID, 7);
     }
 
     bool operator<(const Key& other) const {