Remove some occurrences of WEBRTC_TRACE in webrtc/modules/audio_device/linux/

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.
  */
 
 #include <assert.h>
 
 #include "webrtc/modules/audio_device/audio_device_config.h"
 #include "webrtc/modules/audio_device/linux/audio_device_pulse_linux.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
-#include "webrtc/system_wrappers/include/trace.h"
 
 webrtc::adm_linux_pulse::PulseAudioSymbolTable PaSymbolTable;
 
 // Accesses Pulse functions through our late-binding symbol table instead of
 // directly. This way we don't have to link to libpulse, which means our binary
 // will work on systems that don't have it.
 #define LATE(sym)                                                             \
   LATESYM_GET(webrtc::adm_linux_pulse::PulseAudioSymbolTable, &PaSymbolTable, \
               sym)
 
@@ skipping 54 matching lines @@
       _configuredLatencyRec(0),
       _paDeviceIndex(-1),
       _paStateChanged(false),
       _paMainloop(NULL),
       _paMainloopApi(NULL),
       _paContext(NULL),
       _recStream(NULL),
       _playStream(NULL),
       _recStreamFlags(0),
       _playStreamFlags(0) {
-  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
+  LOG(LS_INFO) << __FUNCTION__ << " created";
 
   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__);
+  LOG(LS_INFO) << __FUNCTION__ << " destroyed";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   Terminate();
 
   if (_recBuffer) {
     delete[] _recBuffer;
     _recBuffer = NULL;
   }
   if (_playBuffer) {
     delete[] _playBuffer;
     _playBuffer = NULL;
@@ skipping 103 matching lines @@
   if (_ptrThreadPlay) {
     rtc::PlatformThread* tmpThread = _ptrThreadPlay.release();
 
     _timeEventPlay.Set();
     tmpThread->Stop();
     delete tmpThread;
   }
 
   // Terminate PulseAudio
   if (TerminatePulseAudio() < 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to terminate PulseAudio");
+    LOG(LS_ERROR) << "failed to terminate PulseAudio";
     return -1;
   }
 
   if (_XDisplay) {
     XCloseDisplay(_XDisplay);
     _XDisplay = NULL;
   }
 
   _initialized = false;
   _outputDeviceIsSpecified = false;
@@ skipping 133 matching lines @@
     return -1;
   }
 
   volume = level;
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetWaveOutVolume(uint16_t volumeLeft,
                                                 uint16_t volumeRight) {
-  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-               "  API call not supported on this platform");
+  LOG(LS_WARNING) << "API call not supported on this platform";
   return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::WaveOutVolume(uint16_t& /*volumeLeft*/,
                                              uint16_t& /*volumeRight*/) const {
-  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-               "  API call not supported on this platform");
+  LOG(LS_WARNING) << "API call not supported on this platform";
   return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::MaxSpeakerVolume(uint32_t& maxVolume) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   uint32_t maxVol(0);
 
   if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) {
     return -1;
   }
@@ skipping 305 matching lines @@
 }
 
 int32_t AudioDeviceLinuxPulse::SetMicrophoneVolume(uint32_t volume) {
   return (_mixerManager.SetMicrophoneVolume(volume));
 }
 
 int32_t AudioDeviceLinuxPulse::MicrophoneVolume(uint32_t& volume) const {
   uint32_t level(0);
 
   if (_mixerManager.MicrophoneVolume(level) == -1) {
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                 "  failed to retrive current microphone level");
+    LOG(LS_WARNING) << "failed to retrieve current microphone level";
     return -1;
   }
 
   volume = level;
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::MaxMicrophoneVolume(uint32_t& maxVolume) const {
   uint32_t maxVol(0);
@@ skipping 51 matching lines @@
 }
 
 int32_t AudioDeviceLinuxPulse::SetPlayoutDevice(uint16_t index) {
   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);
+  LOG(LS_VERBOSE) << "number of availiable output devices is " << nDevices;
 
   if (index > (nDevices - 1)) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  device index is out of range [0,%u]", (nDevices - 1));
+    LOG(LS_ERROR) << "device index is out of range [0," << (nDevices - 1)
+                  << "]";
     return -1;
   }
 
   _outputDeviceIndex = index;
   _outputDeviceIsSpecified = true;
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetPlayoutDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/) {
-  WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-               "WindowsDeviceType not supported");
+  LOG(LS_ERROR) << "WindowsDeviceType not supported";
   return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::PlayoutDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize]) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   const uint16_t nDevices = PlayoutDevices();
 
@@ skipping 84 matching lines @@
 }
 
 int32_t AudioDeviceLinuxPulse::SetRecordingDevice(uint16_t index) {
   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);
+  LOG(LS_VERBOSE) << "number of availiable input devices is " << nDevices;
 
   if (index > (nDevices - 1)) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  device index is out of range [0,%u]", (nDevices - 1));
+    LOG(LS_ERROR) << "device index is out of range [0," << (nDevices - 1)
+                  << "]";
     return -1;
   }
 
   _inputDeviceIndex = index;
   _inputDeviceIsSpecified = true;
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::SetRecordingDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/) {
-  WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-               "WindowsDeviceType not supported");
+  LOG(LS_ERROR) << "WindowsDeviceType not supported";
   return -1;
 }
 
 int32_t AudioDeviceLinuxPulse::PlayoutIsAvailable(bool& available) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   available = false;
 
   // Try to initialize the playout side
   int32_t res = InitPlayout();
 
