Convert NULL to nullptr

minidump/minidump_thread_writer_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 12 matching lines @@
 #include "minidump/minidump_memory_writer_test_util.h"
 #include "minidump/minidump_file_writer.h"
 #include "minidump/minidump_file_writer_test_util.h"
 #include "util/file/string_file_writer.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 // This returns the MINIDUMP_THREAD_LIST stream in |thread_list|. If
-// |memory_list| is non-NULL, a MINIDUMP_MEMORY_LIST stream is also expected in
-// |file_contents|, and that stream will be returned in |memory_list|.
+// |memory_list| is not nullptr, a MINIDUMP_MEMORY_LIST stream is also expected
+// in |file_contents|, and that stream will be returned in |memory_list|.
 void GetThreadListStream(const std::string& file_contents,
                          const MINIDUMP_THREAD_LIST** thread_list,
                          const MINIDUMP_MEMORY_LIST** memory_list) {
   const size_t kDirectoryOffset = sizeof(MINIDUMP_HEADER);
   const uint32_t kExpectedStreams = memory_list ? 2 : 1;
   const size_t kThreadListStreamOffset =
       kDirectoryOffset + kExpectedStreams * sizeof(MINIDUMP_DIRECTORY);
   const size_t kThreadsOffset =
       kThreadListStreamOffset + sizeof(MINIDUMP_THREAD_LIST);
 
@@ skipping 33 matching lines @@
 
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST),
             file_writer.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, NULL));
+      GetThreadListStream(file_writer.string(), &thread_list, nullptr));
 
   EXPECT_EQ(0u, thread_list->NumberOfThreads);
 }
 
 // The MINIDUMP_THREADs |expected| and |observed| are compared against each
-// other using gtest assertions. If |stack| is non-NULL, |observed| is expected
-// to contain a populated MINIDUMP_MEMORY_DESCRIPTOR in its Stack field,
-// otherwise, its Stack field is expected to be zeroed out. The memory
+// other using gtest assertions. If |stack| is not nullptr, |observed| is
+// expected to contain a populated MINIDUMP_MEMORY_DESCRIPTOR in its Stack
+// field, otherwise, its Stack field is expected to be zeroed out. The memory
 // descriptor will be placed in |stack|. |observed| must contain a populated
 // ThreadContext field. The context will be recovered from |file_contents| and
 // stored in |context_base|.
 void ExpectThread(const MINIDUMP_THREAD* expected,
                   const MINIDUMP_THREAD* observed,
                   const std::string& file_contents,
                   const MINIDUMP_MEMORY_DESCRIPTOR** stack,
                   const void** context_base) {
   EXPECT_EQ(expected->ThreadId, observed->ThreadId);
   EXPECT_EQ(expected->SuspendCount, observed->SuspendCount);
@@ skipping 52 matching lines @@
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextX86),
             file_writer.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, NULL));
+      GetThreadListStream(file_writer.string(), &thread_list, nullptr));
 
   EXPECT_EQ(1u, thread_list->NumberOfThreads);
 
   MINIDUMP_THREAD expected = {};
   expected.ThreadId = kThreadID;
   expected.SuspendCount = kSuspendCount;
   expected.PriorityClass = kPriorityClass;
   expected.Priority = kPriority;
   expected.Teb = kTEB;
   expected.ThreadContext.DataSize = sizeof(MinidumpContextX86);
 
   const MinidumpContextX86* observed_context;
   ASSERT_NO_FATAL_FAILURE(
       ExpectThread(&expected,
                    &thread_list->Threads[0],
                    file_writer.string(),
-                   NULL,
+                   nullptr,
                    reinterpret_cast<const void**>(&observed_context)));
 
   ASSERT_NO_FATAL_FAILURE(ExpectMinidumpContextX86(kSeed, observed_context));
 }
 
 TEST(MinidumpThreadWriter, OneThread_AMD64_Stack) {
   MinidumpFileWriter minidump_file_writer;
   MinidumpThreadListWriter thread_list_writer;
 
   const uint32_t kThreadID = 0x22222222;
@@ skipping 27 matching lines @@
   StringFileWriter file_writer;
   ASSERT_TRUE(minidump_file_writer.WriteEverything(&file_writer));
 
   ASSERT_EQ(sizeof(MINIDUMP_HEADER) + sizeof(MINIDUMP_DIRECTORY) +
                 sizeof(MINIDUMP_THREAD_LIST) + 1 * sizeof(MINIDUMP_THREAD) +
                 1 * sizeof(MinidumpContextAMD64) + kMemorySize,
             file_writer.string().size());
 
   const MINIDUMP_THREAD_LIST* thread_list;
   ASSERT_NO_FATAL_FAILURE(
-      GetThreadListStream(file_writer.string(), &thread_list, NULL));
+      GetThreadListStream(file_writer.string(), &thread_list, nullptr));
 
   EXPECT_EQ(1u, thread_list->NumberOfThreads);
 
   MINIDUMP_THREAD expected = {};
   expected.ThreadId = kThreadID;
   expected.SuspendCount = kSuspendCount;
   expected.PriorityClass = kPriorityClass;
   expected.Priority = kPriority;
   expected.Teb = kTEB;
   expected.Stack.StartOfMemoryRange = kMemoryBase;
@@ skipping 236 matching lines @@
   thread_list_writer.AddThread(&thread_writer);
   minidump_file_writer.AddStream(&thread_list_writer);
 
   StringFileWriter file_writer;
   ASSERT_DEATH(minidump_file_writer.WriteEverything(&file_writer), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad