Style Change: NULL->nullptr

src/core/SkTaskGroup.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 "SkOnce.h"
 #include "SkRunnable.h"
 #include "SkSemaphore.h"
@@ skipping 104 matching lines @@
             fThreads.top()->start();
         }
     }
 
     ~ThreadPool() {
         SkASSERT(fWork.isEmpty());  // All SkTaskGroups should be destroyed by now.
 
         // Send a poison pill to each thread.
         SkAtomic<int> dummy(0);
         for (int i = 0; i < fThreads.count(); i++) {
-            this->add(NULL, NULL, &dummy);
+            this->add(nullptr, nullptr, &dummy);
         }
         // Wait for them all to swallow the pill and die.
         for (int i = 0; i < fThreads.count(); i++) {
             fThreads[i]->join();
         }
         SkASSERT(fWork.isEmpty());  // Can't hurt to double check.
         fThreads.deleteAll();
     }
 
     void add(void (*fn)(void*), void* arg, SkAtomic<int32_t>* pending) {
@@ skipping 54 matching lines @@
     // So fWorkAvailable may overcount actual the work available.
     // We make do, but this means some worker threads may wake spuriously.
     SkSemaphore fWorkAvailable;
 
     // These are only changed in a single-threaded context.
     SkTDArray<SkThread*> fThreads;
     static ThreadPool* gGlobal;
 
     friend struct SkTaskGroup::Enabler;
 };
-ThreadPool* ThreadPool::gGlobal = NULL;
+ThreadPool* ThreadPool::gGlobal = nullptr;
 
 }  // namespace
 
 SkTaskGroup::Enabler::Enabler(int threads) {
-    SkASSERT(ThreadPool::gGlobal == NULL);
+    SkASSERT(ThreadPool::gGlobal == nullptr);
     if (threads != 0) {
         ThreadPool::gGlobal = new ThreadPool(threads);
     }
 }
 
 SkTaskGroup::Enabler::~Enabler() { delete ThreadPool::gGlobal; }
 
 SkTaskGroup::SkTaskGroup() : fPending(0) {}
 
 void SkTaskGroup::wait()                            { ThreadPool::Wait(&fPending); }
 void SkTaskGroup::add(SkRunnable* task)             { ThreadPool::Add(task, &fPending); }
 void SkTaskGroup::add(void (*fn)(void*), void* arg) { ThreadPool::Add(fn, arg, &fPending); }
 void SkTaskGroup::batch (void (*fn)(void*), void* args, int N, size_t stride) {
     ThreadPool::Batch(fn, args, N, stride, &fPending);
 }