@@ skipping 34 matching lines @@
   if (!_outputDeviceIsSpecified) {
     return -1;
   }
 
   if (_playIsInitialized) {
     return 0;
   }
 
   // Initialize the speaker (devices might have been added or removed)
   if (InitSpeaker() == -1) {
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                 "  InitSpeaker() failed");
+    LOG(LS_WARNING) << "InitSpeaker() failed";
   }
 
   // Set the play sample specification
   pa_sample_spec playSampleSpec;
   playSampleSpec.channels = _playChannels;
   playSampleSpec.format = PA_SAMPLE_S16LE;
   playSampleSpec.rate = sample_rate_hz_;
 
   // Create a new play stream
   _playStream =
       LATE(pa_stream_new)(_paContext, "playStream", &playSampleSpec, NULL);
 
   if (!_playStream) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to create play stream, err=%d",
-                 LATE(pa_context_errno)(_paContext));
+    LOG(LS_ERROR) << "failed to create play stream, err="
+                  << LATE(pa_context_errno)(_paContext);
     return -1;
   }
 
   // Provide the playStream to the mixer
   _mixerManager.SetPlayStream(_playStream);
 
   if (_ptrAudioBuffer) {
     // Update audio buffer with the selected parameters
     _ptrAudioBuffer->SetPlayoutSampleRate(sample_rate_hz_);
     _ptrAudioBuffer->SetPlayoutChannels((uint8_t)_playChannels);
   }
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  stream state %d\n",
-               LATE(pa_stream_get_state)(_playStream));
+  LOG(LS_VERBOSE) << "stream state " << LATE(pa_stream_get_state)(_playStream);
 
   // Set stream flags
   _playStreamFlags = (pa_stream_flags_t)(PA_STREAM_AUTO_TIMING_UPDATE |
                                          PA_STREAM_INTERPOLATE_TIMING);
 
   if (_configuredLatencyPlay != WEBRTC_PA_NO_LATENCY_REQUIREMENTS) {
     // If configuring a specific latency then we want to specify
     // PA_STREAM_ADJUST_LATENCY to make the server adjust parameters
     // automatically to reach that target latency. However, that flag
     // doesn't exist in Ubuntu 8.04 and many people still use that,
     // so we have to check the protocol version of libpulse.
     if (LATE(pa_context_get_protocol_version)(_paContext) >=
         WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION) {
       _playStreamFlags |= PA_STREAM_ADJUST_LATENCY;
     }
 
     const pa_sample_spec* spec = LATE(pa_stream_get_sample_spec)(_playStream);
     if (!spec) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  pa_stream_get_sample_spec()");
+      LOG(LS_ERROR) << "pa_stream_get_sample_spec()";
       return -1;
     }
 
     size_t bytesPerSec = LATE(pa_bytes_per_second)(spec);
     uint32_t latency = bytesPerSec * WEBRTC_PA_PLAYBACK_LATENCY_MINIMUM_MSECS /
                        WEBRTC_PA_MSECS_PER_SEC;
 
     // Set the play buffer attributes
     _playBufferAttr.maxlength = latency;  // num bytes stored in the buffer
     _playBufferAttr.tlength = latency;    // target fill level of play buffer
@@ skipping 35 matching lines @@
   if (!_inputDeviceIsSpecified) {
     return -1;
   }
 
   if (_recIsInitialized) {
     return 0;
   }
 
   // Initialize the microphone (devices might have been added or removed)
   if (InitMicrophone() == -1) {
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                 "  InitMicrophone() failed");
+    LOG(LS_WARNING) << "InitMicrophone() failed";
   }
 
   // Set the rec sample specification
   pa_sample_spec recSampleSpec;
   recSampleSpec.channels = _recChannels;
   recSampleSpec.format = PA_SAMPLE_S16LE;
   recSampleSpec.rate = sample_rate_hz_;
 
   // Create a new rec stream
   _recStream =
       LATE(pa_stream_new)(_paContext, "recStream", &recSampleSpec, NULL);
   if (!_recStream) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to create rec stream, err=%d",
-                 LATE(pa_context_errno)(_paContext));
+    LOG(LS_ERROR) << "failed to create rec stream, err="
+                  << LATE(pa_context_errno)(_paContext);
     return -1;
   }
 
   // Provide the recStream to the mixer
   _mixerManager.SetRecStream(_recStream);
 
   if (_ptrAudioBuffer) {
     // Update audio buffer with the selected parameters
     _ptrAudioBuffer->SetRecordingSampleRate(sample_rate_hz_);
     _ptrAudioBuffer->SetRecordingChannels((uint8_t)_recChannels);
   }
 
   if (_configuredLatencyRec != WEBRTC_PA_NO_LATENCY_REQUIREMENTS) {
     _recStreamFlags = (pa_stream_flags_t)(PA_STREAM_AUTO_TIMING_UPDATE |
                                           PA_STREAM_INTERPOLATE_TIMING);
 
     // If configuring a specific latency then we want to specify
     // PA_STREAM_ADJUST_LATENCY to make the server adjust parameters
     // automatically to reach that target latency. However, that flag
     // doesn't exist in Ubuntu 8.04 and many people still use that,
     //  so we have to check the protocol version of libpulse.
     if (LATE(pa_context_get_protocol_version)(_paContext) >=
         WEBRTC_PA_ADJUST_LATENCY_PROTOCOL_VERSION) {
       _recStreamFlags |= PA_STREAM_ADJUST_LATENCY;
     }
 
     const pa_sample_spec* spec = LATE(pa_stream_get_sample_spec)(_recStream);
     if (!spec) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  pa_stream_get_sample_spec(rec)");
+      LOG(LS_ERROR) << "pa_stream_get_sample_spec(rec)";
       return -1;
     }
 
     size_t bytesPerSec = LATE(pa_bytes_per_second)(spec);
     uint32_t latency = bytesPerSec * WEBRTC_PA_LOW_CAPTURE_LATENCY_MSECS /
                        WEBRTC_PA_MSECS_PER_SEC;
 
     // Set the rec buffer attributes
     // Note: fragsize specifies a maximum transfer size, not a minimum, so
     // it is not possible to force a high latency setting, only a low one.
