Change implementation of flush-count based GrGpuResource purging

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.
  */
 
 // Include here to ensure SK_SUPPORT_GPU is set correctly before it is examined.
 #include "SkTypes.h"
 
@@ skipping 1119 matching lines @@
         for (int i = 0; i < kFlushCount; ++i) {
             TestResource* r = new TestResource(context->getGpu());
             GrUniqueKey k;
             make_unique_key<1>(&k, i);
             r->resourcePriv().setUniqueKey(k);
             r->unref();
             cache->notifyFlushOccurred(GrResourceCache::kExternal);
         }
 
         // Send flush notifications to the cache. Each flush should purge the oldest resource.
-        for (int i = 0; i < kFlushCount - 1; ++i) {
-            // The first resource was purged after the last flush in the initial loop, hence the -1.
+        for (int i = 0; i < kFlushCount; ++i) {
+            cache->notifyFlushOccurred(GrResourceCache::kExternal);
             REPORTER_ASSERT(reporter, kFlushCount - i - 1 == cache->getResourceCount());
             for (int j = 0; j < i; ++j) {
                 GrUniqueKey k;
                 make_unique_key<1>(&k, j);
                 GrGpuResource* r = cache->findAndRefUniqueResource(k);
                 REPORTER_ASSERT(reporter, !SkToBool(r));
                 SkSafeUnref(r);
             }
-            cache->notifyFlushOccurred(GrResourceCache::kExternal);
         }
 
         REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
         cache->purgeAllUnlocked();
     }
 
     // Do a similar test but where we leave refs on some resources to prevent them from being
     // purged.
     {
         GrGpuResource* refedResources[kFlushCount >> 1];
         for (int i = 0; i < kFlushCount; ++i) {
             TestResource* r = new TestResource(context->getGpu());
             GrUniqueKey k;
             make_unique_key<1>(&k, i);
             r->resourcePriv().setUniqueKey(k);
             // Leave a ref on every other resource, beginning with the first.
             if (SkToBool(i & 0x1)) {
                 refedResources[i/2] = r;
             } else {
                 r->unref();
             }
             cache->notifyFlushOccurred(GrResourceCache::kExternal);
         }
 
         for (int i = 0; i < kFlushCount; ++i) {
             // Should get a resource purged every other flush.
+            cache->notifyFlushOccurred(GrResourceCache::kExternal);
             REPORTER_ASSERT(reporter, kFlushCount - i/2 - 1 == cache->getResourceCount());
-            cache->notifyFlushOccurred(GrResourceCache::kExternal);
         }
 
         // Unref all the resources that we kept refs on in the first loop.
         for (int i = 0; i < kFlushCount >> 1; ++i) {
             refedResources[i]->unref();
         }
 
-        // When we unref'ed them their timestamps got updated. So nothing should be purged until we
-        // get kFlushCount additional flushes. Then everything should be purged.
-        for (int i = 0; i < kFlushCount; ++i) {
+        // After kFlushCount + 1 flushes they all will have sat in the purgeable queue for
+        // kFlushCount full flushes.
+        for (int i = 0; i < kFlushCount + 1; ++i) {
             REPORTER_ASSERT(reporter, kFlushCount >> 1 == cache->getResourceCount());
             cache->notifyFlushOccurred(GrResourceCache::kExternal);
         }
         REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
 
         cache->purgeAllUnlocked();
     }
 
     REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
 
@@ skipping 129 matching lines @@
     test_cache_chained_purge(reporter);
     test_resource_size_changed(reporter);
     test_timestamp_wrap(reporter);
     test_flush(reporter);
     test_large_resource_count(reporter);
     test_custom_data(reporter);
     test_abandoned(reporter);
 }
 
 #endif