Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/test/audio_device_test_api.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 152 matching lines @@
 
     // Windows:
     //      if (WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
     //          user can select between default (Core) or Wave
     //      else
     //          user can select between default (Wave) or Wave
     const int32_t kId = 444;
 
 #if defined(_WIN32)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
+                     kId, AudioDeviceModule::kLinuxAlsaAudio)) == nullptr);
 #if defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is defined!\n\n");
     // create default implementation (=Core Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
+                     kId, AudioDeviceModule::kPlatformDefaultAudio)) !=
+                nullptr);
     EXPECT_EQ(0, audio_device_.release()->Release());
     // create non-default (=Wave Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
+                     kId, AudioDeviceModule::kWindowsWaveAudio)) != nullptr);
     EXPECT_EQ(0, audio_device_.release()->Release());
     // explicitly specify usage of Core Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsCoreAudio)) != NULL);
+                     kId, AudioDeviceModule::kWindowsCoreAudio)) != nullptr);
 #else
     TEST_LOG("WEBRTC_WINDOWS_CORE_AUDIO_BUILD is *not* defined!\n");
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsCoreAudio)) == nullptr);
     // create default implementation (=Wave Audio) instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
+                     kId, AudioDeviceModule::kPlatformDefaultAudio)) !=
+                nullptr);
     EXPECT_EQ(0, audio_device_.release()->Release());
     // explicitly specify usage of Wave Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) != NULL);
+                     kId, AudioDeviceModule::kWindowsWaveAudio)) != nullptr);
 #endif
 #endif
 
 #if defined(ANDROID)
     // Fails tests
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsWaveAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsCoreAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
+                     kId, AudioDeviceModule::kLinuxAlsaAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
+                     kId, AudioDeviceModule::kLinuxPulseAudio)) == nullptr);
     // Create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
+                     kId, AudioDeviceModule::kPlatformDefaultAudio)) !=
+                nullptr);
 #elif defined(WEBRTC_LINUX)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsWaveAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsCoreAudio)) == nullptr);
     // create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
+                     kId, AudioDeviceModule::kPlatformDefaultAudio)) !=
+                nullptr);
     EXPECT_EQ(0, audio_device_->Terminate());
     EXPECT_EQ(0, audio_device_.release()->Release());
     // explicitly specify usage of Pulse Audio (same as default)
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxPulseAudio)) != NULL);
+                     kId, AudioDeviceModule::kLinuxPulseAudio)) != nullptr);
 #endif
 
 #if defined(WEBRTC_MAC)
     // Fails tests
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsWaveAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsWaveAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kWindowsCoreAudio)) == NULL);
+                     kId, AudioDeviceModule::kWindowsCoreAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxAlsaAudio)) == NULL);
+                     kId, AudioDeviceModule::kLinuxAlsaAudio)) == nullptr);
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kLinuxPulseAudio)) == NULL);
+                     kId, AudioDeviceModule::kLinuxPulseAudio)) == nullptr);
     // Create default implementation instance
     EXPECT_TRUE((audio_device_ = AudioDeviceModule::Create(
-                kId, AudioDeviceModule::kPlatformDefaultAudio)) != NULL);
+                     kId, AudioDeviceModule::kPlatformDefaultAudio)) !=
+                nullptr);
 #endif
 