@@ skipping 36 matching lines @@
   _startRec = true;
 
   // The audio thread will signal when recording has started.
   _timeEventRec.Set();
   if (kEventTimeout == _recStartEvent.Wait(10000)) {
     {
       rtc::CritScope lock(&_critSect);
       _startRec = false;
     }
     StopRecording();
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to activate recording");
+    LOG(LS_ERROR) << "failed to activate recording";
     return -1;
   }
 
   {
     rtc::CritScope lock(&_critSect);
     if (_recording) {
       // The recording state is set by the audio thread after recording
       // has started.
     } else {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to activate recording");
+      LOG(LS_ERROR) << "failed to activate recording";
       return -1;
     }
   }
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StopRecording() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&_critSect);
 
   if (!_recIsInitialized) {
     return 0;
   }
 
   if (_recStream == NULL) {
     return -1;
   }
 
   _recIsInitialized = false;
   _recording = false;
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  stopping recording");
+  LOG(LS_VERBOSE) << "stopping recording";
 
   // Stop Recording
   PaLock();
 
   DisableReadCallback();
   LATE(pa_stream_set_overflow_callback)(_recStream, NULL, NULL);
 
   // Unset this here so that we don't get a TERMINATED callback
   LATE(pa_stream_set_state_callback)(_recStream, NULL, NULL);
 
   if (LATE(pa_stream_get_state)(_recStream) != PA_STREAM_UNCONNECTED) {
     // Disconnect the stream
     if (LATE(pa_stream_disconnect)(_recStream) != PA_OK) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to disconnect rec stream, err=%d\n",
-                   LATE(pa_context_errno)(_paContext));
+      LOG(LS_ERROR) << "failed to disconnect rec stream, err="
+                    << LATE(pa_context_errno)(_paContext);
       PaUnLock();
       return -1;
     }
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                 "  disconnected recording");
+    LOG(LS_VERBOSE) << "disconnected recording";
   }
 
   LATE(pa_stream_unref)(_recStream);
   _recStream = NULL;
 
   PaUnLock();
 
   // Provide the recStream to the mixer
   _mixerManager.SetRecStream(_recStream);
 
@@ skipping 41 matching lines @@
   // accessed on the playout thread.
 
   // The audio thread will signal when playout has started.
   _timeEventPlay.Set();
   if (kEventTimeout == _playStartEvent.Wait(10000)) {
     {
       rtc::CritScope lock(&_critSect);
       _startPlay = false;
     }
     StopPlayout();
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to activate playout");
+    LOG(LS_ERROR) << "failed to activate playout";
     return -1;
   }
 
   {
     rtc::CritScope lock(&_critSect);
     if (_playing) {
       // The playing state is set by the audio thread after playout
       // has started.
     } else {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to activate playing");
+      LOG(LS_ERROR) << "failed to activate playing";
       return -1;
     }
   }
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::StopPlayout() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&_critSect);
 
   if (!_playIsInitialized) {
     return 0;
   }
 
   if (_playStream == NULL) {
     return -1;
   }
 
   _playIsInitialized = false;
   _playing = false;
   _sndCardPlayDelay = 0;
   _sndCardRecDelay = 0;
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  stopping playback");
+  LOG(LS_VERBOSE) << "stopping playback";
 
   // Stop Playout
   PaLock();
 
   DisableWriteCallback();
   LATE(pa_stream_set_underflow_callback)(_playStream, NULL, NULL);
 
   // Unset this here so that we don't get a TERMINATED callback
   LATE(pa_stream_set_state_callback)(_playStream, NULL, NULL);
 
   if (LATE(pa_stream_get_state)(_playStream) != PA_STREAM_UNCONNECTED) {
     // Disconnect the stream
     if (LATE(pa_stream_disconnect)(_playStream) != PA_OK) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to disconnect play stream, err=%d",
-                   LATE(pa_context_errno)(_paContext));
+      LOG(LS_ERROR) << "failed to disconnect play stream, err="
+                    << LATE(pa_context_errno)(_paContext);
       PaUnLock();
       return -1;
     }
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                 "  disconnected playback");
+    LOG(LS_VERBOSE) << "disconnected playback";
   }
 
   LATE(pa_stream_unref)(_playStream);
   _playStream = NULL;
 
   PaUnLock();
 
   // Provide the playStream to the mixer
   _mixerManager.SetPlayStream(_playStream);
 
