Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/mac/audio_device_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 61 matching lines @@
     }
   }
 }
 
 // CoreAudio errors are best interpreted as four character strings.
 void AudioDeviceMac::logCAMsg(const TraceLevel level,
                               const TraceModule module,
                               const int32_t id,
                               const char* msg,
                               const char* err) {
-  RTC_DCHECK(msg != NULL);
-  RTC_DCHECK(err != NULL);
+  RTC_DCHECK(msg != nullptr);
+  RTC_DCHECK(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
 }
 
 AudioDeviceMac::AudioDeviceMac(const int32_t id)
-    : _ptrAudioBuffer(NULL),
+    : _ptrAudioBuffer(nullptr),
       _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
       _stopEventRec(*EventWrapper::Create()),
       _stopEvent(*EventWrapper::Create()),
       _id(id),
       _mixerManager(id),
       _inputDeviceIndex(0),
       _outputDeviceIndex(0),
       _inputDeviceID(kAudioObjectUnknown),
       _outputDeviceID(kAudioObjectUnknown),
       _inputDeviceIsSpecified(false),
       _outputDeviceIsSpecified(false),
       _recChannels(N_REC_CHANNELS),
       _playChannels(N_PLAY_CHANNELS),
-      _captureBufData(NULL),
-      _renderBufData(NULL),
+      _captureBufData(nullptr),
+      _renderBufData(nullptr),
       _playBufType(AudioDeviceModule::kFixedBufferSize),
       _initialized(false),
       _isShutDown(false),
       _recording(false),
       _playing(false),
       _recIsInitialized(false),
       _playIsInitialized(false),
       _AGC(false),
       _renderDeviceIsAlive(1),
       _captureDeviceIsAlive(1),
       _twoDevices(true),
       _doStop(false),
       _doStopRec(false),
       _macBookPro(false),
       _macBookProPanRight(false),
       _captureLatencyUs(0),
       _renderLatencyUs(0),
       _captureDelayUs(0),
       _renderDelayUs(0),
       _renderDelayOffsetSamples(0),
       _playBufDelayFixed(20),
       _playWarning(0),
       _playError(0),
       _recWarning(0),
       _recError(0),
-      _paCaptureBuffer(NULL),
-      _paRenderBuffer(NULL),
+      _paCaptureBuffer(nullptr),
+      _paRenderBuffer(nullptr),
       _captureBufSizeSamples(0),
       _renderBufSizeSamples(0),
       prev_key_state_(),
       get_mic_volume_counter_ms_(0) {
   WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
 
-  RTC_DCHECK(&_stopEvent != NULL);
-  RTC_DCHECK(&_stopEventRec != NULL);
+  RTC_DCHECK(&_stopEvent);
+  RTC_DCHECK(&_stopEventRec);
 
   memset(_renderConvertData, 0, sizeof(_renderConvertData));
   memset(&_outStreamFormat, 0, sizeof(AudioStreamBasicDescription));
   memset(&_outDesiredFormat, 0, sizeof(AudioStreamBasicDescription));
   memset(&_inStreamFormat, 0, sizeof(AudioStreamBasicDescription));
   memset(&_inDesiredFormat, 0, sizeof(AudioStreamBasicDescription));
 }
 
 AudioDeviceMac::~AudioDeviceMac() {
   WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destroyed",
                __FUNCTION__);
 
   if (!_isShutDown) {
     Terminate();
   }
 
   RTC_DCHECK(!capture_worker_thread_.get());
   RTC_DCHECK(!render_worker_thread_.get());
 
   if (_paRenderBuffer) {
     delete _paRenderBuffer;
-    _paRenderBuffer = NULL;
+    _paRenderBuffer = nullptr;
   }
 
   if (_paCaptureBuffer) {
     delete _paCaptureBuffer;
-    _paCaptureBuffer = NULL;
+    _paCaptureBuffer = nullptr;
   }
 
   if (_renderBufData) {
     delete[] _renderBufData;
-    _renderBufData = NULL;
+    _renderBufData = nullptr;
   }
 
   if (_captureBufData) {
     delete[] _captureBufData;
-    _captureBufData = NULL;
+    _captureBufData = nullptr;
   }
 
   kern_return_t kernErr = KERN_SUCCESS;
   kernErr = semaphore_destroy(mach_task_self(), _renderSemaphore);
   if (kernErr != KERN_SUCCESS) {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                  " semaphore_destroy() error: %d", kernErr);
   }
 
   kernErr = semaphore_destroy(mach_task_self(), _captureSemaphore);