-    if (audio_device_ == NULL) {
+    if (audio_device_ == nullptr) {
       FAIL() << "Failed creating audio device object!";
     }
 
     process_thread_->RegisterModule(audio_device_);
 
     AudioDeviceModule::AudioLayer audio_layer =
         AudioDeviceModule::kPlatformDefaultAudio;
     EXPECT_EQ(0, audio_device_->ActiveAudioLayer(&audio_layer));
     if (audio_layer == AudioDeviceModule::kLinuxAlsaAudio) {
       linux_alsa_ = true;
     }
   }
 
   static void TearDownTestCase() {
     if (process_thread_) {
       process_thread_->DeRegisterModule(audio_device_);
       process_thread_->Stop();
       process_thread_.reset();
     }
     if (event_observer_) {
       delete event_observer_;
-      event_observer_ = NULL;
+      event_observer_ = nullptr;
     }
     if (audio_transport_) {
       delete audio_transport_;
-      audio_transport_ = NULL;
+      audio_transport_ = nullptr;
     }
     if (audio_device_)
       EXPECT_EQ(0, audio_device_.release()->Release());
     PRINT_TEST_RESULTS;
   }
 
   void SetUp() override {
     if (linux_alsa_) {
       FAIL() << "API Test is not available on ALSA on Linux!";
     }
@@ skipping 30 matching lines @@
   static std::unique_ptr<ProcessThread> process_thread_;
   static rtc::scoped_refptr<AudioDeviceModule> audio_device_;
   static AudioTransportAPI* audio_transport_;
   static AudioEventObserverAPI* event_observer_;
 };
 
 // Must be initialized like this to handle static SetUpTestCase() above.
 bool AudioDeviceAPITest::linux_alsa_ = false;
 std::unique_ptr<ProcessThread> AudioDeviceAPITest::process_thread_;
 rtc::scoped_refptr<AudioDeviceModule> AudioDeviceAPITest::audio_device_;
-AudioTransportAPI* AudioDeviceAPITest::audio_transport_ = NULL;
-AudioEventObserverAPI* AudioDeviceAPITest::event_observer_ = NULL;
+AudioTransportAPI* AudioDeviceAPITest::audio_transport_ = nullptr;
+AudioEventObserverAPI* AudioDeviceAPITest::event_observer_ = nullptr;
 
 TEST_F(AudioDeviceAPITest, RegisterEventObserver) {
   event_observer_ = new AudioEventObserverAPI(audio_device_);
-  EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
+  EXPECT_EQ(0, audio_device_->RegisterEventObserver(nullptr));
   EXPECT_EQ(0, audio_device_->RegisterEventObserver(event_observer_));
-  EXPECT_EQ(0, audio_device_->RegisterEventObserver(NULL));
+  EXPECT_EQ(0, audio_device_->RegisterEventObserver(nullptr));
 }
 
 TEST_F(AudioDeviceAPITest, RegisterAudioCallback) {
   audio_transport_ = new AudioTransportAPI(audio_device_);
-  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
   EXPECT_EQ(0, audio_device_->RegisterAudioCallback(audio_transport_));
-  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
 }
 
 TEST_F(AudioDeviceAPITest, Init) {
   EXPECT_TRUE(audio_device_->Initialized());
   EXPECT_EQ(0, audio_device_->Init());
   EXPECT_TRUE(audio_device_->Initialized());
   EXPECT_EQ(0, audio_device_->Terminate());
   EXPECT_FALSE(audio_device_->Initialized());
   EXPECT_EQ(0, audio_device_->Init());
   EXPECT_TRUE(audio_device_->Initialized());
@@ skipping 26 matching lines @@
 // TODO(henrika): uncomment when you have decided what to do with issue 3675.
 #if 0
 TEST_F(AudioDeviceAPITest, PlayoutDeviceName) {
   char name[kAdmMaxDeviceNameSize];
   char guid[kAdmMaxGuidSize];
   int16_t no_devices = audio_device_->PlayoutDevices();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-2, name, guid));
   EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(no_devices, name, guid));
-  EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(0, NULL, guid));
+  EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(0, nullptr, guid));
 
   // bulk tests
-  EXPECT_EQ(0, audio_device_->PlayoutDeviceName(0, name, NULL));
+  EXPECT_EQ(0, audio_device_->PlayoutDeviceName(0, name, nullptr));
 #ifdef _WIN32
   // shall be mapped to 0.