@@ skipping 20 matching lines @@
 bool AudioDeviceLinuxPulse::Playing() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return (_playing);
 }
 
 int32_t AudioDeviceLinuxPulse::SetPlayoutBuffer(
     const AudioDeviceModule::BufferType type,
     uint16_t sizeMS) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (type != AudioDeviceModule::kFixedBufferSize) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " Adaptive buffer size not supported on this platform");
+    LOG(LS_ERROR) << "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 {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   type = _playBufType;
   sizeMS = _playBufDelayFixed;
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::CPULoad(uint16_t& /*load*/) const {
-  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-               "  API call not supported on this platform");
+  LOG(LS_WARNING) << "API call not supported on this platform";
   return -1;
 }
 
 bool AudioDeviceLinuxPulse::PlayoutWarning() const {
   rtc::CritScope lock(&_critSect);
   return (_playWarning > 0);
 }
 
 bool AudioDeviceLinuxPulse::PlayoutError() const {
   rtc::CritScope lock(&_critSect);
@@ skipping 61 matching lines @@
                                                  const pa_server_info* i,
                                                  void* pThis) {
   static_cast<AudioDeviceLinuxPulse*>(pThis)->PaServerInfoCallbackHandler(i);
 }
 
 void AudioDeviceLinuxPulse::PaStreamStateCallback(pa_stream* p, void* pThis) {
   static_cast<AudioDeviceLinuxPulse*>(pThis)->PaStreamStateCallbackHandler(p);
 }
 
 void AudioDeviceLinuxPulse::PaContextStateCallbackHandler(pa_context* c) {
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  context state cb");
+  LOG(LS_VERBOSE) << "context state cb";
 
   pa_context_state_t state = LATE(pa_context_get_state)(c);
   switch (state) {
     case PA_CONTEXT_UNCONNECTED:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  unconnected");
+      LOG(LS_VERBOSE) << "unconnected";
       break;
     case PA_CONTEXT_CONNECTING:
     case PA_CONTEXT_AUTHORIZING:
     case PA_CONTEXT_SETTING_NAME:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  no state");
+      LOG(LS_VERBOSE) << "no state";
       break;
     case PA_CONTEXT_FAILED:
     case PA_CONTEXT_TERMINATED:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  failed");
+      LOG(LS_VERBOSE) << "failed";
       _paStateChanged = true;
       LATE(pa_threaded_mainloop_signal)(_paMainloop, 0);
       break;
     case PA_CONTEXT_READY:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  ready");
+      LOG(LS_VERBOSE) << "ready";
       _paStateChanged = true;
       LATE(pa_threaded_mainloop_signal)(_paMainloop, 0);
       break;
   }
 }
 
 void AudioDeviceLinuxPulse::PaSinkInfoCallbackHandler(const pa_sink_info* i,
                                                       int eol) {
   if (eol) {
     // Signal that we are done
@@ skipping 70 matching lines @@
     // Copy the sink name
     strncpy(_playDisplayDeviceName, i->default_sink_name,
             kAdmMaxDeviceNameSize);
     _playDisplayDeviceName[kAdmMaxDeviceNameSize - 1] = '\0';
   }
 
   LATE(pa_threaded_mainloop_signal)(_paMainloop, 0);
 }
 
 void AudioDeviceLinuxPulse::PaStreamStateCallbackHandler(pa_stream* p) {
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  stream state cb");
+  LOG(LS_VERBOSE) << "stream state cb";
 
   pa_stream_state_t state = LATE(pa_stream_get_state)(p);
   switch (state) {
     case PA_STREAM_UNCONNECTED:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  unconnected");
+      LOG(LS_VERBOSE) << "unconnected";
       break;
     case PA_STREAM_CREATING:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  creating");
+      LOG(LS_VERBOSE) << "creating";
       break;
     case PA_STREAM_FAILED:
     case PA_STREAM_TERMINATED:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  failed");
+      LOG(LS_VERBOSE) << "failed";
       break;
     case PA_STREAM_READY:
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  ready");
+      LOG(LS_VERBOSE) << "ready";
       break;
   }
 
   LATE(pa_threaded_mainloop_signal)(_paMainloop, 0);
 }
 
 int32_t AudioDeviceLinuxPulse::CheckPulseAudioVersion() {
   PaLock();
 
   pa_operation* paOperation = NULL;
 
   // get the server info and update deviceName
   paOperation =
       LATE(pa_context_get_server_info)(_paContext, PaServerInfoCallback, this);
 
   WaitForOperationCompletion(paOperation);
 
   PaUnLock();
 
-  WEBRTC_TRACE(kTraceStateInfo, kTraceAudioDevice, -1,
-               "  checking PulseAudio version: %s", _paServerVersion);
+  LOG(LS_VERBOSE) << "checking PulseAudio version: " << _paServerVersion;
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::InitSamplingFrequency() {
   PaLock();
 
   pa_operation* paOperation = NULL;
 
   // Get the server info and update sample_rate_hz_
@@ skipping 77 matching lines @@
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::InitPulseAudio() {
   int retVal = 0;
 
   // Load libpulse
   if (!PaSymbolTable.Load()) {
     // Most likely the Pulse library and sound server are not installed on
     // this system
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to load symbol table");
+    LOG(LS_ERROR) << "failed to load symbol table";
     return -1;
   }
 
   // Create a mainloop API and connection to the default server
   // the mainloop is the internal asynchronous API event loop
   if (_paMainloop) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  PA mainloop has already existed");
+    LOG(LS_ERROR) << "PA mainloop has already existed";
     return -1;
   }
   _paMainloop = LATE(pa_threaded_mainloop_new)();
   if (!_paMainloop) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  could not create mainloop");
+    LOG(LS_ERROR) << "could not create mainloop";
     return -1;
   }
 
   // Start the threaded main loop
   retVal = LATE(pa_threaded_mainloop_start)(_paMainloop);
   if (retVal != PA_OK) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to start main loop, error=%d", retVal);
+    LOG(LS_ERROR) << "failed to start main loop, error=" << retVal;
     return -1;
   }
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  mainloop running!");
+  LOG(LS_VERBOSE) << "mainloop running!";
 
   PaLock();
 
   _paMainloopApi = LATE(pa_threaded_mainloop_get_api)(_paMainloop);
   if (!_paMainloopApi) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  could not create mainloop API");