@@ skipping 34 matching lines @@
 
   if (_initialized) {
     return InitStatus::OK;
   }
 
   OSStatus err = noErr;
 
   _isShutDown = false;
 
   // PortAudio ring buffers require an elementCount which is a power of two.
-  if (_renderBufData == NULL) {
+  if (_renderBufData == nullptr) {
     UInt32 powerOfTwo = 1;
     while (powerOfTwo < PLAY_BUF_SIZE_IN_SAMPLES) {
       powerOfTwo <<= 1;
     }
     _renderBufSizeSamples = powerOfTwo;
     _renderBufData = new SInt16[_renderBufSizeSamples];
   }
 
-  if (_paRenderBuffer == NULL) {
+  if (_paRenderBuffer == nullptr) {
     _paRenderBuffer = new PaUtilRingBuffer;
     PaRingBufferSize bufSize = -1;
     bufSize = PaUtil_InitializeRingBuffer(
         _paRenderBuffer, sizeof(SInt16), _renderBufSizeSamples, _renderBufData);
     if (bufSize == -1) {
       WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
                    " PaUtil_InitializeRingBuffer() error");
       return InitStatus::PLAYOUT_ERROR;
     }
   }
 
-  if (_captureBufData == NULL) {
+  if (_captureBufData == nullptr) {
     UInt32 powerOfTwo = 1;
     while (powerOfTwo < REC_BUF_SIZE_IN_SAMPLES) {
       powerOfTwo <<= 1;
     }
     _captureBufSizeSamples = powerOfTwo;
     _captureBufData = new Float32[_captureBufSizeSamples];
   }
 
-  if (_paCaptureBuffer == NULL) {
+  if (_paCaptureBuffer == nullptr) {
     _paCaptureBuffer = new PaUtilRingBuffer;
     PaRingBufferSize bufSize = -1;
     bufSize =
         PaUtil_InitializeRingBuffer(_paCaptureBuffer, sizeof(Float32),
                                     _captureBufSizeSamples, _captureBufData);
     if (bufSize == -1) {
       WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
                    " PaUtil_InitializeRingBuffer() error");
       return InitStatus::RECORDING_ERROR;
     }
   }
 
   kern_return_t kernErr = KERN_SUCCESS;
   kernErr = semaphore_create(mach_task_self(), &_renderSemaphore,
                              SYNC_POLICY_FIFO, 0);
   if (kernErr != KERN_SUCCESS) {
     WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
                  " semaphore_create() error: %d", kernErr);
     return InitStatus::OTHER_ERROR;
   }
 
   kernErr = semaphore_create(mach_task_self(), &_captureSemaphore,
                              SYNC_POLICY_FIFO, 0);
   if (kernErr != KERN_SUCCESS) {
     WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
                  " semaphore_create() error: %d", kernErr);
     return InitStatus::OTHER_ERROR;
   }
 
-  // Setting RunLoop to NULL here instructs HAL to manage its own thread for
+  // Setting RunLoop to null here instructs HAL to manage its own thread for
   // notifications. This was the default behaviour on OS X 10.5 and earlier,
   // but now must be explicitly specified. HAL would otherwise try to use the
   // main thread to issue notifications.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
-  CFRunLoopRef runLoop = NULL;
+  CFRunLoopRef runLoop = nullptr;
   UInt32 size = sizeof(CFRunLoopRef);
   int aoerr = AudioObjectSetPropertyData(
-      kAudioObjectSystemObject, &propertyAddress, 0, NULL, size, &runLoop);
+      kAudioObjectSystemObject, &propertyAddress, 0, nullptr, size, &runLoop);
   if (aoerr != noErr) {
     LOG(LS_ERROR) << "Error in AudioObjectSetPropertyData: "
                   << (const char*)&aoerr;
     return InitStatus::OTHER_ERROR;
   }
 
   // Listen for any device changes.
   propertyAddress.mSelector = kAudioHardwarePropertyDevices;
   WEBRTC_CA_LOG_ERR(AudioObjectAddPropertyListener(
       kAudioObjectSystemObject, &propertyAddress, &objectListenerProc, this));
 
   // Determine if this is a MacBook Pro
   _macBookPro = false;
   _macBookProPanRight = false;
   char buf[128];
   size_t length = sizeof(buf);
   memset(buf, 0, length);
 
