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

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 45 matching lines @@
     _paSpeakerVolume(PA_VOLUME_NORM),
     _paChannels(0),
     _paObjectsSet(false)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                  "%s constructed", __FUNCTION__);
 }
 
 AudioMixerManagerLinuxPulse::~AudioMixerManagerLinuxPulse()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                  "%s destructed", __FUNCTION__);
 
     Close();
 }
 
 // ===========================================================================
 //                                    PUBLIC METHODS
 // ===========================================================================
 
 int32_t AudioMixerManagerLinuxPulse::SetPulseAudioObjects(
     pa_threaded_mainloop* mainloop,
     pa_context* context)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     if (!mainloop || !context)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "  could not set PulseAudio objects for mixer");
         return -1;
     }
 
     _paMainloop = mainloop;
     _paContext = context;
     _paObjectsSet = true;
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "  the PulseAudio objects for the mixer has been set");
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::Close()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     CloseSpeaker();
     CloseMicrophone();
 
     _paMainloop = NULL;
     _paContext = NULL;
     _paObjectsSet = false;
 
     return 0;
 
 }
 
 int32_t AudioMixerManagerLinuxPulse::CloseSpeaker()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     // Reset the index to -1
     _paOutputDeviceIndex = -1;
     _paPlayStream = NULL;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::CloseMicrophone()
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     // Reset the index to -1
     _paInputDeviceIndex = -1;
     _paRecStream = NULL;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetPlayStream(pa_stream* playStream)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetPlayStream(playStream)");
 
     _paPlayStream = playStream;
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetRecStream(pa_stream* recStream)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetRecStream(recStream)");
 
     _paRecStream = recStream;
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::OpenSpeaker(
     uint16_t deviceIndex)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::OpenSpeaker(deviceIndex=%d)",
                  deviceIndex);
 
     // No point in opening the speaker
     // if PA objects have not been set
     if (!_paObjectsSet)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "  PulseAudio objects has not been set");
         return -1;
     }
 
     // Set the index for the PulseAudio
     // output device to control
     _paOutputDeviceIndex = deviceIndex;
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "  the output mixer device is now open");
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::OpenMicrophone(
     uint16_t deviceIndex)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::OpenMicrophone"
                  "(deviceIndex=%d)", deviceIndex);
 
     // No point in opening the microphone
     // if PA objects have not been set
     if (!_paObjectsSet)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "  PulseAudio objects have not been set");
         return -1;
     }
 
     // Set the index for the PulseAudio
     // input device to control
     _paInputDeviceIndex = deviceIndex;
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "  the input mixer device is now open");
 
     return 0;
 }
 
 bool AudioMixerManagerLinuxPulse::SpeakerIsInitialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     return (_paOutputDeviceIndex != -1);
 }
 
 bool AudioMixerManagerLinuxPulse::MicrophoneIsInitialized() const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s",
                  __FUNCTION__);
 
     return (_paInputDeviceIndex != -1);
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetSpeakerVolume(
     uint32_t volume)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetSpeakerVolume(volume=%u)",
                  volume);
 
     if (_paOutputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  output device index has not been set");
         return -1;
     }
@@ skipping 114 matching lines @@
     }
 
     minVolume = static_cast<uint32_t> (PA_VOLUME_MUTED);
 
     return 0;
 }
 
 int32_t
 AudioMixerManagerLinuxPulse::SpeakerVolumeStepSize(uint16_t& stepSize) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paOutputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  output device index has not been set");
         return -1;
     }
 
     // The sink input (stream) will always have step size = 1
     // There are PA_VOLUME_NORM+1 steps
     stepSize = 1;
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "\tAudioMixerManagerLinuxPulse::SpeakerVolumeStepSize() => "
                  "size=%i", stepSize);
 
     return 0;
 }
 
 int32_t
 AudioMixerManagerLinuxPulse::SpeakerVolumeIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paOutputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  output device index has not been set");
         return -1;
     }
 
     // Always available in Pulse Audio
     available = true;
 
     return 0;
 }
 
 int32_t
 AudioMixerManagerLinuxPulse::SpeakerMuteIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paOutputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  output device index has not been set");
         return -1;
     }
 
     // Always available in Pulse Audio
     available = true;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetSpeakerMute(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetSpeakerMute(enable=%u)",
                  enable);
 
     if (_paOutputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  output device index has not been set");
         return -1;
     }
