Convert NULL to nullptr

util/mac/process_reader_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 156 matching lines @@
         EXPECT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "thread_resume");
         --thread_info->suspend_count;
       }
     }
 
     for (ThreadInfo* thread_info : thread_infos_) {
       thread_info->exit_semaphore.Signal();
     }
 
     for (const ThreadInfo* thread_info : thread_infos_) {
-      int rv = pthread_join(thread_info->pthread, NULL);
+      int rv = pthread_join(thread_info->pthread, nullptr);
       CHECK_EQ(0, rv);
     }
   }
 
   // Starts |thread_count| threads and waits on each thread’s ready semaphore,
   // so that when this function returns, all threads have been started and have
   // all run to the point that they’ve signalled that they are ready.
   void StartThreads(size_t thread_count) {
     ASSERT_TRUE(thread_infos_.empty());
 
     for (size_t thread_index = 0; thread_index < thread_count; ++thread_index) {
       ThreadInfo* thread_info = new ThreadInfo();
       thread_infos_.push_back(thread_info);
 
       int rv = pthread_create(&thread_info->pthread,
-                              NULL,
+                              nullptr,
                               ThreadMain,
                               thread_info);
       ASSERT_EQ(0, rv);
     }
 
     for (ThreadInfo* thread_info : thread_infos_) {
       thread_info->ready_semaphore.Wait();
     }
 
     // If present, suspend the thread at indices 1 through 3 the same number of
@@ skipping 22 matching lines @@
     const ThreadInfo* thread_info = thread_infos_[thread_index];
     expectation->stack_address = thread_info->stack_address;
     expectation->suspend_count = thread_info->suspend_count;
 
     return PthreadToThreadID(thread_info->pthread);
   }
 
  private:
   struct ThreadInfo {
     ThreadInfo()
-        : pthread(NULL),
+        : pthread(nullptr),
           stack_address(0),
           ready_semaphore(0),
           exit_semaphore(0),
           suspend_count(0) {
     }
 
     ~ThreadInfo() {}
 
     // The thread’s ID, set at the time the thread is created.
     pthread_t pthread;
@@ skipping 25 matching lines @@
 
     thread_info->ready_semaphore.Signal();
     thread_info->exit_semaphore.Wait();
 
     // Check this here after everything’s known to be synchronized, otherwise
     // there’s a race between the parent thread storing this thread’s pthread_t
     // in thread_info_pthread and this thread starting and attempting to access
     // it.
     CHECK_EQ(pthread_self(), thread_info->pthread);
 
-    return NULL;
+    return nullptr;
   }
 
   // This is a PointerVector because the address of a ThreadInfo object is
   // passed to each thread’s ThreadMain(), so they cannot move around in memory.
   PointerVector<ThreadInfo> thread_infos_;
 
   DISALLOW_COPY_AND_ASSIGN(TestThreadPool);
 };
 
 typedef std::map<uint64_t, TestThreadPool::ThreadExpectation> ThreadMap;
@@ skipping 390 matching lines @@
 };
 
 TEST(ProcessReader, ChildModules) {
   ProcessReaderModulesChild process_reader_modules_child;
   process_reader_modules_child.Run();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad