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

webrtc/modules/audio_device/linux/audio_device_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 88 matching lines @@
     memset(_paServerVersion, 0, sizeof(_paServerVersion));
     memset(&_playBufferAttr, 0, sizeof(_playBufferAttr));
     memset(&_recBufferAttr, 0, sizeof(_recBufferAttr));
     memset(_oldKeyState, 0, sizeof(_oldKeyState));
 }
 
 AudioDeviceLinuxPulse::~AudioDeviceLinuxPulse()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                  "%s destroyed", __FUNCTION__);
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     Terminate();
 
     if (_recBuffer)
     {
         delete [] _recBuffer;
         _recBuffer = NULL;
     }
     if (_playBuffer)
     {
         delete [] _playBuffer;
@@ skipping 12 matching lines @@
 
     delete &_recStartEvent;
     delete &_playStartEvent;
     delete &_timeEventRec;
     delete &_timeEventPlay;
     delete &_critSect;
 }
 
 void AudioDeviceLinuxPulse::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
     _ptrAudioBuffer = audioBuffer;
 
     // Inform the AudioBuffer about default settings for this implementation.
     // Set all values to zero here since the actual settings will be done by
     // InitPlayout and InitRecording later.
     _ptrAudioBuffer->SetRecordingSampleRate(0);
     _ptrAudioBuffer->SetPlayoutSampleRate(0);
     _ptrAudioBuffer->SetRecordingChannels(0);
     _ptrAudioBuffer->SetPlayoutChannels(0);
 }
 
 // ----------------------------------------------------------------------------
 //  ActiveAudioLayer
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceLinuxPulse::ActiveAudioLayer(
     AudioDeviceModule::AudioLayer& audioLayer) const
 {
     audioLayer = AudioDeviceModule::kLinuxPulseAudio;
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::Init()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_initialized)
     {
         return 0;
     }
 
     // Initialize PulseAudio
     if (InitPulseAudio() < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "  failed to initialize PulseAudio");
@@ skipping 49 matching lines @@
     }
     _ptrThreadPlay->SetPriority(kRealtimePriority);
 
     _initialized = true;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::Terminate()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (!_initialized)
     {
         return 0;
     }
 
     _mixerManager.Close();
 
     // RECORDING
     if (_ptrThreadRec)
     {
@@ skipping 30 matching lines @@
 
     _initialized = false;
     _outputDeviceIsSpecified = false;
     _inputDeviceIsSpecified = false;
 
     return 0;
 }
 
 bool AudioDeviceLinuxPulse::Initialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_initialized);
 }
 
 int32_t AudioDeviceLinuxPulse::InitSpeaker()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
     if (_playing)
     {
         return -1;
     }
 
     if (!_outputDeviceIsSpecified)
     {
         return -1;
     }
@@ skipping 23 matching lines @@
 
     // clear _deviceIndex
     _deviceIndex = -1;
     _paDeviceIndex = -1;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::InitMicrophone()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_recording)
     {
         return -1;
     }
 
     if (!_inputDeviceIsSpecified)
     {
         return -1;
     }
 
@@ skipping 22 matching lines @@
 
     // Clear _deviceIndex
     _deviceIndex = -1;
     _paDeviceIndex = -1;
 
     return 0;
 }
 
 bool AudioDeviceLinuxPulse::SpeakerIsInitialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_mixerManager.SpeakerIsInitialized());
 }
 
 bool AudioDeviceLinuxPulse::MicrophoneIsInitialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_mixerManager.MicrophoneIsInitialized());
 }
 
 int32_t AudioDeviceLinuxPulse::SpeakerVolumeIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
 
     // Make an attempt to open up the
     // output mixer corresponding to the currently selected output device.
     if (!wasInitialized && InitSpeaker() == -1)
     {
         // If we end up here it means that the selected speaker has no volume
         // control.
         available = false;
         return 0;
     }
 
     // Given that InitSpeaker was successful, we know volume control exists.
     available = true;
 
     // Close the initialized output mixer
     if (!wasInitialized)
     {
         _mixerManager.CloseSpeaker();
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetSpeakerVolume(uint32_t volume)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (!_playing) {
       // Only update the volume if it's been set while we weren't playing.
       update_speaker_volume_at_startup_ = true;
     }
     return (_mixerManager.SetSpeakerVolume(volume));
 }
 
 int32_t AudioDeviceLinuxPulse::SpeakerVolume(uint32_t& volume) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     uint32_t level(0);
 
     if (_mixerManager.SpeakerVolume(level) == -1)
     {
         return -1;
     }
 
     volume = level;
 
     return 0;