@@ skipping 64 matching lines @@
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "     AudioMixerManagerLinuxPulse::SpeakerMute() => "
                  "enabled=%i, enabled");
 
     return 0;
 }
 
 int32_t
 AudioMixerManagerLinuxPulse::StereoPlayoutIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paOutputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  output device index has not been set");
         return -1;
     }
 
     uint32_t deviceIndex = (uint32_t) _paOutputDeviceIndex;
 
     {
@@ skipping 13 matching lines @@
       return -1;
 
     available = static_cast<bool> (_paChannels == 2);
 
     return 0;
 }
 
 int32_t
 AudioMixerManagerLinuxPulse::StereoRecordingIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     uint32_t deviceIndex = (uint32_t) _paInputDeviceIndex;
 
     AutoPulseLock auto_lock(_paMainloop);
@@ skipping 23 matching lines @@
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  " AudioMixerManagerLinuxPulse::StereoRecordingIsAvailable()"
                  " => available=%i, available");
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::MicrophoneMuteIsAvailable(
     bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     // Always available in Pulse Audio
     available = true;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetMicrophoneMute(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetMicrophoneMute(enable=%u)",
                  enable);
 
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
@@ skipping 34 matching lines @@
                      " could not mute microphone, error%d",
                      LATE(pa_context_errno)(_paContext));
         return -1;
     }
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::MicrophoneMute(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     uint32_t deviceIndex = (uint32_t) _paInputDeviceIndex;
 
     {
@@ skipping 16 matching lines @@
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "\tAudioMixerManagerLinuxPulse::MicrophoneMute() =>"
                  " enabled=%i", enabled);
 
     return 0;
 }
 
 int32_t
 AudioMixerManagerLinuxPulse::MicrophoneBoostIsAvailable(bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     // Always unavailable in Pulse Audio
     // Could make it possible to use PA_VOLUME_MAX
     // but that gives bad audio with some sound cards
     available = false;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::SetMicrophoneBoost(bool enable)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "AudioMixerManagerLinuxPulse::SetMicrophoneBoost(enable=%u)",
                  enable);
 
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     // Ensure the selected microphone destination has a valid boost control
     bool available(false);
     MicrophoneBoostIsAvailable(available);
     if (!available)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  it is not possible to enable microphone boost");
         return -1;
     }
 
     // It is assumed that the call above fails!
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::MicrophoneBoost(bool& enabled) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     // Microphone boost cannot be enabled on this platform!
     enabled = false;
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::MicrophoneVolumeIsAvailable(
     bool& available)
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     // Always available in Pulse Audio
     available = true;
 
@@ skipping 148 matching lines @@
     }
 
     minVolume = static_cast<uint32_t> (PA_VOLUME_MUTED);
 
     return 0;
 }
 
 int32_t AudioMixerManagerLinuxPulse::MicrophoneVolumeStepSize(
     uint16_t& stepSize) const
 {
-    DCHECK(thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (_paInputDeviceIndex == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  input device index has not been set");
         return -1;
     }
 
     uint32_t deviceIndex = (uint32_t) _paInputDeviceIndex;
 
     AutoPulseLock auto_lock(_paMainloop);
@@ skipping 200 matching lines @@
 
   AutoPulseLock auto_lock(_paMainloop);
   paOperation  = LATE(pa_context_get_source_info_by_index)(
       _paContext, device_index, PaSourceInfoCallback, (void*) this);
 
   WaitForOperationCompletion(paOperation);
   return true;
 }
 
 }