+    LOG(LS_ERROR) << "could not create mainloop API";
     PaUnLock();
     return -1;
   }
 
   // Create a new PulseAudio context
   if (_paContext) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  PA context has already existed");
+    LOG(LS_ERROR) << "PA context has already existed";
     PaUnLock();
     return -1;
   }
   _paContext = LATE(pa_context_new)(_paMainloopApi, "WEBRTC VoiceEngine");
 
   if (!_paContext) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  could not create context");
+    LOG(LS_ERROR) << "could not create context";
     PaUnLock();
     return -1;
   }
 
   // Set state callback function
   LATE(pa_context_set_state_callback)(_paContext, PaContextStateCallback, this);
 
   // Connect the context to a server (default)
   _paStateChanged = false;
   retVal =
       LATE(pa_context_connect)(_paContext, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL);
 
   if (retVal != PA_OK) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to connect context, error=%d", retVal);
+    LOG(LS_ERROR) << "failed to connect context, error=" << retVal;
     PaUnLock();
     return -1;
   }
 
   // Wait for state change
   while (!_paStateChanged) {
     LATE(pa_threaded_mainloop_wait)(_paMainloop);
   }
 
   // Now check to see what final state we reached.
   pa_context_state_t state = LATE(pa_context_get_state)(_paContext);
 
   if (state != PA_CONTEXT_READY) {
     if (state == PA_CONTEXT_FAILED) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to connect to PulseAudio sound server");
+      LOG(LS_ERROR) << "failed to connect to PulseAudio sound server";
     } else if (state == PA_CONTEXT_TERMINATED) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  PulseAudio connection terminated early");
+      LOG(LS_ERROR) << "PulseAudio connection terminated early";
     } else {
       // Shouldn't happen, because we only signal on one of those three
       // states
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  unknown problem connecting to PulseAudio");
+      LOG(LS_ERROR) << "unknown problem connecting to PulseAudio";
     }
     PaUnLock();
     return -1;
   }
 
   PaUnLock();
 
   // Give the objects to the mixer manager
   _mixerManager.SetPulseAudioObjects(_paMainloop, _paContext);
 
   // Check the version
   if (CheckPulseAudioVersion() < 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  PulseAudio version %s not supported", _paServerVersion);
+    LOG(LS_ERROR) << "PulseAudio version " << _paServerVersion
+                  << " not supported";
     return -1;
   }
 
   // Initialize sampling frequency
   if (InitSamplingFrequency() < 0 || sample_rate_hz_ == 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  failed to initialize sampling frequency,"
-                 " set to %d Hz",
-                 sample_rate_hz_);
+    LOG(LS_ERROR) << "failed to initialize sampling frequency, set to "
+                  << sample_rate_hz_ << " Hz";
     return -1;
   }
 
   return 0;
 }
 
 int32_t AudioDeviceLinuxPulse::TerminatePulseAudio() {
   // Do nothing if the instance doesn't exist
   // likely PaSymbolTable.Load() fails
   if (!_paMainloop) {
@@ skipping 20 matching lines @@
     LATE(pa_threaded_mainloop_stop)(_paMainloop);
   }
 
   // Free the mainloop
   if (_paMainloop) {
     LATE(pa_threaded_mainloop_free)(_paMainloop);
   }
 
   _paMainloop = NULL;
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  PulseAudio terminated");
+  LOG(LS_VERBOSE) << "PulseAudio terminated";
 
   return 0;
 }
 
 void AudioDeviceLinuxPulse::PaLock() {
   LATE(pa_threaded_mainloop_lock)(_paMainloop);
 }
 
 void AudioDeviceLinuxPulse::PaUnLock() {
   LATE(pa_threaded_mainloop_unlock)(_paMainloop);
 }
 
 void AudioDeviceLinuxPulse::WaitForOperationCompletion(
     pa_operation* paOperation) const {
   if (!paOperation) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "paOperation NULL in WaitForOperationCompletion");
+    LOG(LS_ERROR) << "paOperation NULL in WaitForOperationCompletion";
     return;
   }
 
   while (LATE(pa_operation_get_state)(paOperation) == PA_OPERATION_RUNNING) {
     LATE(pa_threaded_mainloop_wait)(_paMainloop);
   }
 
   LATE(pa_operation_unref)(paOperation);
 }
 