-  int intErr = sysctlbyname("hw.model", buf, &length, NULL, 0);
+  int intErr = sysctlbyname("hw.model", buf, &length, nullptr, 0);
   if (intErr != 0) {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                  " Error in sysctlbyname(): %d", err);
   } else {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Hardware model: %s",
                  buf);
     if (strncmp(buf, "MacBookPro", 10) == 0) {
       _macBookPro = true;
     }
   }
@@ skipping 594 matching lines @@
   WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                "WindowsDeviceType not supported");
   return -1;
 }
 
 int32_t AudioDeviceMac::PlayoutDeviceName(uint16_t index,
                                           char name[kAdmMaxDeviceNameSize],
                                           char guid[kAdmMaxGuidSize]) {
   const uint16_t nDevices(PlayoutDevices());
 
-  if ((index > (nDevices - 1)) || (name == NULL)) {
+  if ((index > (nDevices - 1)) || (name == nullptr)) {
     return -1;
   }
 
   memset(name, 0, kAdmMaxDeviceNameSize);
 
-  if (guid != NULL) {
+  if (guid != nullptr) {
     memset(guid, 0, kAdmMaxGuidSize);
   }
 
   return GetDeviceName(kAudioDevicePropertyScopeOutput, index, name);
 }
 
 int32_t AudioDeviceMac::RecordingDeviceName(uint16_t index,
                                             char name[kAdmMaxDeviceNameSize],
                                             char guid[kAdmMaxGuidSize]) {
   const uint16_t nDevices(RecordingDevices());
 
-  if ((index > (nDevices - 1)) || (name == NULL)) {
+  if ((index > (nDevices - 1)) || (name == nullptr)) {
     return -1;
   }
 
   memset(name, 0, kAdmMaxDeviceNameSize);
 
-  if (guid != NULL) {
+  if (guid != nullptr) {
     memset(guid, 0, kAdmMaxGuidSize);
   }
 
   return GetDeviceName(kAudioDevicePropertyScopeInput, index, name);
 }
 
 int16_t AudioDeviceMac::RecordingDevices() {
   AudioDeviceID recDevices[MaxNumberDevices];
   return GetNumberDevices(kAudioDevicePropertyScopeInput, recDevices,
                           MaxNumberDevices);
@@ skipping 123 matching lines @@
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput, 0};
   if (_macBookPro) {
     _macBookProPanRight = false;
     Boolean hasProperty =
         AudioObjectHasProperty(_outputDeviceID, &propertyAddress);
     if (hasProperty) {
       UInt32 dataSource = 0;
       size = sizeof(dataSource);
       WEBRTC_CA_LOG_WARN(AudioObjectGetPropertyData(
-          _outputDeviceID, &propertyAddress, 0, NULL, &size, &dataSource));
+          _outputDeviceID, &propertyAddress, 0, nullptr, &size, &dataSource));
 
       if (dataSource == 'ispk') {
         _macBookProPanRight = true;
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                      "MacBook Pro using internal speakers; stereo"
                      " panning right");
       } else {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                      "MacBook Pro not using internal speakers");
       }
 
       // Add a listener to determine if the status changes.
       WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(
           _outputDeviceID, &propertyAddress, &objectListenerProc, this));
     }
   }
 
   // Get current stream description
   propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   memset(&_outStreamFormat, 0, sizeof(_outStreamFormat));
   size = sizeof(_outStreamFormat);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &_outStreamFormat));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &_outStreamFormat));
 
   if (_outStreamFormat.mFormatID != kAudioFormatLinearPCM) {
     logCAMsg(kTraceError, kTraceAudioDevice, _id,
              "Unacceptable output stream format -> mFormatID",
              (const char*)&_outStreamFormat.mFormatID);
     return -1;
   }
 
   if (_outStreamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS) {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
@@ skipping 96 matching lines @@
   _captureLatencyUs = 0;
   _captureDeviceIsAlive = 1;
   _doStopRec = false;
 
   // Get current stream description
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeInput, 0};
   memset(&_inStreamFormat, 0, sizeof(_inStreamFormat));
   size = sizeof(_inStreamFormat);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &_inStreamFormat));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &_inStreamFormat));
 
   if (_inStreamFormat.mFormatID != kAudioFormatLinearPCM) {
     logCAMsg(kTraceError, kTraceAudioDevice, _id,
              "Unacceptable input stream format -> mFormatID",
              (const char*)&_inStreamFormat.mFormatID);
     return -1;
   }
 
   if (_inStreamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS) {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
@@ skipping 75 matching lines @@
           _inStreamFormat.mFramesPerPacket;
     }
   }
 
   // Ensure the buffer size is within the acceptable range provided by the
   // device.
   propertyAddress.mSelector = kAudioDevicePropertyBufferSizeRange;
   AudioValueRange range;
   size = sizeof(range);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &range));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &range));
   if (range.mMinimum > bufByteCount) {
     bufByteCount = range.mMinimum;
   } else if (range.mMaximum < bufByteCount) {
     bufByteCount = range.mMaximum;
   }
 
   propertyAddress.mSelector = kAudioDevicePropertyBufferSize;
   size = sizeof(bufByteCount);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, size, &bufByteCount));
