Style Change: NULL->nullptr

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 20 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 static void test_cache(skiatest::Reporter* reporter, GrContext* context, SkCanvas* canvas) {
     const SkIRect size = SkIRect::MakeWH(gWidth, gHeight);
 
     SkBitmap src;
     src.allocN32Pixels(size.width(), size.height());
     src.eraseColor(SK_ColorBLACK);
     size_t srcSize = src.getSize();
 
     size_t initialCacheSize;
-    context->getResourceCacheUsage(NULL, &initialCacheSize);
+    context->getResourceCacheUsage(nullptr, &initialCacheSize);
 
     int oldMaxNum;
     size_t oldMaxBytes;
     context->getResourceCacheLimits(&oldMaxNum, &oldMaxBytes);
 
     // Set the cache limits so we can fit 10 "src" images and the
     // max number of textures doesn't matter
     size_t maxCacheSize = initialCacheSize + 10*srcSize;
     context->setResourceCacheLimits(1000, maxCacheSize);
 
     SkBitmap readback;
     readback.allocN32Pixels(size.width(), size.height());
 
     for (int i = 0; i < 100; ++i) {
         canvas->drawBitmap(src, 0, 0);
         canvas->readPixels(size, &readback);
 
         // "modify" the src texture
         src.notifyPixelsChanged();
 
         size_t curCacheSize;
-        context->getResourceCacheUsage(NULL, &curCacheSize);
+        context->getResourceCacheUsage(nullptr, &curCacheSize);
 
         // we should never go over the size limit
         REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
     }
 
     context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
 }
 
 static void test_stencil_buffers(skiatest::Reporter* reporter, GrContext* context) {
     GrSurfaceDesc smallDesc;
@@ skipping 104 matching lines @@
     const GrGpu* gpu = context->getGpu();
     // this test is only valid for GL
     if (!gpu || !gpu->glContextForTesting()) {
         return;
     }
 
     GrBackendObject texIDs[2];
     static const int kW = 100;
     static const int kH = 100;
 
-    texIDs[0] = gpu->createTestingOnlyBackendTexture(NULL, kW, kH, kRGBA_8888_GrPixelConfig);
-    texIDs[1] = gpu->createTestingOnlyBackendTexture(NULL, kW, kH, kRGBA_8888_GrPixelConfig);
+    texIDs[0] = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kRGBA_8888_GrPixelConfig);
+    texIDs[1] = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH, kRGBA_8888_GrPixelConfig);
 
     context->resetContext();
 
     GrBackendTextureDesc desc;
     desc.fConfig = kBGRA_8888_GrPixelConfig;
     desc.fWidth = kW;
     desc.fHeight = kH;
 
     desc.fTextureHandle = texIDs[0];
     SkAutoTUnref<GrTexture> borrowed(context->textureProvider()->wrapBackendTexture(
                                      desc, kBorrow_GrWrapOwnership));
 
     desc.fTextureHandle = texIDs[1];
     SkAutoTUnref<GrTexture> adopted(context->textureProvider()->wrapBackendTexture(
                                     desc, kAdopt_GrWrapOwnership));
 
     REPORTER_ASSERT(reporter, SkToBool(borrowed) && SkToBool(adopted));
     if (!SkToBool(borrowed) || !SkToBool(adopted)) {
         return;
     }
 
