Revert of Slim Skia down to just one murmur3 implementation.

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageFilter.h"
 
 #include "SkBitmap.h"
-#include "SkChecksum.h"
 #include "SkDevice.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkRect.h"
 #include "SkTDynamicHash.h"
 #include "SkValidationUtils.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "SkGrPixelRef.h"
 #include "SkGr.h"
@@ skipping 306 matching lines @@
                 GrUnlockAndUnrefCachedBitmapTexture(resultTex);
             }
             return true;
         } else {
             return false;
         }
     }
 }
 #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) {
         SkASSERT(fMinChildren <= 2);
     }
 
     virtual ~CacheImpl();
     bool get(const SkImageFilter* key, SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
     void set(const SkImageFilter* key, const SkBitmap& result, const SkIPoint& offset) SK_OVERRIDE;
     void remove(const SkImageFilter* key) SK_OVERRIDE;
 private:
     typedef const SkImageFilter* Key;
     struct Value {
         Value(Key key, const SkBitmap& bitmap, const SkIPoint& offset)
             : fKey(key), fBitmap(bitmap), fOffset(offset) {}
         Key fKey;
         SkBitmap fBitmap;
         SkIPoint fOffset;
         static const Key& GetKey(const Value& v) {
             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;
     int fMinChildren;
 };
 
 bool CacheImpl::get(const SkImageFilter* key, SkBitmap* result, SkIPoint* offset) {
     Value* v = fData.find(key);
     if (v) {
         *result = v->fBitmap;
@@ skipping 26 matching lines @@
 
 CacheImpl::~CacheImpl() {
     SkTDynamicHash<Value, Key>::Iter iter(&fData);
 
     while (!iter.done()) {
         Value* v = &*iter;
         ++iter;
         delete v;
     }
 }