Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/mac/audio_mixer_manager_mac.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 100 matching lines @@
   pid_t hogPid = -1;
 
   _outputDeviceID = deviceID;
 
   // Check which process, if any, has hogged the device.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyHogMode, kAudioDevicePropertyScopeOutput, 0};
 
   size = sizeof(hogPid);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &hogPid));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &hogPid));
 
   if (hogPid == -1) {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  " No process has hogged the input device");
   }
   // getpid() is apparently "always successful"
   else if (hogPid == getpid()) {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  " Our process has hogged the input device");
   } else {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  " Another process (pid = %d) has hogged the input device",
                  static_cast<int>(hogPid));
 
     return -1;
   }
 
   // get number of channels from stream format
   propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
 
   // Get the stream format, to be able to read the number of channels.
   AudioStreamBasicDescription streamFormat;
   size = sizeof(AudioStreamBasicDescription);
   memset(&streamFormat, 0, size);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &streamFormat));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &streamFormat));
 
   _noOutputChannels = streamFormat.mChannelsPerFrame;
 
   return 0;
 }
 
 int32_t AudioMixerManagerMac::OpenMicrophone(AudioDeviceID deviceID) {
   WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                "AudioMixerManagerMac::OpenMicrophone(id=%d)", deviceID);
 
   CriticalSectionScoped lock(&_critSect);
 
   OSStatus err = noErr;
   UInt32 size = 0;
   pid_t hogPid = -1;
 
   _inputDeviceID = deviceID;
 
   // Check which process, if any, has hogged the device.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyHogMode, kAudioDevicePropertyScopeInput, 0};
   size = sizeof(hogPid);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &hogPid));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &hogPid));
   if (hogPid == -1) {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  " No process has hogged the input device");
   }
   // getpid() is apparently "always successful"
   else if (hogPid == getpid()) {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  " Our process has hogged the input device");
   } else {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  " Another process (pid = %d) has hogged the input device",
                  static_cast<int>(hogPid));
 
     return -1;
   }
 
   // get number of channels from stream format
   propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
 
   // Get the stream format, to be able to read the number of channels.
   AudioStreamBasicDescription streamFormat;
   size = sizeof(AudioStreamBasicDescription);
   memset(&streamFormat, 0, size);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &streamFormat));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &streamFormat));
 
   _noInputChannels = streamFormat.mChannelsPerFrame;
 
   return 0;
 }
 
 bool AudioMixerManagerMac::SpeakerIsInitialized() const {
   WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
   return (_outputDeviceID != kAudioObjectUnknown);
@@ skipping 29 matching lines @@
   // Does the capture device have a master volume control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeOutput, 0};
   Boolean isSettable = false;
   err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                       &isSettable);
   if (err == noErr && isSettable) {
     size = sizeof(vol);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-        _outputDeviceID, &propertyAddress, 0, NULL, size, &vol));
+        _outputDeviceID, &propertyAddress, 0, nullptr, size, &vol));
 
     return 0;
   }
 
   // Otherwise try to set each channel.
   for (UInt32 i = 1; i <= _noOutputChannels; i++) {
     propertyAddress.mElement = i;
     isSettable = false;
     err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                         &isSettable);
     if (err == noErr && isSettable) {
       size = sizeof(vol);
       WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-          _outputDeviceID, &propertyAddress, 0, NULL, size, &vol));
+          _outputDeviceID, &propertyAddress, 0, nullptr, size, &vol));
     }
     success = true;
   }
 
   if (!success) {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  " Unable to set a volume on any output channel");
     return -1;
   }
 
@@ skipping 15 matching lines @@
 
   // Does the device have a master volume control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeOutput, 0};
   Boolean hasProperty =
       AudioObjectHasProperty(_outputDeviceID, &propertyAddress);
   if (hasProperty) {
     size = sizeof(vol);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        _outputDeviceID, &propertyAddress, 0, NULL, &size, &vol));