-  EXPECT_EQ(0, audio_device_->PlayoutDeviceName(-1, name, NULL));
+  EXPECT_EQ(0, audio_device_->PlayoutDeviceName(-1, name, nullptr));
 #else
-  EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-1, name, NULL));
+  EXPECT_EQ(-1, audio_device_->PlayoutDeviceName(-1, name, nullptr));
 #endif
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, guid));
-    EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, NULL));
+    EXPECT_EQ(0, audio_device_->PlayoutDeviceName(i, name, nullptr));
   }
 }
 
 TEST_F(AudioDeviceAPITest, RecordingDeviceName) {
   char name[kAdmMaxDeviceNameSize];
   char guid[kAdmMaxGuidSize];
   int16_t no_devices = audio_device_->RecordingDevices();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-2, name, guid));
   EXPECT_EQ(-1, audio_device_->RecordingDeviceName(no_devices, name, guid));
-  EXPECT_EQ(-1, audio_device_->RecordingDeviceName(0, NULL, guid));
+  EXPECT_EQ(-1, audio_device_->RecordingDeviceName(0, nullptr, guid));
 
   // bulk tests
-  EXPECT_EQ(0, audio_device_->RecordingDeviceName(0, name, NULL));
+  EXPECT_EQ(0, audio_device_->RecordingDeviceName(0, name, nullptr));
 #ifdef _WIN32
   // shall me mapped to 0
-  EXPECT_EQ(0, audio_device_->RecordingDeviceName(-1, name, NULL));
+  EXPECT_EQ(0, audio_device_->RecordingDeviceName(-1, name, nullptr));
 #else
-  EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-1, name, NULL));
+  EXPECT_EQ(-1, audio_device_->RecordingDeviceName(-1, name, nullptr));
 #endif
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, guid));
-    EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, NULL));
+    EXPECT_EQ(0, audio_device_->RecordingDeviceName(i, name, nullptr));
   }
 }
 
 TEST_F(AudioDeviceAPITest, SetPlayoutDevice) {
   int16_t no_devices = audio_device_->PlayoutDevices();
 
   // fail tests
   EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(-1));
   EXPECT_EQ(-1, audio_device_->SetPlayoutDevice(no_devices));
 