+      _inputDeviceID, &propertyAddress, 0, nullptr, size, &bufByteCount));
 
   // Get capture device latency
   propertyAddress.mSelector = kAudioDevicePropertyLatency;
   UInt32 latency = 0;
   size = sizeof(UInt32);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &latency));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &latency));
   _captureLatencyUs = (UInt32)((1.0e6 * latency) / _inStreamFormat.mSampleRate);
 
   // Get capture stream latency
   propertyAddress.mSelector = kAudioDevicePropertyStreams;
   AudioStreamID stream = 0;
   size = sizeof(AudioStreamID);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &stream));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &stream));
   propertyAddress.mSelector = kAudioStreamPropertyLatency;
   size = sizeof(UInt32);
   latency = 0;
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _inputDeviceID, &propertyAddress, 0, NULL, &size, &latency));
+      _inputDeviceID, &propertyAddress, 0, nullptr, &size, &latency));
   _captureLatencyUs +=
       (UInt32)((1.0e6 * latency) / _inStreamFormat.mSampleRate);
 
   // Listen for format changes
   // TODO(xians): should we be using kAudioDevicePropertyDeviceHasChanged?
   propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(
       _inputDeviceID, &propertyAddress, &objectListenerProc, this));
 
   // Listen for processor overloads
@@ skipping 341 matching lines @@
 int32_t AudioDeviceMac::GetNumberDevices(const AudioObjectPropertyScope scope,
                                          AudioDeviceID scopedDeviceIds[],
                                          const uint32_t deviceListLength) {
   OSStatus err = noErr;
 
   AudioObjectPropertyAddress propertyAddress = {
       kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
   UInt32 size = 0;
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyDataSize(
-      kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size));
+      kAudioObjectSystemObject, &propertyAddress, 0, nullptr, &size));
   if (size == 0) {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "No devices");
     return 0;
   }
 
   AudioDeviceID* deviceIds = (AudioDeviceID*)malloc(size);
   UInt32 numberDevices = size / sizeof(AudioDeviceID);
-  AudioBufferList* bufferList = NULL;
+  AudioBufferList* bufferList = nullptr;
   UInt32 numberScopedDevices = 0;
 
   // First check if there is a default device and list it
   UInt32 hardwareProperty = 0;
   if (scope == kAudioDevicePropertyScopeOutput) {
     hardwareProperty = kAudioHardwarePropertyDefaultOutputDevice;
   } else {
     hardwareProperty = kAudioHardwarePropertyDefaultInputDevice;
   }
 
   AudioObjectPropertyAddress propertyAddressDefault = {
       hardwareProperty, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
 
   AudioDeviceID usedID;
   UInt32 uintSize = sizeof(UInt32);
-  WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
-                                                     &propertyAddressDefault, 0,
-                                                     NULL, &uintSize, &usedID));
+  WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
+      kAudioObjectSystemObject, &propertyAddressDefault, 0, nullptr, &uintSize,
+      &usedID));
   if (usedID != kAudioDeviceUnknown) {
     scopedDeviceIds[numberScopedDevices] = usedID;
     numberScopedDevices++;
   } else {
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  "GetNumberDevices(): Default device unknown");
   }
 
   // Then list the rest of the devices
   bool listOK = true;
 
