Style Change: SkNEW->new; SkDELETE->delete

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 243 matching lines @@
     TestResource(GrGpu* gpu)
         : INHERITED(gpu, kCached_LifeCycle)
         , fToDelete(NULL)
         , fSize(kDefaultSize)
         , fProperty(kA_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     static TestResource* CreateScratch(GrGpu* gpu, SimulatedProperty property, bool cached = true) {
-        return SkNEW_ARGS(TestResource, (gpu, property, cached, kScratchConstructor));
+        return new TestResource(gpu, property, cached, kScratchConstructor);
     }
 
     ~TestResource() {
         --fNumAlive;
         SkSafeUnref(fToDelete);
     }
 
     void setSize(size_t size) {
         fSize = size;
         this->didChangeGpuMemorySize();
@@ skipping 60 matching lines @@
 private:
     SkAutoTUnref<GrContext> fContext;
 };
 
 static void test_no_key(skiatest::Reporter* reporter) {
     Mock mock(10, 30000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
     // Create a bunch of resources with no keys
-    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
-    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
-    TestResource* c = SkNEW_ARGS(TestResource, (context->getGpu()));
-    TestResource* d = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* a = new TestResource(context->getGpu());
+    TestResource* b = new TestResource(context->getGpu());
+    TestResource* c = new TestResource(context->getGpu());
+    TestResource* d = new TestResource(context->getGpu());
     a->setSize(11);
     b->setSize(12);
     c->setSize(13);
     d->setSize(14);
 
     REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
     REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() +
                               d->gpuMemorySize() == cache->getResourceBytes());
 
@@ skipping 38 matching lines @@
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
     GrUniqueKey uniqueKey;
     make_unique_key<0>(&uniqueKey, 0);
 
     // Create a scratch, a unique, and a wrapped resource
     TestResource* scratch =
             TestResource::CreateScratch(context->getGpu(), TestResource::kB_SimulatedProperty);
     scratch->setSize(10);
-    TestResource* unique = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* unique = new TestResource(context->getGpu());
     unique->setSize(11);
     unique->resourcePriv().setUniqueKey(uniqueKey);
-    TestResource* wrapped = SkNEW_ARGS(TestResource,
-                                       (context->getGpu(), GrGpuResource::kBorrowed_LifeCycle));
+    TestResource* wrapped = new TestResource(context->getGpu(), GrGpuResource::kBorrowed_LifeCycle);
     wrapped->setSize(12);
-    TestResource* unbudgeted = SkNEW_ARGS(TestResource,
-                                          (context->getGpu(), GrGpuResource::kUncached_LifeCycle));
+    TestResource* unbudgeted =
+            new TestResource(context->getGpu(), GrGpuResource::kUncached_LifeCycle);
     unbudgeted->setSize(13);
 
     // Make sure we can't add a unique key to the wrapped resource
     GrUniqueKey uniqueKey2;
     make_unique_key<0>(&uniqueKey2, 1);
     wrapped->resourcePriv().setUniqueKey(uniqueKey2);
     REPORTER_ASSERT(reporter, NULL == cache->findAndRefUniqueResource(uniqueKey2));
 
     // Make sure sizes are as we expect
     REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
@@ skipping 14 matching lines @@
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() ==
                               cache->getBudgetedResourceBytes());
 
     // Unreffing the wrapped resource should free it right away.
     wrapped->unref();
     REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
                               unbudgeted->gpuMemorySize() == cache->getResourceBytes());
 
     // Now try freeing the budgeted resources first
-    wrapped = SkNEW_ARGS(TestResource, (context->getGpu(), GrGpuResource::kBorrowed_LifeCycle));
+    wrapped = new TestResource(context->getGpu(), GrGpuResource::kBorrowed_LifeCycle);
     scratch->setSize(12);
     unique->unref();
     cache->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + wrapped->gpuMemorySize() +
                               unbudgeted->gpuMemorySize() == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() == cache->getBudgetedResourceBytes());
 
     scratch->unref();
@@ skipping 32 matching lines @@
 
     // A large uncached or wrapped resource shouldn't evict anything.
     scratch = TestResource::CreateScratch(context->getGpu(), TestResource::kB_SimulatedProperty);
     scratch->setSize(10);
     scratch->unref();
     REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 10 == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 10 == cache->getBudgetedResourceBytes());
 
-    unique = SkNEW_ARGS(TestResource, (context->getGpu()));
+    unique = new TestResource(context->getGpu());
     unique->setSize(11);
     unique->resourcePriv().setUniqueKey(uniqueKey);
     unique->unref();
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
 
     size_t large = 2 * cache->getResourceBytes();