@@ skipping 38 matching lines @@
   _timeEventPlay.Set();
 }
 
 void AudioDeviceLinuxPulse::PaStreamUnderflowCallback(pa_stream* /*unused*/,
                                                       void* pThis) {
   static_cast<AudioDeviceLinuxPulse*>(pThis)
       ->PaStreamUnderflowCallbackHandler();
 }
 
 void AudioDeviceLinuxPulse::PaStreamUnderflowCallbackHandler() {
-  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "  Playout underflow");
+  LOG(LS_WARNING) << "Playout underflow";
 
   if (_configuredLatencyPlay == WEBRTC_PA_NO_LATENCY_REQUIREMENTS) {
     // We didn't configure a pa_buffer_attr before, so switching to
     // one now would be questionable.
     return;
   }
 
   // Otherwise reconfigure the stream with a higher target latency.
 
   const pa_sample_spec* spec = LATE(pa_stream_get_sample_spec)(_playStream);
   if (!spec) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  pa_stream_get_sample_spec()");
+    LOG(LS_ERROR) << "pa_stream_get_sample_spec()";
     return;
   }
 
   size_t bytesPerSec = LATE(pa_bytes_per_second)(spec);
   uint32_t newLatency =
       _configuredLatencyPlay + bytesPerSec *
                                    WEBRTC_PA_PLAYBACK_LATENCY_INCREMENT_MSECS /
                                    WEBRTC_PA_MSECS_PER_SEC;
 
   // Set the play buffer attributes
   _playBufferAttr.maxlength = newLatency;
   _playBufferAttr.tlength = newLatency;
   _playBufferAttr.minreq = newLatency / WEBRTC_PA_PLAYBACK_REQUEST_FACTOR;
   _playBufferAttr.prebuf = _playBufferAttr.tlength - _playBufferAttr.minreq;
 
   pa_operation* op = LATE(pa_stream_set_buffer_attr)(
       _playStream, &_playBufferAttr, NULL, NULL);
   if (!op) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  pa_stream_set_buffer_attr()");
+    LOG(LS_ERROR) << "pa_stream_set_buffer_attr()";
     return;
   }
 
   // Don't need to wait for this to complete.
   LATE(pa_operation_unref)(op);
 
   // Save the new latency in case we underflow again.
   _configuredLatencyPlay = newLatency;
 }
 
 void AudioDeviceLinuxPulse::EnableReadCallback() {
   LATE(pa_stream_set_read_callback)(_recStream, &PaStreamReadCallback, this);
 }
 
 void AudioDeviceLinuxPulse::DisableReadCallback() {
   LATE(pa_stream_set_read_callback)(_recStream, NULL, NULL);
 }
 
 void AudioDeviceLinuxPulse::PaStreamReadCallback(pa_stream* /*unused1*/,
                                                  size_t /*unused2*/,
                                                  void* pThis) {
   static_cast<AudioDeviceLinuxPulse*>(pThis)->PaStreamReadCallbackHandler();
 }
 
 void AudioDeviceLinuxPulse::PaStreamReadCallbackHandler() {
   // We get the data pointer and size now in order to save one Lock/Unlock
   // in the worker thread.
   if (LATE(pa_stream_peek)(_recStream, &_tempSampleData,
                            &_tempSampleDataSize) != 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "  Can't read data!");
+    LOG(LS_ERROR) << "Can't read data!";
     return;
   }
 
   // Since we consume the data asynchronously on a different thread, we have
   // to temporarily disable the read callback or else Pulse will call it
   // continuously until we consume the data. We re-enable it below.
   DisableReadCallback();
   _timeEventRec.Set();
 }
 
 void AudioDeviceLinuxPulse::PaStreamOverflowCallback(pa_stream* /*unused*/,
                                                      void* pThis) {
   static_cast<AudioDeviceLinuxPulse*>(pThis)->PaStreamOverflowCallbackHandler();
 }
 
 void AudioDeviceLinuxPulse::PaStreamOverflowCallbackHandler() {
-  WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "  Recording overflow");
+  LOG(LS_WARNING) << "Recording overflow";
 }
 
 int32_t AudioDeviceLinuxPulse::LatencyUsecs(pa_stream* stream) {
   if (!WEBRTC_PA_REPORT_LATENCY) {
     return 0;
   }
 
   if (!stream) {
     return 0;
   }
 
   pa_usec_t latency;
   int negative;
   if (LATE(pa_stream_get_latency)(stream, &latency, &negative) != 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "  Can't query latency");
+    LOG(LS_ERROR) << "Can't query latency";
     // We'd rather continue playout/capture with an incorrect delay than
     // stop it altogether, so return a valid value.
     return 0;
   }
 
   if (negative) {
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                 "  warning: pa_stream_get_latency reported negative "
-                 "delay");
+    LOG(LS_VERBOSE) << "warning: pa_stream_get_latency reported negative delay";
 
     // The delay can be negative for monitoring streams if the captured
     // samples haven't been played yet. In such a case, "latency"
     // contains the magnitude, so we must negate it to get the real value.
     int32_t tmpLatency = (int32_t)-latency;
     if (tmpLatency < 0) {
       // Make sure that we don't use a negative delay.
       tmpLatency = 0;
     }
 