-  WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(
-      kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, deviceIds));
+  WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
+                                               &propertyAddress, 0, nullptr,
+                                               &size, deviceIds));
   if (err != noErr) {
     listOK = false;
   } else {
     propertyAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
     propertyAddress.mScope = scope;
     propertyAddress.mElement = 0;
     for (UInt32 i = 0; i < numberDevices; i++) {
       // Check for input channels
       WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyDataSize(
-          deviceIds[i], &propertyAddress, 0, NULL, &size));
+          deviceIds[i], &propertyAddress, 0, nullptr, &size));
       if (err == kAudioHardwareBadDeviceError) {
         // This device doesn't actually exist; continue iterating.
         continue;
       } else if (err != noErr) {
         listOK = false;
         break;
       }
 
       bufferList = (AudioBufferList*)malloc(size);
       WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(
-          deviceIds[i], &propertyAddress, 0, NULL, &size, bufferList));
+          deviceIds[i], &propertyAddress, 0, nullptr, &size, bufferList));
       if (err != noErr) {
         listOK = false;
         break;
       }
 
       if (bufferList->mNumberBuffers > 0) {
         if (numberScopedDevices >= deviceListLength) {
           WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                        "Device list is not long enough");
           listOK = false;
           break;
         }
 
         scopedDeviceIds[numberScopedDevices] = deviceIds[i];
         numberScopedDevices++;
       }
 
       free(bufferList);
-      bufferList = NULL;
+      bufferList = nullptr;
     }  // for
   }
 
   if (!listOK) {
     if (deviceIds) {
       free(deviceIds);
-      deviceIds = NULL;
+      deviceIds = nullptr;
     }
 
     if (bufferList) {
       free(bufferList);
-      bufferList = NULL;
+      bufferList = nullptr;
     }
 
     return -1;
   }
 
   // Happy ending
   if (deviceIds) {
     free(deviceIds);
-    deviceIds = NULL;
+    deviceIds = nullptr;
   }
 
   return numberScopedDevices;
 }
 
 int32_t AudioDeviceMac::GetDeviceName(const AudioObjectPropertyScope scope,
                                       const uint16_t index,
                                       char* name) {
   OSStatus err = noErr;
   UInt32 len = kAdmMaxDeviceNameSize;
@@ skipping 17 matching lines @@
     UInt32 hardwareProperty = 0;
     if (scope == kAudioDevicePropertyScopeOutput) {
       hardwareProperty = kAudioHardwarePropertyDefaultOutputDevice;
     } else {
       hardwareProperty = kAudioHardwarePropertyDefaultInputDevice;
     }
     AudioObjectPropertyAddress propertyAddress = {
         hardwareProperty, kAudioObjectPropertyScopeGlobal,
         kAudioObjectPropertyElementMaster};
     UInt32 size = sizeof(UInt32);
-    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, &usedID));
+    WEBRTC_CA_RETURN_ON_ERR(
+        AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress,
+                                   0, nullptr, &size, &usedID));
     if (usedID == kAudioDeviceUnknown) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    "GetDeviceName(): Default device unknown");
     } else {
       isDefaultDevice = true;
     }
   }
 
   AudioObjectPropertyAddress propertyAddress = {kAudioDevicePropertyDeviceName,
                                                 scope, 0};
 
   if (isDefaultDevice) {
     char devName[len];
 
-    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(usedID, &propertyAddress,
-                                                       0, NULL, &len, devName));
+    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
+        usedID, &propertyAddress, 0, nullptr, &len, devName));
 
     sprintf(name, "default (%s)", devName);
   } else {
     if (index < numberDevices) {
       usedID = deviceIds[index];
     } else {
       usedID = index;
     }
 
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(usedID, &propertyAddress,
-                                                       0, NULL, &len, name));
+                                                       0, nullptr, &len, name));
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::InitDevice(const uint16_t userDeviceIndex,
                                    AudioDeviceID& deviceId,
                                    const bool isInput) {
   OSStatus err = noErr;
   UInt32 size = 0;
@@ skipping 22 matching lines @@
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                  "InitDevice(): No devices");
     return -1;
   }
 
   bool isDefaultDevice = false;
   deviceId = kAudioDeviceUnknown;
   if (userDeviceIndex == 0) {
     // Try to use default system device
     size = sizeof(AudioDeviceID);
-    WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, &deviceId));
+    WEBRTC_CA_RETURN_ON_ERR(
+        AudioObjectGetPropertyData(kAudioObjectSystemObject, &propertyAddress,
+                                   0, nullptr, &size, &deviceId));
     if (deviceId == kAudioDeviceUnknown) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    " No default device exists");
     } else {
       isDefaultDevice = true;
     }
   }
 
   if (!isDefaultDevice) {
     deviceId = deviceIds[userDeviceIndex];
   }
 
   // Obtain device name and manufacturer for logging.
   // Also use this as a test to ensure a user-set device ID is valid.
   char devName[128];
   char devManf[128];
   memset(devName, 0, sizeof(devName));
   memset(devManf, 0, sizeof(devManf));
 
   propertyAddress.mSelector = kAudioDevicePropertyDeviceName;
   propertyAddress.mScope = deviceScope;
   propertyAddress.mElement = 0;
   size = sizeof(devName);