-    unbudgeted = SkNEW_ARGS(TestResource,
-                            (context->getGpu(), large, GrGpuResource::kUncached_LifeCycle));
+    unbudgeted = new TestResource(context->getGpu(), large, GrGpuResource::kUncached_LifeCycle);
     REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
 
     unbudgeted->unref();
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
 
-    wrapped = SkNEW_ARGS(TestResource,
-                         (context->getGpu(), large, GrGpuResource::kBorrowed_LifeCycle));
+    wrapped = new TestResource(context->getGpu(), large, GrGpuResource::kBorrowed_LifeCycle);
     REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
 
     wrapped->unref();
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
@@ skipping 231 matching lines @@
 
 static void test_duplicate_unique_key(skiatest::Reporter* reporter) {
     Mock mock(5, 30000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
     GrUniqueKey key;
     make_unique_key<0>(&key, 0);
     
     // Create two resources that we will attempt to register with the same unique key.
-    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* a = new TestResource(context->getGpu());
     a->setSize(11);
     
     // Set key on resource a.
     a->resourcePriv().setUniqueKey(key);
     REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
     a->unref();
 
     // Make sure that redundantly setting a's key works.
     a->resourcePriv().setUniqueKey(key);
     REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
     a->unref();
     REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
 
     // Create resource b and set the same key. It should replace a's unique key cache entry.
-    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* b = new TestResource(context->getGpu());
     b->setSize(12);
     b->resourcePriv().setUniqueKey(key);
     REPORTER_ASSERT(reporter, b == cache->findAndRefUniqueResource(key));
     b->unref();
 
     // Still have two resources because a is still reffed.
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
     a->unref();
     // Now a should be gone.
     REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
 
     // Now replace b with c, but make sure c can start with one unique key and change it to b's key.
     // Also make b be unreffed when replacement occurs.
     b->unref();
-    TestResource* c = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* c = new TestResource(context->getGpu());
     GrUniqueKey differentKey;
     make_unique_key<0>(&differentKey, 1);
     c->setSize(13);
     c->resourcePriv().setUniqueKey(differentKey);
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, b->gpuMemorySize() + c->gpuMemorySize() == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
     // c replaces b and b should be immediately purged.
     c->resourcePriv().setUniqueKey(key);
     REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
@@ skipping 16 matching lines @@
     REPORTER_ASSERT(reporter, c == cache->findAndRefUniqueResource(key));
     c->resourcePriv().removeUniqueKey();
     c->unref();
     REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
 
     {
         GrUniqueKey key2;
         make_unique_key<0>(&key2, 0);
-        SkAutoTUnref<TestResource> d(SkNEW_ARGS(TestResource, (context->getGpu())));
+        SkAutoTUnref<TestResource> d(new TestResource(context->getGpu()));
         int foo = 4132;
         SkAutoTUnref<SkData> data(SkData::NewWithCopy(&foo, sizeof(foo)));
         key2.setCustomData(data.get());
         d->resourcePriv().setUniqueKey(key2);
     }
 
     GrUniqueKey key3;
     make_unique_key<0>(&key3, 0);
     SkAutoTUnref<GrGpuResource> d2(cache->findAndRefUniqueResource(key3));
     REPORTER_ASSERT(reporter, *(int*) d2->getUniqueKey().getCustomData()->data() == 4132);
 }
 
 static void test_purge_invalidated(skiatest::Reporter* reporter) {
     Mock mock(5, 30000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
     GrUniqueKey key1, key2, key3;
     make_unique_key<0>(&key1, 1);
     make_unique_key<0>(&key2, 2);
     make_unique_key<0>(&key3, 3);
     
     // Add three resources to the cache. Only c is usable as scratch.
-    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
-    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* a = new TestResource(context->getGpu());
+    TestResource* b = new TestResource(context->getGpu());
     TestResource* c = TestResource::CreateScratch(context->getGpu(),
                                                   TestResource::kA_SimulatedProperty);
     a->resourcePriv().setUniqueKey(key1);
     b->resourcePriv().setUniqueKey(key2);
     c->resourcePriv().setUniqueKey(key3);
     a->unref();
     // hold b until *after* the message is sent.
     c->unref();
 
     REPORTER_ASSERT(reporter, cache->hasUniqueKey(key1));
@@ skipping 44 matching lines @@
 
 static void test_cache_chained_purge(skiatest::Reporter* reporter) {
     Mock mock(3, 30000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
     GrUniqueKey key1, key2;
     make_unique_key<0>(&key1, 1);
     make_unique_key<0>(&key2, 2);
 
-
-    TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
-    TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+    TestResource* a = new TestResource(context->getGpu());
+    TestResource* b = new TestResource(context->getGpu());
     a->resourcePriv().setUniqueKey(key1);
     b->resourcePriv().setUniqueKey(key2);
 
     // Make a cycle
     a->setUnrefWhenDestroyed(b);
     b->setUnrefWhenDestroyed(a);
 
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
     a->unref();
@@ skipping 16 matching lines @@
     GrUniqueKey key1, key2;
     make_unique_key<0>(&key1, 1);
     make_unique_key<0>(&key2, 2);
 
     // Test changing resources sizes (both increase & decrease).
     {
         Mock mock(3, 30000);
         GrContext* context = mock.context();
         GrResourceCache* cache = mock.cache();
 
-        TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
+        TestResource* a = new TestResource(context->getGpu());
         a->resourcePriv().setUniqueKey(key1);
         a->unref();
 
-        TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+        TestResource* b = new TestResource(context->getGpu());
         b->resourcePriv().setUniqueKey(key2);
         b->unref();
 
         REPORTER_ASSERT(reporter, 200 == cache->getResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
         {
             SkAutoTUnref<TestResource> find2(
                 static_cast<TestResource*>(cache->findAndRefUniqueResource(key2)));
             find2->setSize(200);
             SkAutoTUnref<TestResource> find1(
                 static_cast<TestResource*>(cache->findAndRefUniqueResource(key1)));
             find1->setSize(50);
         }
 
         REPORTER_ASSERT(reporter, 250 == cache->getResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     }
 
     // Test increasing a resources size beyond the cache budget.
     {
         Mock mock(2, 300);
         GrContext* context = mock.context();
         GrResourceCache* cache = mock.cache();
 
-        TestResource* a = SkNEW_ARGS(TestResource, (context->getGpu()));
+        TestResource* a = new TestResource(context->getGpu());
         a->setSize(100);
         a->resourcePriv().setUniqueKey(key1);
         a->unref();
 
-        TestResource* b = SkNEW_ARGS(TestResource, (context->getGpu()));
+        TestResource* b = new TestResource(context->getGpu());
         b->setSize(100);
         b->resourcePriv().setUniqueKey(key2);
         b->unref();
 
         REPORTER_ASSERT(reporter, 200 == cache->getResourceBytes());
         REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
 
         {
             SkAutoTUnref<TestResource> find2(static_cast<TestResource*>(
                 cache->findAndRefUniqueResource(key2)));
@@ skipping 28 matching lines @@
         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()));
+            TestResource* r = new 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;
@@ skipping 28 matching lines @@
     GrResourceCache* cache = mock.cache();
 
     // The current cache impl will round the max flush count to the next power of 2. So we choose a
     // power of two here to keep things simpler.
     static const int kFlushCount = 16;
     cache->setLimits(1000000, 1000000, kFlushCount);
 
     {
         // Insert a resource and send a flush notification kFlushCount times.
         for (int i = 0; i < kFlushCount; ++i) {
-            TestResource* r = SkNEW_ARGS(TestResource, (context->getGpu()));
+            TestResource* r = new TestResource(context->getGpu());
             GrUniqueKey k;
             make_unique_key<1>(&k, i);
             r->resourcePriv().setUniqueKey(k);
             r->unref();
             cache->notifyFlushOccurred();
         }
 
         // 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.
@@ skipping 10 matching lines @@
 
         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 = SkNEW_ARGS(TestResource, (context->getGpu()));
+            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();
@@ skipping 34 matching lines @@
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
 
     for (int i = 0; i < kResourceCnt; ++i) {
         GrUniqueKey key1, key2;
         make_unique_key<1>(&key1, i);
         make_unique_key<2>(&key2, i);
 
         TestResource* resource;
 
-        resource = SkNEW_ARGS(TestResource, (context->getGpu()));
+        resource = new TestResource(context->getGpu());
         resource->resourcePriv().setUniqueKey(key1);
         resource->setSize(1);
         resource->unref();
 
-        resource = SkNEW_ARGS(TestResource, (context->getGpu()));
+        resource = new TestResource(context->getGpu());
         resource->resourcePriv().setUniqueKey(key2);
         resource->setSize(1);
         resource->unref();
     }
 
     REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache->getResourceBytes() == 2 * kResourceCnt);
     REPORTER_ASSERT(reporter, cache->getResourceCount() == 2 * kResourceCnt);
@@ skipping 74 matching lines @@
     test_purge_invalidated(reporter);
     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);
 }
 
 #endif