+        _outputDeviceID, &propertyAddress, 0, nullptr, &size, &vol));
 
     // vol 0.0 to 1.0 -> convert to 0 - 255
     volume = static_cast<uint32_t>(vol * 255 + 0.5);
   } else {
     // Otherwise get the average volume across channels.
     vol = 0;
     for (UInt32 i = 1; i <= _noOutputChannels; i++) {
       channelVol = 0;
       propertyAddress.mElement = i;
       hasProperty = AudioObjectHasProperty(_outputDeviceID, &propertyAddress);
       if (hasProperty) {
         size = sizeof(channelVol);
         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-            _outputDeviceID, &propertyAddress, 0, NULL, &size, &channelVol));
+            _outputDeviceID, &propertyAddress, 0, nullptr, &size, &channelVol));
 
         vol += channelVol;
         channels++;
       }
     }
 
     if (channels == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    " Unable to get a volume on any channel");
       return -1;
@@ skipping 151 matching lines @@
   // Does the render device have a master mute control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyMute, kAudioDevicePropertyScopeOutput, 0};
   Boolean isSettable = false;
   err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                       &isSettable);
   if (err == noErr && isSettable) {
     size = sizeof(mute);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-        _outputDeviceID, &propertyAddress, 0, NULL, size, &mute));
+        _outputDeviceID, &propertyAddress, 0, nullptr, size, &mute));
 
     return 0;
   }
 
   // Otherwise try to set each channel.
   for (UInt32 i = 1; i <= _noOutputChannels; i++) {
     propertyAddress.mElement = i;
     isSettable = false;
     err = AudioObjectIsPropertySettable(_outputDeviceID, &propertyAddress,
                                         &isSettable);
     if (err == noErr && isSettable) {
       size = sizeof(mute);
       WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-          _outputDeviceID, &propertyAddress, 0, NULL, size, &mute));
+          _outputDeviceID, &propertyAddress, 0, nullptr, size, &mute));
     }
     success = true;
   }
 
   if (!success) {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  " Unable to set mute on any input channel");
     return -1;
   }
 
@@ skipping 15 matching lines @@
 
   // Does the device have a master volume control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyMute, kAudioDevicePropertyScopeOutput, 0};
   Boolean hasProperty =
       AudioObjectHasProperty(_outputDeviceID, &propertyAddress);
   if (hasProperty) {
     size = sizeof(muted);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        _outputDeviceID, &propertyAddress, 0, NULL, &size, &muted));
+        _outputDeviceID, &propertyAddress, 0, nullptr, &size, &muted));
 
     // 1 means muted
     enabled = static_cast<bool>(muted);
   } else {
     // Otherwise check if all channels are muted.
     for (UInt32 i = 1; i <= _noOutputChannels; i++) {
       muted = 0;
       propertyAddress.mElement = i;
       hasProperty = AudioObjectHasProperty(_outputDeviceID, &propertyAddress);
       if (hasProperty) {
         size = sizeof(channelMuted);
-        WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-            _outputDeviceID, &propertyAddress, 0, NULL, &size, &channelMuted));
+        WEBRTC_CA_RETURN_ON_ERR(
+            AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0,
+                                       nullptr, &size, &channelMuted));
 
         muted = (muted && channelMuted);
         channels++;
       }
     }
 
     if (channels == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    " Unable to get mute for any channel");
       return -1;
@@ skipping 92 matching lines @@
   // Does the capture device have a master mute control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyMute, kAudioDevicePropertyScopeInput, 0};
   Boolean isSettable = false;
   err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                       &isSettable);
   if (err == noErr && isSettable) {
     size = sizeof(mute);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-        _inputDeviceID, &propertyAddress, 0, NULL, size, &mute));
+        _inputDeviceID, &propertyAddress, 0, nullptr, size, &mute));
 
     return 0;
   }
 
   // Otherwise try to set each channel.
   for (UInt32 i = 1; i <= _noInputChannels; i++) {
     propertyAddress.mElement = i;
     isSettable = false;
     err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                         &isSettable);
     if (err == noErr && isSettable) {
       size = sizeof(mute);
       WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-          _inputDeviceID, &propertyAddress, 0, NULL, size, &mute));
+          _inputDeviceID, &propertyAddress, 0, nullptr, size, &mute));
     }
     success = true;
   }
 
   if (!success) {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  " Unable to set mute on any input channel");
     return -1;
   }
 
@@ skipping 15 matching lines @@
 
   // Does the device have a master volume control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyMute, kAudioDevicePropertyScopeInput, 0};
   Boolean hasProperty =
       AudioObjectHasProperty(_inputDeviceID, &propertyAddress);
   if (hasProperty) {
     size = sizeof(muted);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        _inputDeviceID, &propertyAddress, 0, NULL, &size, &muted));
