Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/linux/audio_mixer_manager_pulse_linux.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 23 matching lines @@
   }
 
   ~AutoPulseLock() {
     LATE(pa_threaded_mainloop_unlock)(pa_mainloop_);
   }
 
  private:
   pa_threaded_mainloop* const pa_mainloop_;
 };
 
-AudioMixerManagerLinuxPulse::AudioMixerManagerLinuxPulse(const int32_t id) :
-    _id(id),
-    _paOutputDeviceIndex(-1),
-    _paInputDeviceIndex(-1),
-    _paPlayStream(NULL),
-    _paRecStream(NULL),
-    _paMainloop(NULL),
-    _paContext(NULL),
-    _paVolume(0),
-    _paMute(0),
-    _paVolSteps(0),
-    _paSpeakerMute(false),
-    _paSpeakerVolume(PA_VOLUME_NORM),
-    _paChannels(0),
-    _paObjectsSet(false)
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
-                 "%s constructed", __FUNCTION__);
+AudioMixerManagerLinuxPulse::AudioMixerManagerLinuxPulse(const int32_t id)
+    : _id(id),
+      _paOutputDeviceIndex(-1),
+      _paInputDeviceIndex(-1),
+      _paPlayStream(nullptr),
+      _paRecStream(nullptr),
+      _paMainloop(nullptr),
+      _paContext(nullptr),
+      _paVolume(0),
+      _paMute(0),
+      _paVolSteps(0),
+      _paSpeakerMute(false),
+      _paSpeakerVolume(PA_VOLUME_NORM),
+      _paChannels(0),
+      _paObjectsSet(false) {
+  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s constructed",
+               __FUNCTION__);
 }
 
 AudioMixerManagerLinuxPulse::~AudioMixerManagerLinuxPulse()
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                  "%s destructed", __FUNCTION__);
 
     Close();
 }
@@ skipping 29 matching lines @@
 
 int32_t AudioMixerManagerLinuxPulse::Close()
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     CloseSpeaker();
     CloseMicrophone();
 
-    _paMainloop = NULL;
-    _paContext = NULL;
+    _paMainloop = nullptr;
+    _paContext = nullptr;
     _paObjectsSet = false;
 
     return 0;
 
 }
 
 int32_t AudioMixerManagerLinuxPulse::CloseSpeaker()
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     // Reset the index to -1
     _paOutputDeviceIndex = -1;
-    _paPlayStream = NULL;
+    _paPlayStream = nullptr;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::CloseMicrophone()
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     // Reset the index to -1
     _paInputDeviceIndex = -1;
-    _paRecStream = NULL;
+    _paRecStream = nullptr;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetPlayStream(pa_stream* playStream)
 {
     RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetPlayStream(playStream)");
 
@@ skipping 113 matching lines @@
         {
             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                          "  could not get sample specification");
             return -1;
         }
 
         // Set the same volume for all channels
         pa_cvolume cVolumes;
         LATE(pa_cvolume_set)(&cVolumes, spec->channels, volume);
 
-        pa_operation* paOperation = NULL;
+        pa_operation* paOperation = nullptr;
         paOperation = LATE(pa_context_set_sink_input_volume)(
-            _paContext,
-            LATE(pa_stream_get_index)(_paPlayStream),
-            &cVolumes,
-            PaSetVolumeCallback, NULL);
+            _paContext, LATE(pa_stream_get_index)(_paPlayStream), &cVolumes,
+            PaSetVolumeCallback, nullptr);
         if (!paOperation)
         {
             setFailed = true;
         }
 
         // Don't need to wait for the completion
         LATE(pa_operation_unref)(paOperation);
     } else
     {
         // We have not created a stream or it's not connected to the sink
@@ skipping 150 matching lines @@
     }
 
     bool setFailed(false);
 
     if (_paPlayStream && (LATE(pa_stream_get_state)(_paPlayStream)
         != PA_STREAM_UNCONNECTED))
     {
         // We can only really mute if we have a connected stream
         AutoPulseLock auto_lock(_paMainloop);
 
-        pa_operation* paOperation = NULL;
+        pa_operation* paOperation = nullptr;
         paOperation = LATE(pa_context_set_sink_input_mute)(
-            _paContext,
-            LATE(pa_stream_get_index)(_paPlayStream),
-            (int) enable,
-            PaSetVolumeCallback,
-            NULL);
+            _paContext, LATE(pa_stream_get_index)(_paPlayStream), (int)enable,
+            PaSetVolumeCallback, nullptr);
         if (!paOperation)
         {
             setFailed = true;
         }
 
         // Don't need to wait for the completion
         LATE(pa_operation_unref)(paOperation);
     } else
     {
         // We have not created a stream or it's not connected to the sink
@@ skipping 93 matching lines @@
 
     // Get the actual stream device index if we have a connected stream
     // The device used by the stream can be changed
     // during the call
     if (_paRecStream && (LATE(pa_stream_get_state)(_paRecStream)
         != PA_STREAM_UNCONNECTED))
     {
         deviceIndex = LATE(pa_stream_get_device_index)(_paRecStream);
     }
 
-    pa_operation* paOperation = NULL;
+    pa_operation* paOperation = nullptr;
 
     // Get info for this source
     // We want to know if the actual device can record in stereo
     paOperation = LATE(pa_context_get_source_info_by_index)(
         _paContext, deviceIndex,
         PaSourceInfoCallback,
         (void*) this);
 
     WaitForOperationCompletion(paOperation);
 
@@ skipping 31 matching lines @@
                  enable);
 
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     bool setFailed(false);
-    pa_operation* paOperation = NULL;
+    pa_operation* paOperation = nullptr;
 
     uint32_t deviceIndex = (uint32_t) _paInputDeviceIndex;
 
     AutoPulseLock auto_lock(_paMainloop);
 
     // Get the actual stream device index if we have a connected stream
     // The device used by the stream can be changed
     // during the call
     if (_paRecStream && (LATE(pa_stream_get_state)(_paRecStream)
         != PA_STREAM_UNCONNECTED))
     {
         deviceIndex = LATE(pa_stream_get_device_index)(_paRecStream);
     }
 
     // Set mute switch for the source
     paOperation = LATE(pa_context_set_source_mute_by_index)(
-        _paContext, deviceIndex,
-        enable,
-        PaSetVolumeCallback, NULL);
+        _paContext, deviceIndex, enable, PaSetVolumeCallback, nullptr);
 
     if (!paOperation)
     {
         setFailed = true;
     }
 
     // Don't need to wait for this to complete.
     LATE(pa_operation_unref)(paOperation);
 
     if (setFailed)