@@ skipping 112 matching lines @@
     return -1;
   }
 
   if (AGC()) {
     newMicLevel = _ptrAudioBuffer->NewMicLevel();
     if (newMicLevel != 0) {
       // The VQE will only deliver non-zero microphone levels when a
       // change is needed.
       // Set this new mic level (received from the observer as return
       // value in the callback).
-      WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id,
-                   "  AGC change of volume: old=%u => new=%u", currentMicLevel,
-                   newMicLevel);
+      LOG(LS_VERBOSE) << "AGC change of volume: old=" << currentMicLevel
+                      << " => new=" << newMicLevel;
       if (SetMicrophoneVolume(newMicLevel) == -1) {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     "  the required modification of the microphone "
-                     "volume failed");
+        LOG(LS_WARNING)
+            << "the required modification of the microphone volume failed";
       }
     }
   }
 
   return 0;
 }
 
 bool AudioDeviceLinuxPulse::PlayThreadFunc(void* pThis) {
   return (static_cast<AudioDeviceLinuxPulse*>(pThis)->PlayThreadProcess());
 }
 
 bool AudioDeviceLinuxPulse::RecThreadFunc(void* pThis) {
   return (static_cast<AudioDeviceLinuxPulse*>(pThis)->RecThreadProcess());
 }
 
 bool AudioDeviceLinuxPulse::PlayThreadProcess() {
   switch (_timeEventPlay.Wait(1000)) {
     case kEventSignaled:
       break;
     case kEventError:
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "EventWrapper::Wait() failed");
+      LOG(LS_WARNING) << "EventWrapper::Wait() failed";
       return true;
     case kEventTimeout:
       return true;
   }
 
   rtc::CritScope lock(&_critSect);
 
   if (_startPlay) {
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "_startPlay true, performing initial actions");
+    LOG(LS_VERBOSE) << "_startPlay true, performing initial actions";
 
     _startPlay = false;
     _playDeviceName = NULL;
 
     // Set if not default device
     if (_outputDeviceIndex > 0) {
       // Get the playout device name
       _playDeviceName = new char[kAdmMaxDeviceNameSize];
       _deviceIndex = _outputDeviceIndex;
       PlayoutDevices();
@@ skipping 27 matching lines @@
       // Set the same volume for all channels
       const pa_sample_spec* spec = LATE(pa_stream_get_sample_spec)(_playStream);
       LATE(pa_cvolume_set)(&cVolumes, spec->channels, volume);
       update_speaker_volume_at_startup_ = false;
     }
 
     // Connect the stream to a sink
     if (LATE(pa_stream_connect_playback)(
             _playStream, _playDeviceName, &_playBufferAttr,
             (pa_stream_flags_t)_playStreamFlags, ptr_cvolume, NULL) != PA_OK) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to connect play stream, err=%d",