@@ skipping 180 matching lines @@
         EXPECT_EQ(0, audio_device_->InitRecording());
         EXPECT_TRUE(audio_device_->RecordingIsInitialized());
       }
     }
   }
   EXPECT_EQ(0, audio_device_->StopRecording());
 }
 
 TEST_F(AudioDeviceAPITest, StartAndStopPlayout) {
   bool available;
-  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
 
   CheckInitialPlayoutStates();
 
   EXPECT_EQ(-1, audio_device_->StartPlayout());
   EXPECT_EQ(0, audio_device_->StopPlayout());
 
 #ifdef _WIN32
   // kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetPlayoutDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
   if (available)
   {
     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
     EXPECT_EQ(0, audio_device_->InitPlayout());
     EXPECT_EQ(0, audio_device_->StartPlayout());
     EXPECT_TRUE(audio_device_->Playing());
     EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
     EXPECT_EQ(0, audio_device_->StopPlayout());
     EXPECT_FALSE(audio_device_->Playing());
-    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
   }
 #endif
 
   // repeat test but for kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(MACRO_DEFAULT_DEVICE));
   EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
   if (available) {
     EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
     EXPECT_EQ(0, audio_device_->InitPlayout());
     EXPECT_EQ(0, audio_device_->StartPlayout());
     EXPECT_TRUE(audio_device_->Playing());
     EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
     EXPECT_EQ(0, audio_device_->StopPlayout());
     EXPECT_FALSE(audio_device_->Playing());
-    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
   }
 
   // repeat test for all devices
   int16_t no_devices = audio_device_->PlayoutDevices();
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
     EXPECT_EQ(0, audio_device_->PlayoutIsAvailable(&available));
     if (available) {
       EXPECT_FALSE(audio_device_->PlayoutIsInitialized());
       EXPECT_EQ(0, audio_device_->InitPlayout());
       EXPECT_EQ(0, audio_device_->StartPlayout());
       EXPECT_TRUE(audio_device_->Playing());
       EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
       EXPECT_EQ(0, audio_device_->StopPlayout());
       EXPECT_FALSE(audio_device_->Playing());
-      EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+      EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
     }
   }
 }
 
 TEST_F(AudioDeviceAPITest, StartAndStopRecording) {
   bool available;
-  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+  EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
 
   CheckInitialRecordingStates();
 
   EXPECT_EQ(-1, audio_device_->StartRecording());
   EXPECT_EQ(0, audio_device_->StopRecording());
 
 #ifdef _WIN32
   // kDefaultCommunicationDevice
   EXPECT_TRUE(audio_device_->SetRecordingDevice(
           AudioDeviceModule::kDefaultCommunicationDevice) == 0);
   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
   if (available)
   {
     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
     EXPECT_EQ(0, audio_device_->InitRecording());
     EXPECT_EQ(0, audio_device_->StartRecording());
     EXPECT_TRUE(audio_device_->Recording());
     EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
     EXPECT_EQ(0, audio_device_->StopRecording());
     EXPECT_FALSE(audio_device_->Recording());
-    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
   }
 #endif
 
   // repeat test but for kDefaultDevice
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
   EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
   if (available) {
     EXPECT_FALSE(audio_device_->RecordingIsInitialized());
     EXPECT_EQ(0, audio_device_->InitRecording());
     EXPECT_EQ(0, audio_device_->StartRecording());
     EXPECT_TRUE(audio_device_->Recording());
     EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
     EXPECT_EQ(0, audio_device_->StopRecording());
     EXPECT_FALSE(audio_device_->Recording());
-    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+    EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
   }
 
   // repeat test for all devices
   int16_t no_devices = audio_device_->RecordingDevices();
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetRecordingDevice(i));
     EXPECT_EQ(0, audio_device_->RecordingIsAvailable(&available));
     if (available) {
       EXPECT_FALSE(audio_device_->RecordingIsInitialized());
       EXPECT_EQ(0, audio_device_->InitRecording());
       EXPECT_EQ(0, audio_device_->StartRecording());
       EXPECT_TRUE(audio_device_->Recording());
       EXPECT_EQ(-1, audio_device_->RegisterAudioCallback(audio_transport_));
       EXPECT_EQ(0, audio_device_->StopRecording());
       EXPECT_FALSE(audio_device_->Recording());
-      EXPECT_EQ(0, audio_device_->RegisterAudioCallback(NULL));
+      EXPECT_EQ(0, audio_device_->RegisterAudioCallback(nullptr));
     }
   }
 }
 
 #if defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 TEST_F(AudioDeviceAPITest, SetAndGetWaveOutVolume) {
   uint32_t vol(0);
   // NOTE 1: Windows Wave only!
   // NOTE 2: It seems like the waveOutSetVolume API returns
   // MMSYSERR_NOTSUPPORTED on some Vista machines!
@@ skipping 39 matching lines @@
     }
   }
 
   EXPECT_EQ(0, audio_device_->StopPlayout());
   EXPECT_FALSE(audio_device_->Playing());
 }
 #endif  // defined(_WIN32) && !defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 
 TEST_F(AudioDeviceAPITest, InitSpeaker) {
   // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
-  // ensure that any existing output mixer handle is set to NULL.
+  // ensure that any existing output mixer handle is set to null.
   // The mixer handle is closed and reopened again for each call to
   // SetPlayoutDevice.
   CheckInitialPlayoutStates();
 
   // kDefaultCommunicationDevice
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
       MACRO_DEFAULT_COMMUNICATION_DEVICE));
   EXPECT_EQ(0, audio_device_->InitSpeaker());
 
   // fail tests