@@ skipping 15 matching lines @@
 {
 
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                  "  API call not supported on this platform");
     return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::MaxSpeakerVolume(
     uint32_t& maxVolume) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     uint32_t maxVol(0);
 
     if (_mixerManager.MaxSpeakerVolume(maxVol) == -1)
     {
         return -1;
     }
 
     maxVolume = maxVol;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::MinSpeakerVolume(
     uint32_t& minVolume) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     uint32_t minVol(0);
 
     if (_mixerManager.MinSpeakerVolume(minVol) == -1)
     {
         return -1;
     }
 
     minVolume = minVol;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SpeakerVolumeStepSize(
     uint16_t& stepSize) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     uint16_t delta(0);
 
     if (_mixerManager.SpeakerVolumeStepSize(delta) == -1)
     {
         return -1;
     }
 
     stepSize = delta;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SpeakerMuteIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool isAvailable(false);
     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
 
     // Make an attempt to open up the
     // output mixer corresponding to the currently selected output device.
     //
     if (!wasInitialized && InitSpeaker() == -1)
     {
         // If we end up here it means that the selected speaker has no volume
         // control, hence it is safe to state that there is no mute control
@@ skipping 11 matching lines @@
     if (!wasInitialized)
     {
         _mixerManager.CloseSpeaker();
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetSpeakerMute(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_mixerManager.SetSpeakerMute(enable));
 }
 
 int32_t AudioDeviceLinuxPulse::SpeakerMute(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool muted(0);
     if (_mixerManager.SpeakerMute(muted) == -1)
     {
         return -1;
     }
 
     enabled = muted;
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneMuteIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool isAvailable(false);
     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
 
     // Make an attempt to open up the
     // input mixer corresponding to the currently selected input device.
     //
     if (!wasInitialized && InitMicrophone() == -1)
     {
         // If we end up here it means that the selected microphone has no
         // volume control, hence it is safe to state that there is no
@@ skipping 12 matching lines @@
     if (!wasInitialized)
     {
         _mixerManager.CloseMicrophone();
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetMicrophoneMute(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_mixerManager.SetMicrophoneMute(enable));
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneMute(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool muted(0);
     if (_mixerManager.MicrophoneMute(muted) == -1)
     {
         return -1;
     }
 
     enabled = muted;
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneBoostIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool isAvailable(false);
     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
 
     // Enumerate all avaliable microphone and make an attempt to open up the
     // input mixer corresponding to the currently selected input device.
     //
     if (!wasInitialized && InitMicrophone() == -1)
     {
         // If we end up here it means that the selected microphone has no
         // volume control, hence it is safe to state that there is no
@@ skipping 10 matching lines @@
     if (!wasInitialized)
     {
         _mixerManager.CloseMicrophone();
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetMicrophoneBoost(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_mixerManager.SetMicrophoneBoost(enable));
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneBoost(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool onOff(0);
 
     if (_mixerManager.MicrophoneBoost(onOff) == -1)
     {
         return -1;
     }
 
     enabled = onOff;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StereoRecordingIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_recChannels == 2 && _recording) {
       available = true;
       return 0;
     }
 
     available = false;
     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
     int error = 0;
 
     if (!wasInitialized && InitMicrophone() == -1)
@@ skipping 13 matching lines @@
     if (!wasInitialized)
     {
         _mixerManager.CloseMicrophone();
     }
 
     return error;
 }
 
 int32_t AudioDeviceLinuxPulse::SetStereoRecording(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (enable)
         _recChannels = 2;
     else
         _recChannels = 1;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StereoRecording(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_recChannels == 2)
         enabled = true;
     else
         enabled = false;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StereoPlayoutIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_playChannels == 2 && _playing) {
       available = true;
       return 0;
     }
 
     available = false;
     bool wasInitialized = _mixerManager.SpeakerIsInitialized();
     int error = 0;
 
     if (!wasInitialized && InitSpeaker() == -1)
@@ skipping 12 matching lines @@
     if (!wasInitialized)
     {
         _mixerManager.CloseSpeaker();
     }
 
     return error;
 }
 
 int32_t AudioDeviceLinuxPulse::SetStereoPlayout(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (enable)
         _playChannels = 2;
     else
         _playChannels = 1;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StereoPlayout(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_playChannels == 2)
         enabled = true;
     else
         enabled = false;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetAGC(bool enable)
 {
     CriticalSectionScoped lock(&_critSect);
     _AGC = enable;
 
     return 0;
 }
 
 bool AudioDeviceLinuxPulse::AGC() const
 {
     CriticalSectionScoped lock(&_critSect);
     return _AGC;
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneVolumeIsAvailable(
     bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     bool wasInitialized = _mixerManager.MicrophoneIsInitialized();
 
     // Make an attempt to open up the
     // input mixer corresponding to the currently selected output device.
     if (!wasInitialized && InitMicrophone() == -1)
     {
         // If we end up here it means that the selected microphone has no
         // volume control.
         available = false;
         return 0;
@@ skipping 63 matching lines @@
     }
 
     minVolume = minVol;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneVolumeStepSize(
     uint16_t& stepSize) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     uint16_t delta(0);
 
     if (_mixerManager.MicrophoneVolumeStepSize(delta) == -1)
     {
         return -1;
     }
 
     stepSize = delta;
 
     return 0;
@@ skipping 13 matching lines @@
 
     WaitForOperationCompletion(paOperation);
 
     PaUnLock();
 
     return _numPlayDevices;
 }
 
 int32_t AudioDeviceLinuxPulse::SetPlayoutDevice(uint16_t index)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_playIsInitialized)
     {
         return -1;
     }
 
     const uint16_t nDevices = PlayoutDevices();
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "  number of availiable output devices is %u", nDevices);
 
@@ skipping 16 matching lines @@
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                  "WindowsDeviceType not supported");
     return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::PlayoutDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize])
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     const uint16_t nDevices = PlayoutDevices();
 
     if ((index > (nDevices - 1)) || (name == NULL))
     {
         return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
     if (guid != NULL)
@@ skipping 21 matching lines @@
     _deviceIndex = -1;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::RecordingDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize])
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     const uint16_t nDevices(RecordingDevices());
 
     if ((index > (nDevices - 1)) || (name == NULL))
     {
         return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
     if (guid != NULL)
@@ skipping 37 matching lines @@
 
     WaitForOperationCompletion(paOperation);
 
     PaUnLock();
 
     return _numRecDevices;
 }
 
 int32_t AudioDeviceLinuxPulse::SetRecordingDevice(uint16_t index)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_recIsInitialized)
     {
         return -1;
     }
 
     const uint16_t nDevices(RecordingDevices());
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "  number of availiable input devices is %u", nDevices);
 