@@ skipping 155 matching lines @@
     // Get the actual stream device index if we have a connected stream
     // The device used by the stream can be changed
     // during the call
     if (_paRecStream && (LATE(pa_stream_get_state)(_paRecStream)
         != PA_STREAM_UNCONNECTED))
     {
         deviceIndex = LATE(pa_stream_get_device_index)(_paRecStream);
     }
 
     bool setFailed(false);
-    pa_operation* paOperation = NULL;
+    pa_operation* paOperation = nullptr;
 
     // Get the number of channels for this source
     paOperation
         = LATE(pa_context_get_source_info_by_index)(_paContext, deviceIndex,
                                                     PaSourceInfoCallback,
                                                     (void*) this);
 
     WaitForOperationCompletion(paOperation);
 
     uint8_t channels = _paChannels;
     pa_cvolume cVolumes;
     LATE(pa_cvolume_set)(&cVolumes, channels, volume);
 
     // Set the volume for the source
-    paOperation
-        = LATE(pa_context_set_source_volume_by_index)(_paContext, deviceIndex,
-                                                      &cVolumes,
-                                                      PaSetVolumeCallback,
-                                                      NULL);
+    paOperation = LATE(pa_context_set_source_volume_by_index)(
+        _paContext, deviceIndex, &cVolumes, PaSetVolumeCallback, nullptr);
 
     if (!paOperation)
     {
         setFailed = true;
     }
 
     // Don't need to wait for this to complete.
     LATE(pa_operation_unref)(paOperation);
 
     if (setFailed)
@@ skipping 98 matching lines @@
 
     // Get the actual stream device index if we have a connected stream
     // The device used by the stream can be changed
     // during the call
     if (_paRecStream && (LATE(pa_stream_get_state)(_paRecStream)
         != PA_STREAM_UNCONNECTED))
     {
         deviceIndex = LATE(pa_stream_get_device_index)(_paRecStream);
     }
 
-    pa_operation* paOperation = NULL;
+    pa_operation* paOperation = nullptr;
 
     // Get info for this source
     paOperation
         = LATE(pa_context_get_source_info_by_index)(_paContext, deviceIndex,
                                                     PaSourceInfoCallback,
                                                     (void*) this);
 
     WaitForOperationCompletion(paOperation);
 
     stepSize = static_cast<uint16_t> ((PA_VOLUME_NORM + 1) / _paVolSteps);
@@ skipping 140 matching lines @@
 {
     while (LATE(pa_operation_get_state)(paOperation) == PA_OPERATION_RUNNING)
     {
         LATE(pa_threaded_mainloop_wait)(_paMainloop);
     }
 
     LATE(pa_operation_unref)(paOperation);
 }
 
 bool AudioMixerManagerLinuxPulse::GetSinkInputInfo() const {
-  pa_operation* paOperation = NULL;
+  pa_operation* paOperation = nullptr;
 
   AutoPulseLock auto_lock(_paMainloop);
   // Get info for this stream (sink input).
   paOperation = LATE(pa_context_get_sink_input_info)(
       _paContext,
       LATE(pa_stream_get_index)(_paPlayStream),
       PaSinkInputInfoCallback,
       (void*) this);
 
   WaitForOperationCompletion(paOperation);
   return true;
 }
 
 bool AudioMixerManagerLinuxPulse::GetSinkInfoByIndex(
     int device_index) const {
-  pa_operation* paOperation = NULL;
+  pa_operation* paOperation = nullptr;
 
   AutoPulseLock auto_lock(_paMainloop);
   paOperation = LATE(pa_context_get_sink_info_by_index)(_paContext,
       device_index, PaSinkInfoCallback, (void*) this);
 
   WaitForOperationCompletion(paOperation);
   return true;
 }
 
 bool AudioMixerManagerLinuxPulse::GetSourceInfoByIndex(
     int device_index) const {
-  pa_operation* paOperation = NULL;
+  pa_operation* paOperation = nullptr;
 
   AutoPulseLock auto_lock(_paMainloop);
   paOperation  = LATE(pa_context_get_source_info_by_index)(
       _paContext, device_index, PaSourceInfoCallback, (void*) this);
 
   WaitForOperationCompletion(paOperation);
   return true;
 }
 
 }