Add RTC_ prefix to (D)CHECKs and related macros.

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 73 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)
 {
-    DCHECK(msg != NULL);
-    DCHECK(err != NULL);
+  RTC_DCHECK(msg != NULL);
+  RTC_DCHECK(err != NULL);
 
 #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
 }
 
@@ skipping 41 matching lines @@
     _recError(0),
     _paCaptureBuffer(NULL),
     _paRenderBuffer(NULL),
     _captureBufSizeSamples(0),
     _renderBufSizeSamples(0),
     prev_key_state_()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id,
                  "%s created", __FUNCTION__);
 
-    DCHECK(&_stopEvent != NULL);
-    DCHECK(&_stopEventRec != NULL);
+    RTC_DCHECK(&_stopEvent != NULL);
+    RTC_DCHECK(&_stopEventRec != NULL);
 
     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();
     }
 
-    DCHECK(!capture_worker_thread_.get());
-    DCHECK(!render_worker_thread_.get());
+    RTC_DCHECK(!capture_worker_thread_.get());
+    RTC_DCHECK(!render_worker_thread_.get());
 
     if (_paRenderBuffer)
     {
         delete _paRenderBuffer;
         _paRenderBuffer = NULL;
     }
 
     if (_paCaptureBuffer)
     {
         delete _paCaptureBuffer;
@@ skipping 1467 matching lines @@
         return 0;
     }
 
     if (!_initialized)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      " Recording worker thread has not been started");
         return -1;
     }
 
-    DCHECK(!capture_worker_thread_.get());
+    RTC_DCHECK(!capture_worker_thread_.get());
     capture_worker_thread_ =
         ThreadWrapper::CreateThread(RunCapture, this, "CaptureWorkerThread");
-    DCHECK(capture_worker_thread_.get());
+    RTC_DCHECK(capture_worker_thread_.get());
     capture_worker_thread_->Start();
     capture_worker_thread_->SetPriority(kRealtimePriority);
 
     OSStatus err = noErr;
     if (_twoDevices)
     {
         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_inputDeviceID, _inDeviceIOProcID));
     } else if (!_playing)
     {
         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_inputDeviceID, _deviceIOProcID));
@@ skipping 131 matching lines @@
     if (!_playIsInitialized)
     {
         return -1;
     }
 
     if (_playing)
     {
         return 0;
     }
 
-    DCHECK(!render_worker_thread_.get());
+    RTC_DCHECK(!render_worker_thread_.get());
     render_worker_thread_ =
         ThreadWrapper::CreateThread(RunRender, this, "RenderWorkerThread");
     render_worker_thread_->Start();
     render_worker_thread_->SetPriority(kRealtimePriority);
 
     if (_twoDevices || !_recording)
     {
         OSStatus err = noErr;
         WEBRTC_CA_RETURN_ON_ERR(AudioDeviceStart(_outputDeviceID, _deviceIOProcID));
     }
@@ skipping 626 matching lines @@
     return 0;
 }
 
 OSStatus AudioDeviceMac::objectListenerProc(
     AudioObjectID objectId,
     UInt32 numberAddresses,
     const AudioObjectPropertyAddress addresses[],
     void* clientData)
 {
     AudioDeviceMac *ptrThis = (AudioDeviceMac *) clientData;
-    DCHECK(ptrThis != NULL);
+    RTC_DCHECK(ptrThis != NULL);
 
     ptrThis->implObjectListenerProc(objectId, numberAddresses, addresses);
 
     // AudioObjectPropertyListenerProc functions are supposed to return 0
     return 0;
 }
 
 OSStatus AudioDeviceMac::implObjectListenerProc(
     const AudioObjectID objectId,
     const UInt32 numberAddresses,
@@ skipping 265 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;
-    DCHECK(ptrThis != NULL);
+    RTC_DCHECK(ptrThis != NULL);
 
     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;
-    DCHECK(ptrThis != NULL);
+    RTC_DCHECK(ptrThis != NULL);
 
     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;
-    DCHECK(ptrThis != NULL);
+    RTC_DCHECK(ptrThis != NULL);
 
     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);
