Handle the case when the GrResourceCache timestamp wraps.

tests/ResourceCacheTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
@@ skipping 905 matching lines @@
                 cache->findAndRefUniqueResource(key2)));
             find2->setSize(201);
         }
         REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
 
         REPORTER_ASSERT(reporter, 201 == cache->getResourceBytes());
         REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
     }
 }
 
+static void test_timestamp_wrap(skiatest::Reporter* reporter) {
+    enum {
+        kCount = 50,

[robertphillips, 2015/02/19 18:47:33]

reosource -> resources

+        kBudgetCnt = kCount / 2, // half the reosource should get purged.
+        kLockedFreq = 8,
+        kBudgetSize = 0x80000000, // really large, just use the cnt budget
+    };
+
+    SkRandom random;
+
+    // Run the test 2*kCount times;
+    for (int i = 0; i < 2 * kCount; ++i ) {
+        Mock mock(kBudgetCnt, kBudgetSize);
+        GrContext* context = mock.context();
+        GrResourceCache* cache = mock.cache();
+
+        // Pick a random number of resources to add before the timestamp will wrap.
+        cache->changeTimestamp(SK_MaxU32 - random.nextULessThan(kCount + 1));
+
+        enum { kNumToPurge = kCount - kBudgetCnt };
+        SkTDArray<int> shouldPurgeIdxs;
+        int purgeableCnt = 0;
+        SkTDArray<GrGpuResource*> resourcesToUnref;
+
+        // Add kCount resources, holding onto resources at random so we have a mix of purgeable and
+        // unpurgeable resources.
+        for (int j = 0; j < kCount; ++j) {
+            GrUniqueKey key;
+            make_unique_key<0>(&key, j);
+
+            TestResource* r = SkNEW_ARGS(TestResource, (context->getGpu()));
+            r->resourcePriv().setUniqueKey(key);
+            if (random.nextU() % kLockedFreq) {
+                // Make this is purgeable.
+                r->unref();
+                ++purgeableCnt;
+                if (purgeableCnt <= kNumToPurge) {
+                    *shouldPurgeIdxs.append() = j;
+                }
+            } else {
+                *resourcesToUnref.append() = r;
+            }
+        }
+
+        // Verify that the correct resources were purged.
+        int currShouldPurgeIdx = 0;
+        for (int j = 0; j < kCount; ++j) {
+            GrUniqueKey key;
+            make_unique_key<0>(&key, j);
+            GrGpuResource* res = cache->findAndRefUniqueResource(key);
+            if (currShouldPurgeIdx < shouldPurgeIdxs.count() &&
+                shouldPurgeIdxs[currShouldPurgeIdx] == j) {
+                ++currShouldPurgeIdx;
+                REPORTER_ASSERT(reporter, NULL == res);
+            } else {

[robertphillips, 2015/02/19 18:47:33]

Can we assert that the time stamps are less than kCount?

[bsalomon, 2015/02/19 18:52:54]

I'd have to expose access to the time stamp here. Also, I feel like that'd be
testing the particulars of the implementation rather than just correctness (that
the lru purgeable resources are purged).

+                REPORTER_ASSERT(reporter, NULL != res);
+            }
+            SkSafeUnref(res);
+        }
+
+        for (int j = 0; j < resourcesToUnref.count(); ++j) {
+            resourcesToUnref[j]->unref();
+        }
+    }
+}
+
 static void test_large_resource_count(skiatest::Reporter* reporter) {
     // Set the cache size to double the resource count because we're going to create 2x that number
     // resources, using two different key domains. Add a little slop to the bytes because we resize
     // down to 1 byte after creating the resource.
     static const int kResourceCnt = 2000;
 
     Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
@@ skipping 39 matching lines @@
     for (int i = 0; i < kResourceCnt; ++i) {
         GrUniqueKey key1, key2;
         make_unique_key<1>(&key1, i);
         make_unique_key<2>(&key2, i);
 
         REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
         REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key2));
     }
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////
 DEF_GPUTEST(ResourceCache, reporter, factory) {
     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
         GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
         if (!GrContextFactory::IsRenderingGLContext(glType)) {
             continue;
         }
         GrContext* context = factory->get(glType);
         if (NULL == context) {
             continue;
@@ skipping 15 matching lines @@
     test_budgeting(reporter);
     test_unbudgeted(reporter);
     test_unbudgeted_to_scratch(reporter);
     test_duplicate_unique_key(reporter);
     test_duplicate_scratch_key(reporter);
     test_remove_scratch_key(reporter);
     test_scratch_key_consistency(reporter);
     test_purge_invalidated(reporter);
     test_cache_chained_purge(reporter);
     test_resource_size_changed(reporter);
+    test_timestamp_wrap(reporter);
     test_large_resource_count(reporter);
 }
 
 #endif