@@ skipping 13 matching lines @@
 int32_t AudioDeviceLinuxPulse::SetRecordingDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/)
 {
     WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                  "WindowsDeviceType not supported");
     return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     available = false;
 
     // Try to initialize the playout side
     int32_t res = InitPlayout();
 
     // Cancel effect of initialization
     StopPlayout();
 
     if (res != -1)
     {
         available = true;
     }
 
     return res;
 }
 
 int32_t AudioDeviceLinuxPulse::RecordingIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     available = false;
 
     // Try to initialize the playout side
     int32_t res = InitRecording();
 
     // Cancel effect of initialization
     StopRecording();
 
     if (res != -1)
     {
         available = true;
     }
 
     return res;
 }
 
 int32_t AudioDeviceLinuxPulse::InitPlayout()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
     if (_playing)
     {
         return -1;
     }
 
     if (!_outputDeviceIsSpecified)
     {
         return -1;
     }
@@ skipping 101 matching lines @@
     // Mark playout side as initialized
     _playIsInitialized = true;
     _sndCardPlayDelay = 0;
     _sndCardRecDelay = 0;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::InitRecording()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
     if (_recording)
     {
         return -1;
     }
 
     if (!_inputDeviceIsSpecified)
     {
         return -1;
     }
@@ skipping 91 matching lines @@
                                        this);
 
     // Mark recording side as initialized
     _recIsInitialized = true;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StartRecording()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (!_recIsInitialized)
     {
         return -1;
     }
 
     if (_recording)
     {
         return 0;
     }
 