-    DCHECK(ptrThis != NULL);
+    RTC_DCHECK(ptrThis != NULL);
 
     return ptrThis->implInConverterProc(numberDataPackets, data);
 }
 
 OSStatus AudioDeviceMac::implDeviceIOProc(const AudioBufferList *inputData,
                                           const AudioTimeStamp *inputTime,
                                           AudioBufferList *outputData,
                                           const AudioTimeStamp *outputTime)
 {
     OSStatus err = noErr;
@@ skipping 36 matching lines @@
     }
 
     if (!_playing)
     {
         // This can be the case when a shared device is capturing but not
         // rendering. We allow the checks above before returning to avoid a
         // timeout when capturing is stopped.
         return 0;
     }
 
-    DCHECK(_outStreamFormat.mBytesPerFrame != 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);
     if (err != noErr)
     {
         if (err == 1)
         {
@@ skipping 20 matching lines @@
         + 0.5);
 
     AtomicSet32(&_renderDelayUs, renderDelayUs);
 
     return 0;
 }
 
 OSStatus AudioDeviceMac::implOutConverterProc(UInt32 *numberDataPackets,
                                               AudioBufferList *data)
 {
-    DCHECK(data->mNumberBuffers == 1);
+  RTC_DCHECK(data->mNumberBuffers == 1);
     PaRingBufferSize numSamples = *numberDataPackets
         * _outDesiredFormat.mChannelsPerFrame;
 
     data->mBuffers->mNumberChannels = _outDesiredFormat.mChannelsPerFrame;
     // Always give the converter as much as it wants, zero padding as required.
     data->mBuffers->mDataByteSize = *numberDataPackets
         * _outDesiredFormat.mBytesPerPacket;
     data->mBuffers->mData = _renderConvertData;
     memset(_renderConvertData, 0, sizeof(_renderConvertData));
 
@@ skipping 53 matching lines @@
 
     int32_t captureDelayUs = static_cast<int32_t> (1e-3 * (nowNs - inputTimeNs)
         + 0.5);
     captureDelayUs
         += static_cast<int32_t> ((1.0e6 * bufSizeSamples)
             / _inStreamFormat.mChannelsPerFrame / _inStreamFormat.mSampleRate
             + 0.5);
 
     AtomicSet32(&_captureDelayUs, captureDelayUs);
 
-    DCHECK(inputData->mNumberBuffers == 1);
+    RTC_DCHECK(inputData->mNumberBuffers == 1);
     PaRingBufferSize numSamples = inputData->mBuffers->mDataByteSize
         * _inStreamFormat.mChannelsPerFrame / _inStreamFormat.mBytesPerPacket;
     PaUtil_WriteRingBuffer(_paCaptureBuffer, inputData->mBuffers->mData,
                            numSamples);
 
     kern_return_t kernErr = semaphore_signal_all(_captureSemaphore);
     if (kernErr != KERN_SUCCESS)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      " semaphore_signal_all() error: %d", kernErr);
     }
 
     return err;
 }
 
 OSStatus AudioDeviceMac::implInConverterProc(UInt32 *numberDataPackets,
                                              AudioBufferList *data)
 {
-    DCHECK(data->mNumberBuffers == 1);
+  RTC_DCHECK(data->mNumberBuffers == 1);
     PaRingBufferSize numSamples = *numberDataPackets
         * _inStreamFormat.mChannelsPerFrame;
 
     while (PaUtil_GetRingBufferReadAvailable(_paCaptureBuffer) < numSamples)
     {
         mach_timespec_t timeout;
         timeout.tv_sec = 0;
         timeout.tv_nsec = TIMER_PERIOD_MS;
 
         kern_return_t kernErr = semaphore_timedwait(_captureSemaphore, timeout);
@@ skipping 232 matching lines @@
                              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