-  WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId, &propertyAddress,
-                                                     0, NULL, &size, devName));
+  WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
+      deviceId, &propertyAddress, 0, nullptr, &size, devName));
 
   propertyAddress.mSelector = kAudioDevicePropertyDeviceManufacturer;
   size = sizeof(devManf);
-  WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId, &propertyAddress,
-                                                     0, NULL, &size, devManf));
+  WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
+      deviceId, &propertyAddress, 0, nullptr, &size, devManf));
 
   if (isInput) {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Input device: %s %s",
                  devManf, devName);
   } else {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Output device: %s %s",
                  devManf, devName);
   }
 
   return 0;
@@ skipping 46 matching lines @@
     }
   }
 
   // Ensure the buffer size is within the range provided by the device.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyDataSource, kAudioDevicePropertyScopeOutput, 0};
   propertyAddress.mSelector = kAudioDevicePropertyBufferSizeRange;
   AudioValueRange range;
   UInt32 size = sizeof(range);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &range));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &range));
   if (range.mMinimum > bufByteCount) {
     bufByteCount = range.mMinimum;
   } else if (range.mMaximum < bufByteCount) {
     bufByteCount = range.mMaximum;
   }
 
   propertyAddress.mSelector = kAudioDevicePropertyBufferSize;
   size = sizeof(bufByteCount);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectSetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, size, &bufByteCount));
+      _outputDeviceID, &propertyAddress, 0, nullptr, size, &bufByteCount));
 
   // Get render device latency.
   propertyAddress.mSelector = kAudioDevicePropertyLatency;
   UInt32 latency = 0;
   size = sizeof(UInt32);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &latency));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &latency));
   _renderLatencyUs =
       static_cast<uint32_t>((1.0e6 * latency) / _outStreamFormat.mSampleRate);
 
   // Get render stream latency.
   propertyAddress.mSelector = kAudioDevicePropertyStreams;
   AudioStreamID stream = 0;
   size = sizeof(AudioStreamID);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &stream));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &stream));
   propertyAddress.mSelector = kAudioStreamPropertyLatency;
   size = sizeof(UInt32);
   latency = 0;
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      _outputDeviceID, &propertyAddress, 0, NULL, &size, &latency));
+      _outputDeviceID, &propertyAddress, 0, nullptr, &size, &latency));
   _renderLatencyUs +=
       static_cast<uint32_t>((1.0e6 * latency) / _outStreamFormat.mSampleRate);
 
   WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                "  initial playout status: _renderDelayOffsetSamples=%d,"
                " _renderDelayUs=%d, _renderLatencyUs=%d",
                _renderDelayOffsetSamples, _renderDelayUs, _renderLatencyUs);
   return 0;
 }
 
 OSStatus AudioDeviceMac::objectListenerProc(
     AudioObjectID objectId,
     UInt32 numberAddresses,
     const AudioObjectPropertyAddress addresses[],
     void* clientData) {
   AudioDeviceMac* ptrThis = (AudioDeviceMac*)clientData;
-  RTC_DCHECK(ptrThis != NULL);
+  RTC_DCHECK(ptrThis != nullptr);
 
   ptrThis->implObjectListenerProc(objectId, numberAddresses, addresses);
 
   // AudioObjectPropertyListenerProc functions are supposed to return 0
   return 0;
 }
 
 OSStatus AudioDeviceMac::implObjectListenerProc(
     const AudioObjectID objectId,
     const UInt32 numberAddresses,
@@ skipping 22 matching lines @@
   WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
                "kAudioHardwarePropertyDevices");
 
   // A device has changed. Check if our registered devices have been removed.
   // Ensure the devices have been initialized, meaning the IDs are valid.
   if (MicrophoneIsInitialized()) {
     AudioObjectPropertyAddress propertyAddress = {
         kAudioDevicePropertyDeviceIsAlive, kAudioDevicePropertyScopeInput, 0};
     UInt32 deviceIsAlive = 1;
     UInt32 size = sizeof(UInt32);
-    err = AudioObjectGetPropertyData(_inputDeviceID, &propertyAddress, 0, NULL,
-                                     &size, &deviceIsAlive);
+    err = AudioObjectGetPropertyData(_inputDeviceID, &propertyAddress, 0,
+                                     nullptr, &size, &deviceIsAlive);
 
     if (err == kAudioHardwareBadDeviceError || deviceIsAlive == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    "Capture device is not alive (probably removed)");
       AtomicSet32(&_captureDeviceIsAlive, 0);
       _mixerManager.CloseMicrophone();
       if (_recError == 1) {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  pending recording error exists");
       }
       _recError = 1;  // triggers callback from module process thread
     } else if (err != noErr) {
       logCAMsg(kTraceError, kTraceAudioDevice, _id,
                "Error in AudioDeviceGetProperty()", (const char*)&err);
       return -1;
     }
   }
 
   if (SpeakerIsInitialized()) {
     AudioObjectPropertyAddress propertyAddress = {
         kAudioDevicePropertyDeviceIsAlive, kAudioDevicePropertyScopeOutput, 0};
     UInt32 deviceIsAlive = 1;
     UInt32 size = sizeof(UInt32);
-    err = AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0, NULL,
-                                     &size, &deviceIsAlive);
+    err = AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0,
+                                     nullptr, &size, &deviceIsAlive);
 
     if (err == kAudioHardwareBadDeviceError || deviceIsAlive == 0) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    "Render device is not alive (probably removed)");
       AtomicSet32(&_renderDeviceIsAlive, 0);
       _mixerManager.CloseSpeaker();
       if (_playError == 1) {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  pending playout error exists");
       }
