Switch uses of SkChecksum::Compute to Murmur3.

src/gpu/GrResourceCache.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrResourceCache.h"
@@ skipping 24 matching lines @@
 
     int32_t domain = sk_atomic_inc(&gDomain);
     if (domain > SK_MaxU16) {
         SkFAIL("Too many GrUniqueKey Domains");
     }
 
     return static_cast<Domain>(domain);
 }
 
 uint32_t GrResourceKeyHash(const uint32_t* data, size_t size) {
-    return SkChecksum::Compute(data, size);
+    return SkChecksum::Murmur3(data, size);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GrResourceCache::AutoValidate : ::SkNoncopyable {
 public:
     AutoValidate(GrResourceCache* cache) : fCache(cache) { cache->validate(); }
     ~AutoValidate() { fCache->validate(); }
 private:
     GrResourceCache* fCache;
@@ skipping 501 matching lines @@
                 }
             };
             Less less;
             SkTQSort(fNonpurgeableResources.begin(), fNonpurgeableResources.end() - 1, less);
 
             // Pick resources out of the purgeable and non-purgeable arrays based on lowest
             // timestamp and assign new timestamps.
             int currP = 0;
             int currNP = 0;
             while (currP < sortedPurgeableResources.count() &&
-                   currNP < fNonpurgeableResources.count()) {                
+                   currNP < fNonpurgeableResources.count()) {
                 uint32_t tsP = sortedPurgeableResources[currP]->cacheAccess().timestamp();
                 uint32_t tsNP = fNonpurgeableResources[currNP]->cacheAccess().timestamp();
                 SkASSERT(tsP != tsNP);
                 if (tsP < tsNP) {
                     sortedPurgeableResources[currP++]->cacheAccess().setTimestamp(fTimestamp++);
                 } else {
                     // Correct the index in the nonpurgeable array stored on the resource post-sort.
                     *fNonpurgeableResources[currNP]->cacheAccess().accessCacheIndex() = currNP;
                     fNonpurgeableResources[currNP++]->cacheAccess().setTimestamp(fTimestamp++);
                 }
@@ skipping 11 matching lines @@
             // Rebuild the queue.
             for (int i = 0; i < sortedPurgeableResources.count(); ++i) {
                 fPurgeableQueue.insert(sortedPurgeableResources[i]);
             }
 
             this->validate();
             SkASSERT(count == this->getResourceCount());
 
             // count should be the next timestamp we return.
             SkASSERT(fTimestamp == SkToU32(count));
-            
+
             // The historical timestamps of flushes are now invalid.
             this->resetFlushTimestamps();
-        }        
+        }
     }
     return fTimestamp++;
 }
 
 void GrResourceCache::notifyFlushOccurred() {
     if (fFlushTimestamps) {
         SkASSERT(SkIsPow2(fMaxUnusedFlushes));
         fLastFlushTimestampIndex = (fLastFlushTimestampIndex + 1) & (fMaxUnusedFlushes - 1);
         // get the timestamp before accessing fFlushTimestamps because getNextTimestamp will
         // reallocate fFlushTimestamps on timestamp overflow.
@@ skipping 120 matching lines @@
         return true;
     }
     if (index < fNonpurgeableResources.count() && fNonpurgeableResources[index] == resource) {
         return true;
     }
     SkDEBUGFAIL("Resource index should be -1 or the resource should be in the cache.");
     return false;
 }
 
 #endif