Get rid of GrMurmur3Hash

src/gpu/effects/GrTextureStripAtlas.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTextureStripAtlas_DEFINED
 #define GrTextureStripAtlas_DEFINED
 
-#include "GrMurmur3HashKey.h"
 #include "SkBitmap.h"
+#include "SkChecksum.h"
 #include "SkGr.h"
 #include "SkTDArray.h"
 #include "SkTDynamicHash.h"
 #include "SkTypes.h"
 
 /**
  * Maintains a single large texture whose rows store many textures of a small fixed height,
  * stored in rows across the x-axis such that we can safely wrap/repeat them horizontally.
  */
 class GrTextureStripAtlas {
 public:
     /**
      * Descriptor struct which we'll use as a hash table key
      **/
     struct Desc {
-        Desc() { memset(this, 0, sizeof(*this)); }
+        Desc() { sk_bzero(this, sizeof(*this)); }
+        GrContext* fContext;
+        GrPixelConfig fConfig;
         uint16_t fWidth, fHeight, fRowHeight;
-        GrPixelConfig fConfig;
-        GrContext* fContext;
-        const uint32_t* asKey() const { return reinterpret_cast<const uint32_t*>(this); }
+        uint16_t fUnusedPadding;
+        bool operator==(const Desc& other) const {
+            return 0 == memcmp(this, &other, sizeof(Desc));
+        }
     };
 
     /**
      * Try to find an atlas with the required parameters, creates a new one if necessary
      */
     static GrTextureStripAtlas* GetAtlas(const Desc& desc);
 
     ~GrTextureStripAtlas();
 
     /**
@@ skipping 88 matching lines @@
     /**
      * Clean up callback registered with GrContext. Allows this class to
      * free up any allocated AtlasEntry and GrTextureStripAtlas objects
      */
     static void CleanUp(const GrContext* context, void* info);
 
     // Hash table entry for atlases
     class AtlasEntry : public ::SkNoncopyable {
     public:
         // for SkTDynamicHash
-        class Key : public GrMurmur3HashKey<sizeof(GrTextureStripAtlas::Desc)> {};
-        static const Key& GetKey(const AtlasEntry& entry) { return entry.fKey; }
-        static uint32_t Hash(const Key& key) { return key.getHash(); }
+        static const Desc& GetKey(const AtlasEntry& entry) { return entry.fDesc; }
+        static uint32_t Hash(const Desc& desc) { return SkChecksum::Murmur3(&desc, sizeof(Desc)); }
 
         // AtlasEntry proper
         AtlasEntry() : fAtlas(NULL) {}
         ~AtlasEntry() { SkDELETE(fAtlas); }
-        Key fKey;
+        Desc fDesc;
         GrTextureStripAtlas* fAtlas;
     };
 
     class Hash;
     static Hash* gAtlasCache;
 
     static Hash* GetCache();
 
     // We increment gCacheCount for each atlas
     static int32_t gCacheCount;
@@ skipping 19 matching lines @@
     // Head and tail for linked list of least-recently-used rows (front = least recently used).
     // Note that when a texture is locked, it gets removed from this list until it is unlocked.
     AtlasRow* fLRUFront;
     AtlasRow* fLRUBack;
 
     // A list of pointers to AtlasRows that currently contain cached images, sorted by key
     SkTDArray<AtlasRow*> fKeyTable;
 };
 
 #endif