@@ skipping 16 matching lines @@
   WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "Stream format changed");
 
   if (objectId != _inputDeviceID && objectId != _outputDeviceID) {
     return 0;
   }
 
   // Get the new device format
   AudioStreamBasicDescription streamFormat;
   UInt32 size = sizeof(streamFormat);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-      objectId, &propertyAddress, 0, NULL, &size, &streamFormat));
+      objectId, &propertyAddress, 0, nullptr, &size, &streamFormat));
 
   if (streamFormat.mFormatID != kAudioFormatLinearPCM) {
     logCAMsg(kTraceError, kTraceAudioDevice, _id,
              "Unacceptable input stream format -> mFormatID",
              (const char*)&streamFormat.mFormatID);
     return -1;
   }
 
   if (streamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS) {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
@@ skipping 72 matching lines @@
   OSStatus err = noErr;
 
   if (_macBookPro &&
       propertyAddress.mScope == kAudioDevicePropertyScopeOutput) {
     WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "Data source changed");
 
     _macBookProPanRight = false;
     UInt32 dataSource = 0;
     UInt32 size = sizeof(UInt32);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
-        objectId, &propertyAddress, 0, NULL, &size, &dataSource));
+        objectId, &propertyAddress, 0, nullptr, &size, &dataSource));
     if (dataSource == 'ispk') {
       _macBookProPanRight = true;
       WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                    "MacBook Pro using internal speakers; stereo panning right");
     } else {
       WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                    "MacBook Pro not using internal speakers");
     }
   }
 