-    borrowed.reset(NULL);
-    adopted.reset(NULL);
+    borrowed.reset(nullptr);
+    adopted.reset(nullptr);
 
     context->flush();
 
     bool borrowedIsAlive = gpu->isTestingOnlyBackendTexture(texIDs[0]);
     bool adoptedIsAlive = gpu->isTestingOnlyBackendTexture(texIDs[1]);
 
     REPORTER_ASSERT(reporter, borrowedIsAlive);
     REPORTER_ASSERT(reporter, !adoptedIsAlive);
 
     gpu->deleteTestingOnlyBackendTexture(texIDs[0]);
 
     context->resetContext();
 }
 
 class TestResource : public GrGpuResource {
     enum ScratchConstructor { kScratchConstructor };
 public:
     static const size_t kDefaultSize = 100;
     
     /** Property that distinctly categorizes the resource.
      * For example, textures have width, height, ... */
     enum SimulatedProperty { kA_SimulatedProperty, kB_SimulatedProperty };
 
     TestResource(GrGpu* gpu, size_t size, GrGpuResource::LifeCycle lifeCycle)
         : INHERITED(gpu, lifeCycle)
-        , fToDelete(NULL)
+        , fToDelete(nullptr)
         , fSize(size)
         , fProperty(kA_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu, GrGpuResource::LifeCycle lifeCycle)
         : INHERITED(gpu, lifeCycle)
-        , fToDelete(NULL)
+        , fToDelete(nullptr)
         , fSize(kDefaultSize)
         , fProperty(kA_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     TestResource(GrGpu* gpu)
         : INHERITED(gpu, kCached_LifeCycle)
-        , fToDelete(NULL)
+        , fToDelete(nullptr)
         , fSize(kDefaultSize)
         , fProperty(kA_SimulatedProperty) {
         ++fNumAlive;
         this->registerWithCache();
     }
 
     static TestResource* CreateScratch(GrGpu* gpu, SimulatedProperty property, bool cached = true) {
         return new TestResource(gpu, property, cached, kScratchConstructor);
     }
 
@@ skipping 23 matching lines @@
 
     static size_t ExpectedScratchKeySize() {
         return sizeof(uint32_t) * (kScratchKeyFieldCnt + GrScratchKey::kMetaDataCnt);
     }
 
 private:
     static const int kScratchKeyFieldCnt = 6;
 
     TestResource(GrGpu* gpu, SimulatedProperty property, bool cached, ScratchConstructor)
         : INHERITED(gpu, cached ? kCached_LifeCycle : kUncached_LifeCycle)
-        , fToDelete(NULL)
+        , fToDelete(nullptr)
         , fSize(kDefaultSize)
         , fProperty(property) {
         GrScratchKey scratchKey;
         ComputeScratchKey(fProperty, &scratchKey);
         this->setScratchKey(scratchKey);
         ++fNumAlive;
         this->registerWithCache();
     }
 
     size_t onGpuMemorySize() const override { return fSize; }
@@ skipping 99 matching lines @@
     TestResource* wrapped = new TestResource(context->getGpu(), GrGpuResource::kBorrowed_LifeCycle);
     wrapped->setSize(12);
     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));
+    REPORTER_ASSERT(reporter, nullptr == cache->findAndRefUniqueResource(uniqueKey2));
 
     // Make sure sizes are as we expect
     REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
                               wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() ==
                               cache->getResourceBytes());
     REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
     REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() ==
                               cache->getBudgetedResourceBytes());
 
@@ skipping 119 matching lines @@
         TestResource::CreateScratch(context->getGpu(), TestResource::kA_SimulatedProperty, false);
     GrScratchKey key;
     TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &key);
 
     size_t size = resource->gpuMemorySize();
     for (int i = 0; i < 2; ++i) {
         // Since this resource is unbudgeted, it should not be reachable as scratch.
         REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
         REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
         REPORTER_ASSERT(reporter, !resource->resourcePriv().isBudgeted());
-        REPORTER_ASSERT(reporter, NULL == cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
+        REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
         REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
         REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
         REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
         REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
 
         // Once it is unrefed, it should become available as scratch.
         resource->unref();
         REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
         REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
         REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
@@ skipping 37 matching lines @@
     // Create two resources that have the same scratch key.
     TestResource* a = TestResource::CreateScratch(context->getGpu(),
                                                   TestResource::kB_SimulatedProperty);
     TestResource* b = TestResource::CreateScratch(context->getGpu(),
                                                   TestResource::kB_SimulatedProperty);
     a->setSize(11);
     b->setSize(12);
     GrScratchKey scratchKey1;
     TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey1);
     // Check for negative case consistency. (leaks upon test failure.)
-    REPORTER_ASSERT(reporter, NULL == cache->findAndRefScratchResource(scratchKey1, TestResource::kDefaultSize, 0));
+    REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(scratchKey1, TestResource::kDefaultSize, 0));
 
     GrScratchKey scratchKey;
     TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
 
     // Scratch resources are registered with GrResourceCache just by existing. There are 2.
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
     REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() ==
                               cache->getResourceBytes());