@@ skipping 13 matching lines @@
   // repeat test for all devices
   int16_t no_devices = audio_device_->PlayoutDevices();
   for (int i = 0; i < no_devices; i++) {
     EXPECT_EQ(0, audio_device_->SetPlayoutDevice(i));
     EXPECT_EQ(0, audio_device_->InitSpeaker());
   }
 }
 
 TEST_F(AudioDeviceAPITest, InitMicrophone) {
   // NOTE: By calling Terminate (in TearDown) followed by Init (in SetUp) we
-  // ensure that any existing output mixer handle is set to NULL.
+  // ensure that any existing output mixer handle is set to null.
   // The mixer handle is closed and reopened again for each call to
   // SetRecordingDevice.
   CheckInitialRecordingStates();
 
   // kDefaultCommunicationDevice
   EXPECT_EQ(0,
       audio_device_->SetRecordingDevice(MACRO_DEFAULT_COMMUNICATION_DEVICE));
   EXPECT_EQ(0, audio_device_->InitMicrophone());
 
   // fail tests
@@ skipping 770 matching lines @@
 }
 
 // TODO(kjellander): Fix flakiness causing failures on Windows.
 // TODO(phoglund):  Fix flakiness causing failures on Linux.
 #if !defined(_WIN32) && !defined(WEBRTC_LINUX)
 TEST_F(AudioDeviceAPITest, StartAndStopRawOutputFileRecording) {
   // NOTE: this API is better tested in a functional test
   CheckInitialPlayoutStates();
 
   // fail tests
-  EXPECT_EQ(-1, audio_device_->StartRawOutputFileRecording(NULL));
+  EXPECT_EQ(-1, audio_device_->StartRawOutputFileRecording(nullptr));
 
   // bulk tests
   EXPECT_EQ(0, audio_device_->StartRawOutputFileRecording(
       GetFilename("raw_output_not_playing.pcm")));
   EXPECT_EQ(0, audio_device_->StopRawOutputFileRecording());
   EXPECT_EQ(0, audio_device_->SetPlayoutDevice(
       MACRO_DEFAULT_COMMUNICATION_DEVICE));
 
   // TODO(kjellander): Fix so these tests pass on Mac.
 #if !defined(WEBRTC_MAC)
@@ skipping 15 matching lines @@
   // - size of raw_output_not_playing.pcm shall be 0
   // - size of raw_output_playing.pcm shall be > 0
 }
 
 TEST_F(AudioDeviceAPITest, StartAndStopRawInputFileRecording) {
   // NOTE: this API is better tested in a functional test
   CheckInitialRecordingStates();
   EXPECT_FALSE(audio_device_->Playing());
 
   // fail tests
-  EXPECT_EQ(-1, audio_device_->StartRawInputFileRecording(NULL));
+  EXPECT_EQ(-1, audio_device_->StartRawInputFileRecording(nullptr));
 
   // bulk tests
   EXPECT_EQ(0, audio_device_->StartRawInputFileRecording(
       GetFilename("raw_input_not_recording.pcm")));
   EXPECT_EQ(0, audio_device_->StopRawInputFileRecording());
   EXPECT_EQ(0, audio_device_->SetRecordingDevice(MACRO_DEFAULT_DEVICE));
 
   // TODO(kjellander): Fix so these tests pass on Mac.
 #if !defined(WEBRTC_MAC)
   EXPECT_EQ(0, audio_device_->InitRecording());
@@ skipping 43 matching lines @@
   EXPECT_EQ(48000, sampleRate);
 #elif defined(ANDROID)
   TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000));
 #elif defined(WEBRTC_IOS)
   TEST_LOG("Playout sample rate is %u\n\n", sampleRate);
   EXPECT_TRUE((sampleRate == 44000) || (sampleRate == 16000) ||
               (sampleRate == 8000));
 #endif
 }