-                   LATE(pa_context_errno)(_paContext));
+      LOG(LS_ERROR) << "failed to connect play stream, err="
+                    << LATE(pa_context_errno)(_paContext);
     }
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                 "  play stream connected");
+    LOG(LS_VERBOSE) << "play stream connected";
 
     // Wait for state change
     while (LATE(pa_stream_get_state)(_playStream) != PA_STREAM_READY) {
       LATE(pa_threaded_mainloop_wait)(_paMainloop);
     }
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  play stream ready");
+    LOG(LS_VERBOSE) << "play stream ready";
 
     // We can now handle write callbacks
     EnableWriteCallback();
 
     PaUnLock();
 
     // Clear device name
     if (_playDeviceName) {
       delete[] _playDeviceName;
       _playDeviceName = NULL;
@@ skipping 17 matching lines @@
         write = _tempBufferSpace;
       }
 
       PaLock();
       if (LATE(pa_stream_write)(
               _playStream, (void*)&_playBuffer[_playbackBufferUnused], write,
               NULL, (int64_t)0, PA_SEEK_RELATIVE) != PA_OK) {
         _writeErrors++;
         if (_writeErrors > 10) {
           if (_playError == 1) {
-            WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id,
-                         "  pending playout error exists");
+            LOG(LS_WARNING) << "pending playout error exists";
           }
           // Triggers callback from module process thread.
           _playError = 1;
-          WEBRTC_TRACE(kTraceError, kTraceUtility, _id,
-                       "  kPlayoutError message posted: "
-                       "_writeErrors=%u, error=%d",
-                       _writeErrors, LATE(pa_context_errno)(_paContext));
+          LOG(LS_ERROR) << "kPlayoutError message posted: _writeErrors="
+                        << _writeErrors
+                        << ", error=" << LATE(pa_context_errno)(_paContext);
           _writeErrors = 0;
         }
       }
       PaUnLock();
 
       _playbackBufferUnused += write;
       _tempBufferSpace -= write;
     }
 
     uint32_t numPlaySamples = _playbackBufferSize / (2 * _playChannels);
     // Might have been reduced to zero by the above.
     if (_tempBufferSpace > 0) {
       // Ask for new PCM data to be played out using the
       // AudioDeviceBuffer ensure that this callback is executed
       // without taking the audio-thread lock.
       UnLock();
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  requesting data");
+      LOG(LS_VERBOSE) << "requesting data";
       uint32_t nSamples = _ptrAudioBuffer->RequestPlayoutData(numPlaySamples);
       Lock();
 
       // We have been unlocked - check the flag again.
       if (!_playing) {
         return true;
       }
 
       nSamples = _ptrAudioBuffer->GetPlayoutData(_playBuffer);
       if (nSamples != numPlaySamples) {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  invalid number of output samples(%d)", nSamples);
+        LOG(LS_ERROR) << "invalid number of output samples(" << nSamples << ")";
       }
 
       size_t write = _playbackBufferSize;
       if (_tempBufferSpace < write) {
         write = _tempBufferSpace;
       }
 
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  will write");
+      LOG(LS_VERBOSE) << "will write";
       PaLock();
       if (LATE(pa_stream_write)(_playStream, (void*)&_playBuffer[0], write,
                                 NULL, (int64_t)0, PA_SEEK_RELATIVE) != PA_OK) {
         _writeErrors++;
         if (_writeErrors > 10) {
           if (_playError == 1) {
-            WEBRTC_TRACE(kTraceWarning, kTraceUtility, _id,
-                         "  pending playout error exists");
+            LOG(LS_WARNING) << "pending playout error exists";
           }
           // Triggers callback from module process thread.
           _playError = 1;
-          WEBRTC_TRACE(kTraceError, kTraceUtility, _id,
-                       "  kPlayoutError message posted: "
-                       "_writeErrors=%u, error=%d",
-                       _writeErrors, LATE(pa_context_errno)(_paContext));
+          LOG(LS_ERROR) << "kPlayoutError message posted: _writeErrors="
+                        << _writeErrors
+                        << ", error=" << LATE(pa_context_errno)(_paContext);
           _writeErrors = 0;
         }
       }
       PaUnLock();
 
       _playbackBufferUnused = write;
     }
 
     _tempBufferSpace = 0;
     PaLock();
     EnableWriteCallback();
     PaUnLock();
 
   }  // _playing
 
   return true;
 }
 
 bool AudioDeviceLinuxPulse::RecThreadProcess() {
   switch (_timeEventRec.Wait(1000)) {
     case kEventSignaled:
       break;
     case kEventError:
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "EventWrapper::Wait() failed");
+      LOG(LS_WARNING) << "EventWrapper::Wait() failed";
       return true;
     case kEventTimeout:
       return true;
   }
 
   rtc::CritScope lock(&_critSect);
 
   if (_startRec) {
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "_startRec true, performing initial actions");
+    LOG(LS_VERBOSE) << "_startRec true, performing initial actions";
 
     _recDeviceName = NULL;
 
     // Set if not default device
     if (_inputDeviceIndex > 0) {
       // Get the recording device name
       _recDeviceName = new char[kAdmMaxDeviceNameSize];
       _deviceIndex = _inputDeviceIndex;
       RecordingDevices();
     }
 
     PaLock();
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  connecting stream");
+    LOG(LS_VERBOSE) << "connecting stream";
 
     // Connect the stream to a source
     if (LATE(pa_stream_connect_record)(
             _recStream, _recDeviceName, &_recBufferAttr,
             (pa_stream_flags_t)_recStreamFlags) != PA_OK) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  failed to connect rec stream, err=%d",
-                   LATE(pa_context_errno)(_paContext));
+      LOG(LS_ERROR) << "failed to connect rec stream, err="
+                    << LATE(pa_context_errno)(_paContext);
     }
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  connected");
+    LOG(LS_VERBOSE) << "connected";
 
     // Wait for state change
     while (LATE(pa_stream_get_state)(_recStream) != PA_STREAM_READY) {
       LATE(pa_threaded_mainloop_wait)(_paMainloop);
     }
 
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "  done");
+    LOG(LS_VERBOSE) << "done";
 
     // We can now handle read callbacks
     EnableReadCallback();
 
     PaUnLock();
 
     // Clear device name
     if (_recDeviceName) {
       delete[] _recDeviceName;
       _recDeviceName = NULL;
@@ skipping 12 matching lines @@
       return true;
     }
 
     _tempSampleData = NULL;
     _tempSampleDataSize = 0;
 
     PaLock();
     while (true) {
       // Ack the last thing we read
       if (LATE(pa_stream_drop)(_recStream) != 0) {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     "  failed to drop, err=%d\n",
-                     LATE(pa_context_errno)(_paContext));
+        LOG(LS_WARNING) << "failed to drop, err="
+                        << LATE(pa_context_errno)(_paContext);
       }
 
       if (LATE(pa_stream_readable_size)(_recStream) <= 0) {
         // Then that was all the data
         break;
       }
 
       // Else more data.
       const void* sampleData;
       size_t sampleDataSize;
 
       if (LATE(pa_stream_peek)(_recStream, &sampleData, &sampleDataSize) != 0) {
         _recError = 1;  // triggers callback from module process thread
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  RECORD_ERROR message posted, error = %d",
-                     LATE(pa_context_errno)(_paContext));
+        LOG(LS_ERROR) << "RECORD_ERROR message posted, error = "
+                      << LATE(pa_context_errno)(_paContext);
         break;
       }
 
       _sndCardRecDelay = (uint32_t)(LatencyUsecs(_recStream) / 1000);
 
       // Drop lock for sigslot dispatch, which could take a while.
       PaUnLock();
       // Read data and provide it to VoiceEngine
       if (ReadRecordedData(sampleData, sampleDataSize) == -1) {
         return true;
@@ skipping 24 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);
 }
 }  // namespace webrtc