@@ skipping 26 matching lines @@
                                                   TestResource::kB_SimulatedProperty);
     TestResource* b = TestResource::CreateScratch(context->getGpu(),
                                                   TestResource::kB_SimulatedProperty);
     a->unref();
     b->unref();
 
     GrScratchKey scratchKey;
     // Ensure that scratch key lookup is correct for negative case.
     TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
     // (following leaks upon test failure).
-    REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == NULL);
+    REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == nullptr);
 
     // Scratch resources are registered with GrResourceCache just by existing. There are 2.
     TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
     SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
     REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
 
     // Find the first resource and remove its scratch key
     GrGpuResource* find;
     find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
@@ skipping 59 matching lines @@
     scratchKey = scratchKey2;
     REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
     REPORTER_ASSERT(reporter, scratchKey1 != scratchKey);
     REPORTER_ASSERT(reporter, scratchKey != scratchKey1);
     REPORTER_ASSERT(reporter, scratchKey2 == scratchKey);
     REPORTER_ASSERT(reporter, scratchKey == scratchKey2);
 
     // Ensure that scratch key lookup is correct for negative case.
     TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
     // (following leaks upon test failure).
-    REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == NULL);
+    REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == nullptr);
 
     // Find the first resource with a scratch key and a copy of a scratch key.
     TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
     GrGpuResource* find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
-    REPORTER_ASSERT(reporter, find != NULL);
+    REPORTER_ASSERT(reporter, find != nullptr);
     find->unref();
 
     scratchKey2 = scratchKey;
     find = cache->findAndRefScratchResource(scratchKey2, TestResource::kDefaultSize, 0);
-    REPORTER_ASSERT(reporter, find != NULL);
+    REPORTER_ASSERT(reporter, find != nullptr);
     REPORTER_ASSERT(reporter, find == a || find == b);
 
     GrGpuResource* find2 = cache->findAndRefScratchResource(scratchKey2, TestResource::kDefaultSize, 0);
-    REPORTER_ASSERT(reporter, find2 != NULL);
+    REPORTER_ASSERT(reporter, find2 != nullptr);
     REPORTER_ASSERT(reporter, find2 == a || find2 == b);
     REPORTER_ASSERT(reporter, find2 != find);
     find2->unref();
     find->unref();
 }
 
 static void test_duplicate_unique_key(skiatest::Reporter* reporter) {
     Mock mock(5, 30000);
     GrContext* context = mock.context();
     GrResourceCache* cache = mock.cache();
@@ skipping 179 matching lines @@
 
     a->unref();
     b->unref();
 
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
     cache->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
     // Break the cycle
-    a->setUnrefWhenDestroyed(NULL);
+    a->setUnrefWhenDestroyed(nullptr);
     REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
 
     cache->purgeAllUnlocked();
     REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
 }
 
 static void test_resource_size_changed(skiatest::Reporter* reporter) {
     GrUniqueKey key1, key2;
     make_unique_key<0>(&key1, 1);
     make_unique_key<0>(&key2, 2);
@@ skipping 103 matching lines @@
 
         // 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);
+                REPORTER_ASSERT(reporter, nullptr == res);
             } else {
-                REPORTER_ASSERT(reporter, NULL != res);
+                REPORTER_ASSERT(reporter, nullptr != res);
             }
             SkSafeUnref(res);
         }
 
         for (int j = 0; j < resourcesToUnref.count(); ++j) {
             resourcesToUnref[j]->unref();
         }
     }
 }
 
@@ skipping 154 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 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) {
+        if (nullptr == context) {
             continue;
         }
         GrSurfaceDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
         desc.fWidth = gWidth;
         desc.fHeight = gHeight;
         SkImageInfo info = SkImageInfo::MakeN32Premul(gWidth, gHeight);
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context,
                                                                    SkSurface::kNo_Budgeted, info));
@@ skipping 14 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