@@ skipping 27 matching lines @@
 // ============================================================================
 
 OSStatus AudioDeviceMac::deviceIOProc(AudioDeviceID,
                                       const AudioTimeStamp*,
                                       const AudioBufferList* inputData,
                                       const AudioTimeStamp* inputTime,
                                       AudioBufferList* outputData,
                                       const AudioTimeStamp* outputTime,
                                       void* clientData) {
   AudioDeviceMac* ptrThis = (AudioDeviceMac*)clientData;
-  RTC_DCHECK(ptrThis != NULL);
+  RTC_DCHECK(ptrThis != nullptr);
 
   ptrThis->implDeviceIOProc(inputData, inputTime, outputData, outputTime);
 
   // AudioDeviceIOProc functions are supposed to return 0
   return 0;
 }
 
 OSStatus AudioDeviceMac::outConverterProc(AudioConverterRef,
                                           UInt32* numberDataPackets,
                                           AudioBufferList* data,
                                           AudioStreamPacketDescription**,
                                           void* userData) {
   AudioDeviceMac* ptrThis = (AudioDeviceMac*)userData;
-  RTC_DCHECK(ptrThis != NULL);
+  RTC_DCHECK(ptrThis != nullptr);
 
   return ptrThis->implOutConverterProc(numberDataPackets, data);
 }
 
 OSStatus AudioDeviceMac::inDeviceIOProc(AudioDeviceID,
                                         const AudioTimeStamp*,
                                         const AudioBufferList* inputData,
                                         const AudioTimeStamp* inputTime,
                                         AudioBufferList*,
                                         const AudioTimeStamp*,
                                         void* clientData) {
   AudioDeviceMac* ptrThis = (AudioDeviceMac*)clientData;
-  RTC_DCHECK(ptrThis != NULL);
+  RTC_DCHECK(ptrThis != nullptr);
 
   ptrThis->implInDeviceIOProc(inputData, inputTime);
 
   // AudioDeviceIOProc functions are supposed to return 0
   return 0;
 }
 
 OSStatus AudioDeviceMac::inConverterProc(
     AudioConverterRef,
     UInt32* numberDataPackets,
     AudioBufferList* data,
     AudioStreamPacketDescription** /*dataPacketDescription*/,
     void* userData) {
   AudioDeviceMac* ptrThis = static_cast<AudioDeviceMac*>(userData);
-  RTC_DCHECK(ptrThis != NULL);
+  RTC_DCHECK(ptrThis != nullptr);
 
   return ptrThis->implInConverterProc(numberDataPackets, data);
 }
 
 OSStatus AudioDeviceMac::implDeviceIOProc(const AudioBufferList* inputData,
                                           const AudioTimeStamp* inputTime,
                                           AudioBufferList* outputData,
                                           const AudioTimeStamp* outputTime) {
   OSStatus err = noErr;
   UInt64 outputTimeNs = AudioConvertHostTimeToNanos(outputTime->mHostTime);
@@ skipping 34 matching lines @@
     // timeout when capturing is stopped.
     return 0;
   }
 
   RTC_DCHECK(_outStreamFormat.mBytesPerFrame != 0);
   UInt32 size =
       outputData->mBuffers->mDataByteSize / _outStreamFormat.mBytesPerFrame;
 
   // TODO(xians): signal an error somehow?
   err = AudioConverterFillComplexBuffer(_renderConverter, outConverterProc,
-                                        this, &size, outputData, NULL);
+                                        this, &size, outputData, nullptr);
   if (err != noErr) {
     if (err == 1) {
       // This is our own error.
       WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                    " Error in AudioConverterFillComplexBuffer()");
       return 1;
     } else {
       logCAMsg(kTraceError, kTraceAudioDevice, _id,
                "Error in AudioConverterFillComplexBuffer()", (const char*)&err);
       return 1;
@@ skipping 226 matching lines @@
   UInt32 size = ENGINE_REC_BUF_SIZE_IN_SAMPLES;
 
   AudioBufferList engineBuffer;
   engineBuffer.mNumberBuffers = 1;  // Interleaved channels.
   engineBuffer.mBuffers->mNumberChannels = _inDesiredFormat.mChannelsPerFrame;
   engineBuffer.mBuffers->mDataByteSize =
       _inDesiredFormat.mBytesPerPacket * noRecSamples;
   engineBuffer.mBuffers->mData = recordBuffer;
 
   err = AudioConverterFillComplexBuffer(_captureConverter, inConverterProc,
-                                        this, &size, &engineBuffer, NULL);
+                                        this, &size, &engineBuffer, nullptr);
   if (err != noErr) {
     if (err == 1) {
       // This is our own error.
       return false;
     } else {
       logCAMsg(kTraceError, kTraceAudioDevice, _id,
                "Error in AudioConverterFillComplexBuffer()", (const char*)&err);
       return false;
     }
   }
@@ skipping 74 matching lines @@
     bool keyState =
         CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, key_index);
     // A false -> true change in keymap means a key is pressed.
     key_down |= (keyState && !prev_key_state_[key_index]);
     // Save current state.
     prev_key_state_[key_index] = keyState;
   }
   return key_down;
 }
 }  // namespace webrtc