Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/audio_device_impl.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 104 matching lines @@
 
 // ----------------------------------------------------------------------------
 //  AudioDeviceModuleImpl - ctor
 // ----------------------------------------------------------------------------
 
 AudioDeviceModuleImpl::AudioDeviceModuleImpl(const int32_t id,
                                              const AudioLayer audioLayer)
     : _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
       _critSectEventCb(*CriticalSectionWrapper::CreateCriticalSection()),
       _critSectAudioCb(*CriticalSectionWrapper::CreateCriticalSection()),
-      _ptrCbAudioDeviceObserver(NULL),
-      _ptrAudioDevice(NULL),
+      _ptrCbAudioDeviceObserver(nullptr),
+      _ptrAudioDevice(nullptr),
       _id(id),
       _platformAudioLayer(audioLayer),
       _lastProcessTime(rtc::TimeMillis()),
       _platformType(kPlatformNotSupported),
       _initialized(false),
       _lastError(kAdmErrNone) {
   LOG(INFO) << __FUNCTION__;
 }
 
 // ----------------------------------------------------------------------------
@@ skipping 37 matching lines @@
   return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  CreatePlatformSpecificObjects
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::CreatePlatformSpecificObjects() {
   LOG(INFO) << __FUNCTION__;
 
-  AudioDeviceGeneric* ptrAudioDevice(NULL);
+  AudioDeviceGeneric* ptrAudioDevice(nullptr);
 
 #if defined(WEBRTC_DUMMY_AUDIO_BUILD)
   ptrAudioDevice = new AudioDeviceDummy(Id());
   LOG(INFO) << "Dummy Audio APIs will be utilized";
 #elif defined(WEBRTC_DUMMY_FILE_DEVICES)
   ptrAudioDevice = FileAudioDeviceFactory::CreateFileAudioDevice(Id());
   if (ptrAudioDevice) {
     LOG(INFO) << "Will use file-playing dummy device.";
   } else {
     // Create a dummy device instead.
@@ skipping 21 matching lines @@
       (audioLayer == kPlatformDefaultAudio)) {
     LOG(INFO) << "attempting to use the Windows Core Audio APIs...";
 
     if (AudioDeviceWindowsCore::CoreAudioIsSupported()) {
       // create *Windows Core Audio* implementation
       ptrAudioDevice = new AudioDeviceWindowsCore(Id());
       LOG(INFO) << "Windows Core Audio APIs will be utilized";
     } else {
       // create *Windows Wave Audio* implementation
       ptrAudioDevice = new AudioDeviceWindowsWave(Id());
-      if (ptrAudioDevice != NULL) {
+      if (ptrAudioDevice != nullptr) {
         // Core Audio was not supported => revert to Windows Wave instead
         _platformAudioLayer =
             kWindowsWaveAudio;  // modify the state set at construction
         LOG(WARNING) << "Windows Core Audio is *not* supported => Wave APIs "
                         "will be utilized instead";
       }
     }
   }
 #endif  // defined(WEBRTC_WINDOWS_CORE_AUDIO_BUILD)
 #endif  // #if defined(_WIN32)
@@ skipping 51 matching lines @@
     AudioDeviceLinuxPulse* pulseDevice = new AudioDeviceLinuxPulse(Id());
     if (pulseDevice->Init() == AudioDeviceGeneric::InitStatus::OK) {
       ptrAudioDevice = pulseDevice;
       LOG(INFO) << "Linux PulseAudio APIs will be utilized";
     } else {
       delete pulseDevice;
 #endif
 #if defined(LINUX_ALSA)
       // create *Linux ALSA Audio* implementation
       ptrAudioDevice = new AudioDeviceLinuxALSA(Id());
-      if (ptrAudioDevice != NULL) {
+      if (ptrAudioDevice != nullptr) {
         // Pulse Audio was not supported => revert to ALSA instead
         _platformAudioLayer =
             kLinuxAlsaAudio;  // modify the state set at construction
         LOG(WARNING) << "Linux PulseAudio is *not* supported => ALSA APIs will "
                         "be utilized instead";
       }
 #endif
 #if defined(LINUX_PULSE)
     }
 #endif
@@ skipping 30 matching lines @@
   // Available for all platforms
   //
   if (audioLayer == kDummyAudio) {
     // Create *Dummy Audio* implementation
     assert(!ptrAudioDevice);
     ptrAudioDevice = new AudioDeviceDummy(Id());
     LOG(INFO) << "Dummy Audio APIs will be utilized";
   }
 #endif  // if defined(WEBRTC_DUMMY_AUDIO_BUILD)
 
-  if (ptrAudioDevice == NULL) {
+  if (ptrAudioDevice == nullptr) {
     LOG(LERROR)
         << "unable to create the platform specific audio device implementation";
     return -1;
   }
 
   // Store valid output pointers
   //
   _ptrAudioDevice = ptrAudioDevice;
 
   return 0;
@@ skipping 17 matching lines @@
 
 // ----------------------------------------------------------------------------
 //  ~AudioDeviceModuleImpl - dtor
 // ----------------------------------------------------------------------------
 
 AudioDeviceModuleImpl::~AudioDeviceModuleImpl() {
   LOG(INFO) << __FUNCTION__;
 
   if (_ptrAudioDevice) {
     delete _ptrAudioDevice;
-    _ptrAudioDevice = NULL;
+    _ptrAudioDevice = nullptr;
   }
 
   delete &_critSect;
   delete &_critSectEventCb;
   delete &_critSectAudioCb;
 }
 
 // ============================================================================
 //                                  Module
 // ============================================================================
@@ skipping 847 matching lines @@
 //  PlayoutDeviceName
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::PlayoutDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize]) {
   LOG(INFO) << __FUNCTION__ << "(" << index << ", ...)";
   CHECK_INITIALIZED();
 
-  if (name == NULL) {
+  if (name == nullptr) {
     _lastError = kAdmErrArgument;
     return -1;
   }
 
   if (_ptrAudioDevice->PlayoutDeviceName(index, name, guid) == -1) {
     return -1;
   }
 
-  if (name != NULL) {
+  if (name != nullptr) {
     LOG(INFO) << "output: name = " << name;
   }
-  if (guid != NULL) {
+  if (guid != nullptr) {
     LOG(INFO) << "output: guid = " << guid;
   }
 
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDeviceName
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::RecordingDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize]) {
   LOG(INFO) << __FUNCTION__ << "(" << index << ", ...)";
   CHECK_INITIALIZED();
 
-  if (name == NULL) {
+  if (name == nullptr) {
     _lastError = kAdmErrArgument;
     return -1;
   }
 
   if (_ptrAudioDevice->RecordingDeviceName(index, name, guid) == -1) {
     return -1;
   }
 
-  if (name != NULL) {
+  if (name != nullptr) {
     LOG(INFO) << "output: name = " << name;
   }
-  if (guid != NULL) {
+  if (guid != nullptr) {
     LOG(INFO) << "output: guid = " << guid;
   }
 
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDevices
 // ----------------------------------------------------------------------------
 
@@ skipping 193 matching lines @@
 
 // ----------------------------------------------------------------------------
 //  StartRawInputFileRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StartRawInputFileRecording(
     const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
-  if (NULL == pcmFileNameUTF8) {
+  if (nullptr == pcmFileNameUTF8) {
     return -1;
   }
 
   return (_audioDeviceBuffer.StartInputFileRecording(pcmFileNameUTF8));
 }
 
 // ----------------------------------------------------------------------------
 //  StopRawInputFileRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StopRawInputFileRecording() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   return (_audioDeviceBuffer.StopInputFileRecording());
 }
 
 // ----------------------------------------------------------------------------
 //  StartRawOutputFileRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StartRawOutputFileRecording(
     const char pcmFileNameUTF8[kAdmMaxFileNameSize]) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
-  if (NULL == pcmFileNameUTF8) {
+  if (nullptr == pcmFileNameUTF8) {
     return -1;
   }
 
   return (_audioDeviceBuffer.StartOutputFileRecording(pcmFileNameUTF8));
 }
 
 // ----------------------------------------------------------------------------
 //  StopRawOutputFileRecording
 // ----------------------------------------------------------------------------
 
@@ skipping 322 matching lines @@
 //  PlatformAudioLayer
 // ----------------------------------------------------------------------------
 
 AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer()
     const {
   LOG(INFO) << __FUNCTION__;
   return _platformAudioLayer;
 }
 
 }  // namespace webrtc