+        _inputDeviceID, &propertyAddress, 0, nullptr, &size, &muted));
 
     // 1 means muted
     enabled = static_cast<bool>(muted);
   } else {
     // Otherwise check if all channels are muted.
     for (UInt32 i = 1; i <= _noInputChannels; i++) {
       muted = 0;
       propertyAddress.mElement = i;
       hasProperty = AudioObjectHasProperty(_inputDeviceID, &propertyAddress);
       if (hasProperty) {
         size = sizeof(channelMuted);
-        WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-            _inputDeviceID, &propertyAddress, 0, NULL, &size, &channelMuted));
+        WEBRTC_CA_RETURN_ON_ERR(
+            AudioObjectGetPropertyData(_inputDeviceID, &propertyAddress, 0,
+                                       nullptr, &size, &channelMuted));
 
         muted = (muted && channelMuted);
         channels++;
       }
     }
 
     if (channels == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    " Unable to get mute for any channel");
       return -1;
@@ skipping 125 matching lines @@
   // Does the capture device have a master volume control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeInput, 0};
   Boolean isSettable = false;
   err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                       &isSettable);
   if (err == noErr && isSettable) {
     size = sizeof(vol);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-        _inputDeviceID, &propertyAddress, 0, NULL, size, &vol));
+        _inputDeviceID, &propertyAddress, 0, nullptr, size, &vol));
 
     return 0;
   }
 
   // Otherwise try to set each channel.
   for (UInt32 i = 1; i <= _noInputChannels; i++) {
     propertyAddress.mElement = i;
     isSettable = false;
     err = AudioObjectIsPropertySettable(_inputDeviceID, &propertyAddress,
                                         &isSettable);
     if (err == noErr && isSettable) {
       size = sizeof(vol);
       WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-          _inputDeviceID, &propertyAddress, 0, NULL, size, &vol));
+          _inputDeviceID, &propertyAddress, 0, nullptr, size, &vol));
     }
     success = true;
   }
 
   if (!success) {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  " Unable to set a level on any input channel");
     return -1;
   }
 
@@ skipping 15 matching lines @@
 
   // Does the device have a master volume control?
   // If so, use it exclusively.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyVolumeScalar, kAudioDevicePropertyScopeInput, 0};
   Boolean hasProperty =
       AudioObjectHasProperty(_inputDeviceID, &propertyAddress);
   if (hasProperty) {
     size = sizeof(volFloat32);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        _inputDeviceID, &propertyAddress, 0, NULL, &size, &volFloat32));
+        _inputDeviceID, &propertyAddress, 0, nullptr, &size, &volFloat32));
 
     // vol 0.0 to 1.0 -> convert to 0 - 255
     volume = static_cast<uint32_t>(volFloat32 * 255 + 0.5);
   } else {
     // Otherwise get the average volume across channels.
     volFloat32 = 0;
     for (UInt32 i = 1; i <= _noInputChannels; i++) {
       channelVol = 0;
       propertyAddress.mElement = i;
       hasProperty = AudioObjectHasProperty(_inputDeviceID, &propertyAddress);
       if (hasProperty) {
         size = sizeof(channelVol);
         WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-            _inputDeviceID, &propertyAddress, 0, NULL, &size, &channelVol));
+            _inputDeviceID, &propertyAddress, 0, nullptr, &size, &channelVol));
 
         volFloat32 += channelVol;
         channels++;
       }
     }
 
     if (channels == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    " Unable to get a level on any channel");
       return -1;
@@ skipping 57 matching lines @@
 // ============================================================================
 //                                 Private Methods
 // ============================================================================
 
 // CoreAudio errors are best interpreted as four character strings.
 void AudioMixerManagerMac::logCAMsg(const TraceLevel level,
                                     const TraceModule module,
                                     const int32_t id,
                                     const char* msg,
                                     const char* err) {
-  assert(msg != NULL);
-  assert(err != NULL);
+  assert(msg != nullptr);
+  assert(err != nullptr);
 
 #ifdef WEBRTC_ARCH_BIG_ENDIAN
   WEBRTC_TRACE(level, module, id, "%s: %.4s", msg, err);
 #else
   // We need to flip the characters in this case.
   WEBRTC_TRACE(level, module, id, "%s: %.1s%.1s%.1s%.1s", msg, err + 3, err + 2,
                err + 1, err);
 #endif
 }
 
 }  // namespace webrtc
 // EOF