@@ skipping 26 matching lines @@
                          "  failed to activate recording");
             return -1;
         }
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StopRecording()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     CriticalSectionScoped lock(&_critSect);
 
     if (!_recIsInitialized)
     {
         return 0;
     }
 
     if (_recStream == NULL)
     {
         return -1;
@@ skipping 42 matching lines @@
     {
         delete [] _recBuffer;
         _recBuffer = NULL;
     }
 
     return 0;
 }
 
 bool AudioDeviceLinuxPulse::RecordingIsInitialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_recIsInitialized);
 }
 
 bool AudioDeviceLinuxPulse::Recording() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_recording);
 }
 
 bool AudioDeviceLinuxPulse::PlayoutIsInitialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_playIsInitialized);
 }
 
 int32_t AudioDeviceLinuxPulse::StartPlayout()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
     if (!_playIsInitialized)
     {
         return -1;
     }
 
     if (_playing)
     {
         return 0;
     }
@@ skipping 33 matching lines @@
                          "  failed to activate playing");
             return -1;
         }
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StopPlayout()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     CriticalSectionScoped lock(&_critSect);
 
     if (!_playIsInitialized)
     {
         return 0;
     }
 
     if (_playStream == NULL)
     {
         return -1;
@@ skipping 51 matching lines @@
 
 int32_t AudioDeviceLinuxPulse::PlayoutDelay(uint16_t& delayMS) const
 {
     CriticalSectionScoped lock(&_critSect);
     delayMS = (uint16_t) _sndCardPlayDelay;
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::RecordingDelay(uint16_t& delayMS) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     delayMS = (uint16_t) _sndCardRecDelay;
     return 0;
 }
 
 bool AudioDeviceLinuxPulse::Playing() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return (_playing);
 }
 
 int32_t AudioDeviceLinuxPulse::SetPlayoutBuffer(
     const AudioDeviceModule::BufferType type,
     uint16_t sizeMS)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (type != AudioDeviceModule::kFixedBufferSize)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      " Adaptive buffer size not supported on this platform");
         return -1;
     }
 
     _playBufType = type;
     _playBufDelayFixed = sizeMS;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::PlayoutBuffer(
     AudioDeviceModule::BufferType& type,
     uint16_t& sizeMS) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     type = _playBufType;
     sizeMS = _playBufDelayFixed;
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::CPULoad(uint16_t& /*load*/) const
 {
 
     WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
@@ skipping 1359 matching lines @@
 
   // A bit change in keymap means a key is pressed
   for (i = 0; i < sizeof(szKey); i++)
     state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i];
 
   // Save old state
   memcpy((char*)_oldKeyState, (char*)szKey, sizeof(_oldKeyState));
   return (state != 0);
 }
 }