Replace WEBRTC_TRACE logging in modules/audio_device/.. mac/ win/

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.
  */
 
 #include "webrtc/modules/audio_device/mac/audio_device_mac.h"
 #include "webrtc/modules/audio_device/audio_device_config.h"
 #include "webrtc/modules/audio_device/mac/portaudio/pa_ringbuffer.h"
 #include "webrtc/rtc_base/arraysize.h"
 #include "webrtc/rtc_base/checks.h"
-#include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/platform_thread.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
-#include "webrtc/system_wrappers/include/trace.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <libkern/OSAtomic.h>  // OSAtomicCompareAndSwap()
 #include <mach/mach.h>         // mach_task_self()
 #include <sys/sysctl.h>        // sysctlbyname()
 
 namespace webrtc {
 
 #define WEBRTC_CA_RETURN_ON_ERR(expr)                                  \
   do {                                                                 \
     err = expr;                                                        \
     if (err != noErr) {                                                \
-      logCAMsg(kTraceError, kTraceAudioDevice, _id, "Error in " #expr, \
+      logCAMsg(rtc::LS_ERROR, "Error in " #expr,                       \
                (const char*) & err);                                   \
       return -1;                                                       \
     }                                                                  \
   } while (0)
 
 #define WEBRTC_CA_LOG_ERR(expr)                                        \
   do {                                                                 \
     err = expr;                                                        \
     if (err != noErr) {                                                \
-      logCAMsg(kTraceError, kTraceAudioDevice, _id, "Error in " #expr, \
+      logCAMsg(rtc::LS_ERROR, "Error in " #expr,                       \
                (const char*) & err);                                   \
     }                                                                  \
   } while (0)
 
 #define WEBRTC_CA_LOG_WARN(expr)                                         \
   do {                                                                   \
     err = expr;                                                          \
     if (err != noErr) {                                                  \
-      logCAMsg(kTraceWarning, kTraceAudioDevice, _id, "Error in " #expr, \
+      logCAMsg(rtc::LS_WARNING, "Error in " #expr,                       \
                (const char*) & err);                                     \
     }                                                                    \
   } while (0)
 
 enum { MaxNumberDevices = 64 };
 
 void AudioDeviceMac::AtomicSet32(int32_t* theValue, int32_t newValue) {
   while (1) {
     int32_t oldValue = *theValue;
     if (OSAtomicCompareAndSwap32Barrier(oldValue, newValue, theValue) == true) {
       return;
     }
   }
 }
 
 int32_t AudioDeviceMac::AtomicGet32(int32_t* theValue) {
   while (1) {
     int32_t value = *theValue;
     if (OSAtomicCompareAndSwap32Barrier(value, value, theValue) == true) {
       return value;
     }
   }
 }
 
 // CoreAudio errors are best interpreted as four character strings.
-void AudioDeviceMac::logCAMsg(const TraceLevel level,
-                              const TraceModule module,
-                              const int32_t id,
+void AudioDeviceMac::logCAMsg(const rtc::LoggingSeverity sev,
                               const char* msg,
                               const char* err) {
   RTC_DCHECK(msg != NULL);
   RTC_DCHECK(err != NULL);
 
 #ifdef WEBRTC_ARCH_BIG_ENDIAN
-  WEBRTC_TRACE(level, module, id, "%s: %.4s", msg, err);
+  switch (sev) {
+    case rtc::LS_ERROR:
+      LOG(LS_ERROR) << msg << ": " << err[0] << err[1] << err[2] << err[3];
+      break;
+    case rtc::LS_WARNING:
+      LOG(LS_WARNING) << msg << ": " << err[0] << err[1] << err[2] << err[3];
+      break;
+    case rtc::LS_VERBOSE:
+      LOG(LS_VERBOSE) << msg << ": " << err[0] << err[1] << err[2] << err[3];
+      break;
+    default:
+      break;
+  }
 #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);
+   switch (sev) {
+    case rtc::LS_ERROR:
+      LOG(LS_ERROR) << msg << ": " << err[3] << err[2] << err[1] << err[0];
+      break;
+    case rtc::LS_WARNING:
+      LOG(LS_WARNING) << msg << ": " << err[3] << err[2] << err[1] << err[0];
+      break;
+    case rtc::LS_VERBOSE:
+      LOG(LS_VERBOSE) << msg << ": " << err[3] << err[2] << err[1] << err[0];
+      break;
+    default:
+      break;
+  }
 #endif
 }
 
-AudioDeviceMac::AudioDeviceMac(const int32_t id)
+AudioDeviceMac::AudioDeviceMac()
     : _ptrAudioBuffer(NULL),
       _stopEventRec(*EventWrapper::Create()),
       _stopEvent(*EventWrapper::Create()),
-      _id(id),
-      _mixerManager(id),
+      _mixerManager(),
       _inputDeviceIndex(0),
       _outputDeviceIndex(0),
       _inputDeviceID(kAudioObjectUnknown),
       _outputDeviceID(kAudioObjectUnknown),
       _inputDeviceIsSpecified(false),
       _outputDeviceIsSpecified(false),
       _recChannels(N_REC_CHANNELS),
       _playChannels(N_PLAY_CHANNELS),
       _captureBufData(NULL),
       _renderBufData(NULL),
@@ skipping 21 matching lines @@
       _playWarning(0),
       _playError(0),
       _recWarning(0),
       _recError(0),
       _paCaptureBuffer(NULL),
       _paRenderBuffer(NULL),
       _captureBufSizeSamples(0),
       _renderBufSizeSamples(0),
       prev_key_state_(),
       get_mic_volume_counter_ms_(0) {
-  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
+  LOG(LS_INFO) << __FUNCTION__ << " created";
 
   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__);
+  LOG(LS_INFO) << __FUNCTION__ << " destroyed";
 
   if (!_isShutDown) {
     Terminate();
   }
 
   RTC_DCHECK(!capture_worker_thread_.get());
   RTC_DCHECK(!render_worker_thread_.get());
 
   if (_paRenderBuffer) {
     delete _paRenderBuffer;
@@ skipping 11 matching lines @@
   }
 
   if (_captureBufData) {
     delete[] _captureBufData;
     _captureBufData = NULL;
   }
 
   kern_return_t kernErr = KERN_SUCCESS;
   kernErr = semaphore_destroy(mach_task_self(), _renderSemaphore);
   if (kernErr != KERN_SUCCESS) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " semaphore_destroy() error: %d", kernErr);
+    LOG(LS_ERROR) << "semaphore_destroy() error: " << kernErr;
   }
 
   kernErr = semaphore_destroy(mach_task_self(), _captureSemaphore);
   if (kernErr != KERN_SUCCESS) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " semaphore_destroy() error: %d", kernErr);
+    LOG(LS_ERROR) << "semaphore_destroy() error: " << kernErr;
   }
 
   delete &_stopEvent;
   delete &_stopEventRec;
 }
 
 // ============================================================================
 //                                     API
 // ============================================================================
 
@@ skipping 35 matching lines @@
     _renderBufSizeSamples = powerOfTwo;
     _renderBufData = new SInt16[_renderBufSizeSamples];
   }
 
   if (_paRenderBuffer == NULL) {
     _paRenderBuffer = new PaUtilRingBuffer;
     PaRingBufferSize bufSize = -1;
     bufSize = PaUtil_InitializeRingBuffer(
         _paRenderBuffer, sizeof(SInt16), _renderBufSizeSamples, _renderBufData);
     if (bufSize == -1) {
-      WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
-                   " PaUtil_InitializeRingBuffer() error");
+      LOG(LS_ERROR) << "PaUtil_InitializeRingBuffer() error";
       return InitStatus::PLAYOUT_ERROR;
     }
   }
 
   if (_captureBufData == NULL) {
     UInt32 powerOfTwo = 1;
     while (powerOfTwo < REC_BUF_SIZE_IN_SAMPLES) {
       powerOfTwo <<= 1;
     }
     _captureBufSizeSamples = powerOfTwo;
     _captureBufData = new Float32[_captureBufSizeSamples];
   }
 
   if (_paCaptureBuffer == NULL) {
     _paCaptureBuffer = new PaUtilRingBuffer;
     PaRingBufferSize bufSize = -1;
     bufSize =
         PaUtil_InitializeRingBuffer(_paCaptureBuffer, sizeof(Float32),
                                     _captureBufSizeSamples, _captureBufData);
     if (bufSize == -1) {
-      WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
-                   " PaUtil_InitializeRingBuffer() error");
+      LOG(LS_ERROR) << "PaUtil_InitializeRingBuffer() error";
       return InitStatus::RECORDING_ERROR;
     }
   }
 
   kern_return_t kernErr = KERN_SUCCESS;
   kernErr = semaphore_create(mach_task_self(), &_renderSemaphore,
                              SYNC_POLICY_FIFO, 0);
   if (kernErr != KERN_SUCCESS) {
-    WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
-                 " semaphore_create() error: %d", kernErr);
+    LOG(LS_ERROR) << "semaphore_create() error: " << kernErr;
     return InitStatus::OTHER_ERROR;
   }
 
   kernErr = semaphore_create(mach_task_self(), &_captureSemaphore,
                              SYNC_POLICY_FIFO, 0);
   if (kernErr != KERN_SUCCESS) {
-    WEBRTC_TRACE(kTraceCritical, kTraceAudioDevice, _id,
-                 " semaphore_create() error: %d", kernErr);
+    LOG(LS_ERROR) << "semaphore_create() error: " << kernErr;
     return InitStatus::OTHER_ERROR;
   }
 
   // Setting RunLoop to NULL here instructs HAL to manage its own thread for
   // notifications. This was the default behaviour on OS X 10.5 and earlier,
   // but now must be explicitly specified. HAL would otherwise try to use the
   // main thread to issue notifications.
   AudioObjectPropertyAddress propertyAddress = {
       kAudioHardwarePropertyRunLoop, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
@@ skipping 14 matching lines @@
 
   // Determine if this is a MacBook Pro
   _macBookPro = false;
   _macBookProPanRight = false;
   char buf[128];
   size_t length = sizeof(buf);
   memset(buf, 0, length);
 
   int intErr = sysctlbyname("hw.model", buf, &length, NULL, 0);
   if (intErr != 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " Error in sysctlbyname(): %d", err);
+    LOG(LS_ERROR) << "Error in sysctlbyname(): " << err;
   } else {
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Hardware model: %s",
-                 buf);
+    LOG(LS_VERBOSE) << "Hardware model: " << buf;
     if (strncmp(buf, "MacBookPro", 10) == 0) {
       _macBookPro = true;
     }
   }
 
   _playWarning = 0;
   _playError = 0;
   _recWarning = 0;
   _recError = 0;
 
   get_mic_volume_counter_ms_ = 0;
 
   _initialized = true;
 
   return InitStatus::OK;
 }
 
 int32_t AudioDeviceMac::Terminate() {
   if (!_initialized) {
     return 0;
   }
 
   if (_recording) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " Recording must be stopped");
+    LOG(LS_ERROR) << "Recording must be stopped";
     return -1;
   }
 
   if (_playing) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " Playback must be stopped");
+    LOG(LS_ERROR) << "Playback must be stopped";
     return -1;
   }
 
   _critSect.Enter();
 
   _mixerManager.Close();
 
   OSStatus err = noErr;
   int retVal = 0;
 
   AudioObjectPropertyAddress propertyAddress = {
       kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
   WEBRTC_CA_LOG_WARN(AudioObjectRemovePropertyListener(
       kAudioObjectSystemObject, &propertyAddress, &objectListenerProc, this));
 
   err = AudioHardwareUnload();
   if (err != noErr) {
-    logCAMsg(kTraceError, kTraceAudioDevice, _id,
+    logCAMsg(rtc::LS_ERROR,
              "Error in AudioHardwareUnload()", (const char*)&err);
     retVal = -1;
   }
 
   _isShutDown = true;
   _initialized = false;
   _outputDeviceIsSpecified = false;
   _inputDeviceIsSpecified = false;
 
   _critSect.Leave();
@@ skipping 145 matching lines @@
   if (_mixerManager.SpeakerVolume(level) == -1) {
     return -1;
   }
 
   volume = level;
   return 0;
 }
 
 int32_t AudioDeviceMac::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 AudioDeviceMac::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 AudioDeviceMac::MaxSpeakerVolume(uint32_t& maxVolume) const {
   uint32_t maxVol(0);
 
   if (_mixerManager.MaxSpeakerVolume(maxVol) == -1) {
     return -1;
   }
 
@@ skipping 278 matching lines @@
 }
 
 int32_t AudioDeviceMac::SetMicrophoneVolume(uint32_t volume) {
   return (_mixerManager.SetMicrophoneVolume(volume));
 }
 
 int32_t AudioDeviceMac::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 AudioDeviceMac::MaxMicrophoneVolume(uint32_t& maxVolume) const {
   uint32_t maxVol(0);
 
@@ skipping 36 matching lines @@
 int32_t AudioDeviceMac::SetPlayoutDevice(uint16_t index) {
   rtc::CritScope lock(&_critSect);
 
   if (_playIsInitialized) {
     return -1;
   }
 
   AudioDeviceID playDevices[MaxNumberDevices];
   uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeOutput,
                                        playDevices, MaxNumberDevices);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "  number of availiable waveform-audio output devices is %u",
-               nDevices);
+  LOG(LS_VERBOSE) << "number of available waveform-audio 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 AudioDeviceMac::SetPlayoutDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/) {
-  WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-               "WindowsDeviceType not supported");
+  LOG(LS_ERROR) << "WindowsDeviceType not supported";
   return -1;
 }
 
 int32_t AudioDeviceMac::PlayoutDeviceName(uint16_t index,
                                           char name[kAdmMaxDeviceNameSize],
                                           char guid[kAdmMaxGuidSize]) {
   const uint16_t nDevices(PlayoutDevices());
 
   if ((index > (nDevices - 1)) || (name == NULL)) {
     return -1;
@@ skipping 33 matching lines @@
 }
 
 int32_t AudioDeviceMac::SetRecordingDevice(uint16_t index) {
   if (_recIsInitialized) {
     return -1;
   }
 
   AudioDeviceID recDevices[MaxNumberDevices];
   uint32_t nDevices = GetNumberDevices(kAudioDevicePropertyScopeInput,
                                        recDevices, MaxNumberDevices);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "  number of availiable waveform-audio input devices is %u",
-               nDevices);
+  LOG(LS_VERBOSE) << "number of available waveform-audio 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 AudioDeviceMac::SetRecordingDevice(
     AudioDeviceModule::WindowsDeviceType /*device*/) {
-  WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-               "WindowsDeviceType not supported");
+  LOG(LS_ERROR) << "WindowsDeviceType not supported";
   return -1;
 }
 
 int32_t AudioDeviceMac::PlayoutIsAvailable(bool& available) {
   available = true;
 
   // Try to initialize the playout side
   if (InitPlayout() == -1) {
     available = false;
   }
@@ skipping 46 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";
   }
 
   if (!MicrophoneIsInitialized()) {
     // Make this call to check if we are using
     // one or two devices (_twoDevices)
     bool available = false;
     if (MicrophoneIsAvailable(available) == -1) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "  MicrophoneIsAvailable() failed");
+      LOG(LS_WARNING) << "MicrophoneIsAvailable() failed";
     }
   }
 
   PaUtil_FlushRingBuffer(_paRenderBuffer);
 
   OSStatus err = noErr;
   UInt32 size = 0;
   _renderDelayOffsetSamples = 0;
   _renderDelayUs = 0;
   _renderLatencyUs = 0;
@@ skipping 10 matching lines @@
     Boolean hasProperty =
         AudioObjectHasProperty(_outputDeviceID, &propertyAddress);
     if (hasProperty) {
       UInt32 dataSource = 0;
       size = sizeof(dataSource);
       WEBRTC_CA_LOG_WARN(AudioObjectGetPropertyData(
           _outputDeviceID, &propertyAddress, 0, NULL, &size, &dataSource));
 
       if (dataSource == 'ispk') {
         _macBookProPanRight = true;
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                     "MacBook Pro using internal speakers; stereo"
-                     " panning right");
+        LOG(LS_VERBOSE)
+            << "MacBook Pro using internal speakers; stereo panning right";
       } else {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                     "MacBook Pro not using internal speakers");
+        LOG(LS_VERBOSE) << "MacBook Pro not using internal speakers";
       }
 
       // Add a listener to determine if the status changes.
       WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(
           _outputDeviceID, &propertyAddress, &objectListenerProc, this));
     }
   }
 
   // Get current stream description
   propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   memset(&_outStreamFormat, 0, sizeof(_outStreamFormat));
   size = sizeof(_outStreamFormat);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
       _outputDeviceID, &propertyAddress, 0, NULL, &size, &_outStreamFormat));
 
   if (_outStreamFormat.mFormatID != kAudioFormatLinearPCM) {
-    logCAMsg(kTraceError, kTraceAudioDevice, _id,
+    logCAMsg(rtc::LS_ERROR,
              "Unacceptable output stream format -> mFormatID",
              (const char*)&_outStreamFormat.mFormatID);
     return -1;
   }
 
   if (_outStreamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "Too many channels on output device (mChannelsPerFrame = %d)",
-                 _outStreamFormat.mChannelsPerFrame);
+    LOG(LS_ERROR) << "Too many channels on output device (mChannelsPerFrame = "
+                  << _outStreamFormat.mChannelsPerFrame << ")";
     return -1;
   }
 
   if (_outStreamFormat.mFormatFlags & kAudioFormatFlagIsNonInterleaved) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "Non-interleaved audio data is not supported.",
-                 "AudioHardware streams should not have this format.");
+    LOG(LS_ERROR) << "Non-interleaved audio data is not supported."
+                  << "AudioHardware streams should not have this format.";
     return -1;
   }
 
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Ouput stream format:");
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "mSampleRate = %f, mChannelsPerFrame = %u",
-               _outStreamFormat.mSampleRate,
-               _outStreamFormat.mChannelsPerFrame);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "mBytesPerPacket = %u, mFramesPerPacket = %u",
-               _outStreamFormat.mBytesPerPacket,
-               _outStreamFormat.mFramesPerPacket);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "mBytesPerFrame = %u, mBitsPerChannel = %u",
-               _outStreamFormat.mBytesPerFrame,
-               _outStreamFormat.mBitsPerChannel);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "mFormatFlags = %u",
-               _outStreamFormat.mFormatFlags);
-  logCAMsg(kTraceInfo, kTraceAudioDevice, _id, "mFormatID",
+  LOG(LS_VERBOSE) << "Ouput stream format:";
+  LOG(LS_VERBOSE) << "mSampleRate = " << _outStreamFormat.mSampleRate
+                  << ", mChannelsPerFrame = "
+                  << _outStreamFormat.mChannelsPerFrame;
+  LOG(LS_VERBOSE) << "mBytesPerPacket = " << _outStreamFormat.mBytesPerPacket
+                  << ", mFramesPerPacket = "
+                  << _outStreamFormat.mFramesPerPacket;
+  LOG(LS_VERBOSE) << "mBytesPerFrame = " << _outStreamFormat.mBytesPerFrame
+                  << ", mBitsPerChannel = " << _outStreamFormat.mBitsPerChannel;
+  LOG(LS_VERBOSE) << "mFormatFlags = " << _outStreamFormat.mFormatFlags;
+  logCAMsg(rtc::LS_VERBOSE, "mFormatID",
            (const char*)&_outStreamFormat.mFormatID);
 
   // Our preferred format to work with.
   if (_outStreamFormat.mChannelsPerFrame < 2) {
     // Disable stereo playout when we only have one channel on the device.
     _playChannels = 1;
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "Stereo playout unavailable on this device");
+    LOG(LS_VERBOSE) << "Stereo playout unavailable on this device";
   }
   WEBRTC_CA_RETURN_ON_ERR(SetDesiredPlayoutFormat());
 
   // Listen for format changes.
   propertyAddress.mSelector = kAudioDevicePropertyStreamFormat;
   WEBRTC_CA_LOG_WARN(AudioObjectAddPropertyListener(
       _outputDeviceID, &propertyAddress, &objectListenerProc, this));
 
   // Listen for processor overloads.
   propertyAddress.mSelector = kAudioDeviceProcessorOverload;
@@ skipping 20 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";
   }
 
   if (!SpeakerIsInitialized()) {
     // Make this call to check if we are using
     // one or two devices (_twoDevices)
     bool available = false;
     if (SpeakerIsAvailable(available) == -1) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "  SpeakerIsAvailable() failed");
+      LOG(LS_WARNING) << "SpeakerIsAvailable() failed";
     }
   }
 
   OSStatus err = noErr;
   UInt32 size = 0;
 
   PaUtil_FlushRingBuffer(_paCaptureBuffer);
 
   _captureDelayUs = 0;
   _captureLatencyUs = 0;
   _captureDeviceIsAlive = 1;
   _doStopRec = false;
 
   // Get current stream description
   AudioObjectPropertyAddress propertyAddress = {
       kAudioDevicePropertyStreamFormat, kAudioDevicePropertyScopeInput, 0};
   memset(&_inStreamFormat, 0, sizeof(_inStreamFormat));
   size = sizeof(_inStreamFormat);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
       _inputDeviceID, &propertyAddress, 0, NULL, &size, &_inStreamFormat));
 
   if (_inStreamFormat.mFormatID != kAudioFormatLinearPCM) {
-    logCAMsg(kTraceError, kTraceAudioDevice, _id,
+    logCAMsg(rtc::LS_ERROR,
              "Unacceptable input stream format -> mFormatID",
              (const char*)&_inStreamFormat.mFormatID);
     return -1;
   }
 
   if (_inStreamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "Too many channels on input device (mChannelsPerFrame = %d)",
-                 _inStreamFormat.mChannelsPerFrame);
+    LOG(LS_ERROR) << "Too many channels on input device (mChannelsPerFrame = "
+                  << _inStreamFormat.mChannelsPerFrame << ")";
     return -1;
   }
 
   const int io_block_size_samples = _inStreamFormat.mChannelsPerFrame *
                                     _inStreamFormat.mSampleRate / 100 *
                                     N_BLOCKS_IO;
   if (io_block_size_samples > _captureBufSizeSamples) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "Input IO block size (%d) is larger than ring buffer (%u)",
-                 io_block_size_samples, _captureBufSizeSamples);
+    LOG(LS_ERROR) << "Input IO block size (" << io_block_size_samples
+                  << ") is larger than ring buffer (" << _captureBufSizeSamples
+                  << ")";
     return -1;
   }
 
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Input stream format:");
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               " mSampleRate = %f, mChannelsPerFrame = %u",
-               _inStreamFormat.mSampleRate, _inStreamFormat.mChannelsPerFrame);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               " mBytesPerPacket = %u, mFramesPerPacket = %u",
-               _inStreamFormat.mBytesPerPacket,
-               _inStreamFormat.mFramesPerPacket);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               " mBytesPerFrame = %u, mBitsPerChannel = %u",
-               _inStreamFormat.mBytesPerFrame, _inStreamFormat.mBitsPerChannel);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " mFormatFlags = %u",
-               _inStreamFormat.mFormatFlags);
-  logCAMsg(kTraceInfo, kTraceAudioDevice, _id, "mFormatID",
+  LOG(LS_VERBOSE) << "Input stream format:";
+  LOG(LS_VERBOSE) << "mSampleRate = " << _inStreamFormat.mSampleRate
+                  << ", mChannelsPerFrame = "
+                  << _inStreamFormat.mChannelsPerFrame;
+  LOG(LS_VERBOSE) << "mBytesPerPacket = " << _inStreamFormat.mBytesPerPacket
+                  << ", mFramesPerPacket = "
+                  << _inStreamFormat.mFramesPerPacket;
+  LOG(LS_VERBOSE) << "mBytesPerFrame = " << _inStreamFormat.mBytesPerFrame
+                  << ", mBitsPerChannel = " << _inStreamFormat.mBitsPerChannel;
+  LOG(LS_VERBOSE) << "mFormatFlags = " << _inStreamFormat.mFormatFlags;
+  logCAMsg(rtc::LS_VERBOSE, "mFormatID",
            (const char*)&_inStreamFormat.mFormatID);
 
   // Our preferred format to work with
   if (_inStreamFormat.mChannelsPerFrame >= 2 && (_recChannels == 2)) {
     _inDesiredFormat.mChannelsPerFrame = 2;
   } else {
     // Disable stereo recording when we only have one channel on the device.
     _inDesiredFormat.mChannelsPerFrame = 1;
     _recChannels = 1;
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                 "Stereo recording unavailable on this device");
+    LOG(LS_VERBOSE) << "Stereo recording unavailable on this device";
   }
 
   if (_ptrAudioBuffer) {
     // Update audio buffer with the selected parameters
     _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
     _ptrAudioBuffer->SetRecordingChannels((uint8_t)_recChannels);
   }
 
   _inDesiredFormat.mSampleRate = N_REC_SAMPLES_PER_SEC;
   _inDesiredFormat.mBytesPerPacket =
@@ skipping 96 matching lines @@
 
   if (!_recIsInitialized) {
     return -1;
   }
 
   if (_recording) {
     return 0;
   }
 
   if (!_initialized) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " Recording worker thread has not been started");
+    LOG(LS_ERROR) << "Recording worker thread has not been started";
     return -1;
   }
 
   RTC_DCHECK(!capture_worker_thread_.get());
   capture_worker_thread_.reset(
       new rtc::PlatformThread(RunCapture, this, "CaptureWorkerThread"));
   RTC_DCHECK(capture_worker_thread_.get());
   capture_worker_thread_->Start();
   capture_worker_thread_->SetPriority(rtc::kRealtimePriority);
 
@@ skipping 21 matching lines @@
 
   // Stop device
   int32_t captureDeviceIsAlive = AtomicGet32(&_captureDeviceIsAlive);
   if (_twoDevices) {
     if (_recording && captureDeviceIsAlive == 1) {
       _recording = false;
       _doStopRec = true;  // Signal to io proc to stop audio device
       _critSect.Leave();  // Cannot be under lock, risk of deadlock
       if (kEventTimeout == _stopEventRec.Wait(2000)) {
         rtc::CritScope critScoped(&_critSect);
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     " Timed out stopping the capture IOProc. "
-                     "We may have failed to detect a device removal.");
+        LOG(LS_WARNING)
+            << "Timed out stopping the capture IOProc."
+            << "We may have failed to detect a device removal.";
 
         WEBRTC_CA_LOG_WARN(AudioDeviceStop(_inputDeviceID, _inDeviceIOProcID));
         WEBRTC_CA_LOG_WARN(
             AudioDeviceDestroyIOProcID(_inputDeviceID, _inDeviceIOProcID));
       }
       _critSect.Enter();
       _doStopRec = false;
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, " Recording stopped");
+      LOG(LS_VERBOSE) << "Recording stopped";
     }
   } else {
     // We signal a stop for a shared device even when rendering has
     // not yet ended. This is to ensure the IOProc will return early as
     // intended (by checking |_recording|) before accessing
     // resources we free below (e.g. the capture converter).
     //
     // In the case of a shared devcie, the IOProc will verify
     // rendering has ended before stopping itself.
     if (_recording && captureDeviceIsAlive == 1) {
       _recording = false;
       _doStop = true;     // Signal to io proc to stop audio device
       _critSect.Leave();  // Cannot be under lock, risk of deadlock
       if (kEventTimeout == _stopEvent.Wait(2000)) {
         rtc::CritScope critScoped(&_critSect);
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     " Timed out stopping the shared IOProc. "
-                     "We may have failed to detect a device removal.");
+        LOG(LS_WARNING)
+            << "Timed out stopping the shared IOProc."
+            << "We may have failed to detect a device removal.";
 
         // We assume rendering on a shared device has stopped as well if
         // the IOProc times out.
         WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
         WEBRTC_CA_LOG_WARN(
             AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
       }
       _critSect.Enter();
       _doStop = false;
-      WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                   " Recording stopped (shared)");
+      LOG(LS_VERBOSE) << "Recording stopped (shared)";
     }
   }
 
   // Setting this signal will allow the worker thread to be stopped.
   AtomicSet32(&_captureDeviceIsAlive, 0);
 
   if (capture_worker_thread_.get()) {
     _critSect.Leave();
     capture_worker_thread_->Stop();
     capture_worker_thread_.reset();
@@ skipping 72 matching lines @@
     // intended (by checking |_playing|) before accessing resources we
     // free below (e.g. the render converter).
     //
     // In the case of a shared device, the IOProc will verify capturing
     // has ended before stopping itself.
     _playing = false;
     _doStop = true;     // Signal to io proc to stop audio device
     _critSect.Leave();  // Cannot be under lock, risk of deadlock
     if (kEventTimeout == _stopEvent.Wait(2000)) {
       rtc::CritScope critScoped(&_critSect);
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   " Timed out stopping the render IOProc. "
-                   "We may have failed to detect a device removal.");
+      LOG(LS_WARNING)
+          << "Timed out stopping the render IOProc."
+          << "We may have failed to detect a device removal.";
 
       // We assume capturing on a shared device has stopped as well if the
       // IOProc times out.
       WEBRTC_CA_LOG_WARN(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
       WEBRTC_CA_LOG_WARN(
           AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
     }
     _critSect.Enter();
     _doStop = false;
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "Playout stopped");
+    LOG(LS_VERBOSE) << "Playout stopped";
   }
 
   // Setting this signal will allow the worker thread to be stopped.
   AtomicSet32(&_renderDeviceIsAlive, 0);
   if (render_worker_thread_.get()) {
     _critSect.Leave();
     render_worker_thread_->Stop();
     render_worker_thread_.reset();
     _critSect.Enter();
   }
@@ skipping 41 matching lines @@
 }
 
 bool AudioDeviceMac::Playing() const {
   return (_playing);
 }
 
 int32_t AudioDeviceMac::SetPlayoutBuffer(
     const AudioDeviceModule::BufferType type,
     uint16_t sizeMS) {
   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 AudioDeviceMac::PlayoutBuffer(AudioDeviceModule::BufferType& type,
                                       uint16_t& sizeMS) const {
   type = _playBufType;
   sizeMS = _playBufDelayFixed;
 
   return 0;
 }
 
 // Not implemented for Mac.
 int32_t AudioDeviceMac::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 AudioDeviceMac::PlayoutWarning() const {
   return (_playWarning > 0);
 }
 
 bool AudioDeviceMac::PlayoutError() const {
   return (_playError > 0);
@@ skipping 32 matching lines @@
                                          const uint32_t deviceListLength) {
   OSStatus err = noErr;
 
   AudioObjectPropertyAddress propertyAddress = {
       kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
   UInt32 size = 0;
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyDataSize(
       kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size));
   if (size == 0) {
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "No devices");
+    LOG(LS_WARNING) << "No devices";
     return 0;
   }
 
   AudioDeviceID* deviceIds = (AudioDeviceID*)malloc(size);
   UInt32 numberDevices = size / sizeof(AudioDeviceID);
   AudioBufferList* bufferList = NULL;
   UInt32 numberScopedDevices = 0;
 
   // First check if there is a default device and list it
   UInt32 hardwareProperty = 0;
   if (scope == kAudioDevicePropertyScopeOutput) {
     hardwareProperty = kAudioHardwarePropertyDefaultOutputDevice;
   } else {
     hardwareProperty = kAudioHardwarePropertyDefaultInputDevice;
   }
 
   AudioObjectPropertyAddress propertyAddressDefault = {
       hardwareProperty, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
 
   AudioDeviceID usedID;
   UInt32 uintSize = sizeof(UInt32);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                                      &propertyAddressDefault, 0,
                                                      NULL, &uintSize, &usedID));
   if (usedID != kAudioDeviceUnknown) {
     scopedDeviceIds[numberScopedDevices] = usedID;
     numberScopedDevices++;
   } else {
-    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                 "GetNumberDevices(): Default device unknown");
+    LOG(LS_WARNING) << "GetNumberDevices(): Default device unknown";
   }
 
   // Then list the rest of the devices
   bool listOK = true;
 
   WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(
       kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, deviceIds));
   if (err != noErr) {
     listOK = false;
   } else {
@@ skipping 15 matching lines @@
       bufferList = (AudioBufferList*)malloc(size);
       WEBRTC_CA_LOG_ERR(AudioObjectGetPropertyData(
           deviceIds[i], &propertyAddress, 0, NULL, &size, bufferList));
       if (err != noErr) {
         listOK = false;
         break;
       }
 
       if (bufferList->mNumberBuffers > 0) {
         if (numberScopedDevices >= deviceListLength) {
-          WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                       "Device list is not long enough");
+          LOG(LS_ERROR) << "Device list is not long enough";
           listOK = false;
           break;
         }
 
         scopedDeviceIds[numberScopedDevices] = deviceIds[i];
         numberScopedDevices++;
       }
 
       free(bufferList);
       bufferList = NULL;
@@ skipping 27 matching lines @@
                                       const uint16_t index,
                                       char* name) {
   OSStatus err = noErr;
   UInt32 len = kAdmMaxDeviceNameSize;
   AudioDeviceID deviceIds[MaxNumberDevices];
 
   int numberDevices = GetNumberDevices(scope, deviceIds, MaxNumberDevices);
   if (numberDevices < 0) {
     return -1;
   } else if (numberDevices == 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "No devices");
+    LOG(LS_ERROR) << "No devices";
     return -1;
   }
 
   // If the number is below the number of devices, assume it's "WEBRTC ID"
   // otherwise assume it's a CoreAudio ID
   AudioDeviceID usedID;
 
   // Check if there is a default device
   bool isDefaultDevice = false;
   if (index == 0) {
     UInt32 hardwareProperty = 0;
     if (scope == kAudioDevicePropertyScopeOutput) {
       hardwareProperty = kAudioHardwarePropertyDefaultOutputDevice;
     } else {
       hardwareProperty = kAudioHardwarePropertyDefaultInputDevice;
     }
     AudioObjectPropertyAddress propertyAddress = {
         hardwareProperty, kAudioObjectPropertyScopeGlobal,
         kAudioObjectPropertyElementMaster};
     UInt32 size = sizeof(UInt32);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
         kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, &usedID));
     if (usedID == kAudioDeviceUnknown) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "GetDeviceName(): Default device unknown");
+      LOG(LS_WARNING) << "GetDeviceName(): Default device unknown";
     } else {
       isDefaultDevice = true;
     }
   }
 
   AudioObjectPropertyAddress propertyAddress = {kAudioDevicePropertyDeviceName,
                                                 scope, 0};
 
   if (isDefaultDevice) {
     char devName[len];
@@ skipping 36 matching lines @@
   AudioObjectPropertyAddress propertyAddress = {
       defaultDeviceSelector, kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster};
 
   // Get the actual device IDs
   int numberDevices =
       GetNumberDevices(deviceScope, deviceIds, MaxNumberDevices);
   if (numberDevices < 0) {
     return -1;
   } else if (numberDevices == 0) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "InitDevice(): No devices");
+    LOG(LS_ERROR) << "InitDevice(): No devices";
     return -1;
   }
 
   bool isDefaultDevice = false;
   deviceId = kAudioDeviceUnknown;
   if (userDeviceIndex == 0) {
     // Try to use default system device
     size = sizeof(AudioDeviceID);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
         kAudioObjectSystemObject, &propertyAddress, 0, NULL, &size, &deviceId));
     if (deviceId == kAudioDeviceUnknown) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   " No default device exists");
+      LOG(LS_WARNING) << "No default device exists";
     } else {
       isDefaultDevice = true;
     }
   }
 
   if (!isDefaultDevice) {
     deviceId = deviceIds[userDeviceIndex];
   }
 
   // Obtain device name and manufacturer for logging.
   // Also use this as a test to ensure a user-set device ID is valid.
   char devName[128];
   char devManf[128];
   memset(devName, 0, sizeof(devName));
   memset(devManf, 0, sizeof(devManf));
 
   propertyAddress.mSelector = kAudioDevicePropertyDeviceName;
   propertyAddress.mScope = deviceScope;
   propertyAddress.mElement = 0;
   size = sizeof(devName);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId, &propertyAddress,
                                                      0, NULL, &size, devName));
 
   propertyAddress.mSelector = kAudioDevicePropertyDeviceManufacturer;
   size = sizeof(devManf);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(deviceId, &propertyAddress,
                                                      0, NULL, &size, devManf));
 
   if (isInput) {
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Input device: %s %s",
-                 devManf, devName);
+    LOG(LS_VERBOSE) << "Input device: " << devManf << " " << devName;
   } else {
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, " Output device: %s %s",
-                 devManf, devName);
+    LOG(LS_VERBOSE) << "Output device: " << devManf << " " << devName;
   }
 
   return 0;
 }
 
 OSStatus AudioDeviceMac::SetDesiredPlayoutFormat() {
   // Our preferred format to work with.
   _outDesiredFormat.mSampleRate = N_PLAY_SAMPLES_PER_SEC;
   _outDesiredFormat.mChannelsPerFrame = _playChannels;
 
@@ skipping 74 matching lines @@
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
       _outputDeviceID, &propertyAddress, 0, NULL, &size, &stream));
   propertyAddress.mSelector = kAudioStreamPropertyLatency;
   size = sizeof(UInt32);
   latency = 0;
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
       _outputDeviceID, &propertyAddress, 0, NULL, &size, &latency));
   _renderLatencyUs +=
       static_cast<uint32_t>((1.0e6 * latency) / _outStreamFormat.mSampleRate);
 
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "  initial playout status: _renderDelayOffsetSamples=%d,"
-               " _renderDelayUs=%d, _renderLatencyUs=%d",
-               _renderDelayOffsetSamples, _renderDelayUs, _renderLatencyUs);
+  LOG(LS_VERBOSE) << "initial playout status: _renderDelayOffsetSamples="
+                  << _renderDelayOffsetSamples << ", _renderDelayUs="
+                  << _renderDelayUs << ", _renderLatencyUs="
+                  << _renderLatencyUs;
   return 0;
 }
 
 OSStatus AudioDeviceMac::objectListenerProc(
     AudioObjectID objectId,
     UInt32 numberAddresses,
     const AudioObjectPropertyAddress addresses[],
     void* clientData) {
   AudioDeviceMac* ptrThis = (AudioDeviceMac*)clientData;
   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,
     const AudioObjectPropertyAddress addresses[]) {
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-               "AudioDeviceMac::implObjectListenerProc()");
+  LOG(LS_VERBOSE) << "AudioDeviceMac::implObjectListenerProc()";
 
   for (UInt32 i = 0; i < numberAddresses; i++) {
     if (addresses[i].mSelector == kAudioHardwarePropertyDevices) {
       HandleDeviceChange();
     } else if (addresses[i].mSelector == kAudioDevicePropertyStreamFormat) {
       HandleStreamFormatChange(objectId, addresses[i]);
     } else if (addresses[i].mSelector == kAudioDevicePropertyDataSource) {
       HandleDataSourceChange(objectId, addresses[i]);
     } else if (addresses[i].mSelector == kAudioDeviceProcessorOverload) {
       HandleProcessorOverload(addresses[i]);
     }
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::HandleDeviceChange() {
   OSStatus err = noErr;
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-               "kAudioHardwarePropertyDevices");
+  LOG(LS_VERBOSE) << "kAudioHardwarePropertyDevices";
 
   // A device has changed. Check if our registered devices have been removed.
   // Ensure the devices have been initialized, meaning the IDs are valid.
   if (MicrophoneIsInitialized()) {
     AudioObjectPropertyAddress propertyAddress = {
         kAudioDevicePropertyDeviceIsAlive, kAudioDevicePropertyScopeInput, 0};
     UInt32 deviceIsAlive = 1;
     UInt32 size = sizeof(UInt32);
     err = AudioObjectGetPropertyData(_inputDeviceID, &propertyAddress, 0, NULL,
                                      &size, &deviceIsAlive);
 
     if (err == kAudioHardwareBadDeviceError || deviceIsAlive == 0) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "Capture device is not alive (probably removed)");
+      LOG(LS_WARNING) << "Capture device is not alive (probably removed)";
       AtomicSet32(&_captureDeviceIsAlive, 0);
       _mixerManager.CloseMicrophone();
       if (_recError == 1) {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     "  pending recording error exists");
+        LOG(LS_WARNING) << "pending recording error exists";
       }
       _recError = 1;  // triggers callback from module process thread
     } else if (err != noErr) {
-      logCAMsg(kTraceError, kTraceAudioDevice, _id,
+      logCAMsg(rtc::LS_ERROR,
                "Error in AudioDeviceGetProperty()", (const char*)&err);
       return -1;
     }
   }
 
   if (SpeakerIsInitialized()) {
     AudioObjectPropertyAddress propertyAddress = {
         kAudioDevicePropertyDeviceIsAlive, kAudioDevicePropertyScopeOutput, 0};
     UInt32 deviceIsAlive = 1;
     UInt32 size = sizeof(UInt32);
     err = AudioObjectGetPropertyData(_outputDeviceID, &propertyAddress, 0, NULL,
                                      &size, &deviceIsAlive);
 
     if (err == kAudioHardwareBadDeviceError || deviceIsAlive == 0) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                   "Render device is not alive (probably removed)");
+      LOG(LS_WARNING) << "Render device is not alive (probably removed)";
       AtomicSet32(&_renderDeviceIsAlive, 0);
       _mixerManager.CloseSpeaker();
       if (_playError == 1) {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-                     "  pending playout error exists");
+        LOG(LS_WARNING) << "pending playout error exists";
       }
       _playError = 1;  // triggers callback from module process thread
     } else if (err != noErr) {
-      logCAMsg(kTraceError, kTraceAudioDevice, _id,
+      logCAMsg(rtc::LS_ERROR,
                "Error in AudioDeviceGetProperty()", (const char*)&err);
       return -1;
     }
   }
 
   return 0;
 }
 
 int32_t AudioDeviceMac::HandleStreamFormatChange(
     const AudioObjectID objectId,
     const AudioObjectPropertyAddress propertyAddress) {
   OSStatus err = noErr;
 
-  WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "Stream format changed");
+  LOG(LS_VERBOSE) << "Stream format changed";
 
   if (objectId != _inputDeviceID && objectId != _outputDeviceID) {
     return 0;
   }
 
   // Get the new device format
   AudioStreamBasicDescription streamFormat;
   UInt32 size = sizeof(streamFormat);
   WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
       objectId, &propertyAddress, 0, NULL, &size, &streamFormat));
 
   if (streamFormat.mFormatID != kAudioFormatLinearPCM) {
-    logCAMsg(kTraceError, kTraceAudioDevice, _id,
+    logCAMsg(rtc::LS_ERROR,
              "Unacceptable input stream format -> mFormatID",
              (const char*)&streamFormat.mFormatID);
     return -1;
   }
 
   if (streamFormat.mChannelsPerFrame > N_DEVICE_CHANNELS) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "Too many channels on device (mChannelsPerFrame = %d)",
-                 streamFormat.mChannelsPerFrame);
+    LOG(LS_ERROR) << "Too many channels on device (mChannelsPerFrame = "
+                  << streamFormat.mChannelsPerFrame << ")";
     return -1;
   }
 
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "Stream format:");
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "mSampleRate = %f, mChannelsPerFrame = %u",
-               streamFormat.mSampleRate, streamFormat.mChannelsPerFrame);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "mBytesPerPacket = %u, mFramesPerPacket = %u",
-               streamFormat.mBytesPerPacket, streamFormat.mFramesPerPacket);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-               "mBytesPerFrame = %u, mBitsPerChannel = %u",
-               streamFormat.mBytesPerFrame, streamFormat.mBitsPerChannel);
-  WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "mFormatFlags = %u",
-               streamFormat.mFormatFlags);
-  logCAMsg(kTraceInfo, kTraceAudioDevice, _id, "mFormatID",
+  LOG(LS_VERBOSE) << "Stream format:";
+  LOG(LS_VERBOSE) << "mSampleRate = " << streamFormat.mSampleRate
+                  << ", mChannelsPerFrame = " << streamFormat.mChannelsPerFrame;
+  LOG(LS_VERBOSE) << "mBytesPerPacket = " << streamFormat.mBytesPerPacket
+                  << ", mFramesPerPacket = " << streamFormat.mFramesPerPacket;
+  LOG(LS_VERBOSE) << "mBytesPerFrame = " << streamFormat.mBytesPerFrame
+                  << ", mBitsPerChannel = " << streamFormat.mBitsPerChannel;
+  LOG(LS_VERBOSE) << "mFormatFlags = " << streamFormat.mFormatFlags;
+  logCAMsg(rtc::LS_VERBOSE, "mFormatID",
            (const char*)&streamFormat.mFormatID);
 
   if (propertyAddress.mScope == kAudioDevicePropertyScopeInput) {
     const int io_block_size_samples = streamFormat.mChannelsPerFrame *
                                       streamFormat.mSampleRate / 100 *
                                       N_BLOCKS_IO;
     if (io_block_size_samples > _captureBufSizeSamples) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "Input IO block size (%d) is larger than ring buffer (%u)",
-                   io_block_size_samples, _captureBufSizeSamples);
+      LOG(LS_ERROR) << "Input IO block size (" << io_block_size_samples
+                    << ") is larger than ring buffer ("
+                    << _captureBufSizeSamples << ")";
       return -1;
     }
 
     memcpy(&_inStreamFormat, &streamFormat, sizeof(streamFormat));
 
     if (_inStreamFormat.mChannelsPerFrame >= 2 && (_recChannels == 2)) {
       _inDesiredFormat.mChannelsPerFrame = 2;
     } else {
       // Disable stereo recording when we only have one channel on the device.
       _inDesiredFormat.mChannelsPerFrame = 1;
       _recChannels = 1;
-      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                   "Stereo recording unavailable on this device");
+      LOG(LS_VERBOSE) << "Stereo recording unavailable on this device";
     }
 
     if (_ptrAudioBuffer) {
       // Update audio buffer with the selected parameters
       _ptrAudioBuffer->SetRecordingSampleRate(N_REC_SAMPLES_PER_SEC);
       _ptrAudioBuffer->SetRecordingChannels((uint8_t)_recChannels);
     }
 
     // Recreate the converter with the new format
     // TODO(xians): make this thread safe
     WEBRTC_CA_RETURN_ON_ERR(AudioConverterDispose(_captureConverter));
 
     WEBRTC_CA_RETURN_ON_ERR(AudioConverterNew(&streamFormat, &_inDesiredFormat,
                                               &_captureConverter));
   } else {
     memcpy(&_outStreamFormat, &streamFormat, sizeof(streamFormat));
 
     // Our preferred format to work with
     if (_outStreamFormat.mChannelsPerFrame < 2) {
       _playChannels = 1;
-      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                   "Stereo playout unavailable on this device");
+      LOG(LS_VERBOSE) << "Stereo playout unavailable on this device";
     }
     WEBRTC_CA_RETURN_ON_ERR(SetDesiredPlayoutFormat());
   }
   return 0;
 }
 
 int32_t AudioDeviceMac::HandleDataSourceChange(
     const AudioObjectID objectId,
     const AudioObjectPropertyAddress propertyAddress) {
   OSStatus err = noErr;
 
   if (_macBookPro &&
       propertyAddress.mScope == kAudioDevicePropertyScopeOutput) {
-    WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id, "Data source changed");
+    LOG(LS_VERBOSE) << "Data source changed";
 
     _macBookProPanRight = false;
     UInt32 dataSource = 0;
     UInt32 size = sizeof(UInt32);
     WEBRTC_CA_RETURN_ON_ERR(AudioObjectGetPropertyData(
         objectId, &propertyAddress, 0, NULL, &size, &dataSource));
     if (dataSource == 'ispk') {
       _macBookProPanRight = true;
-      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                   "MacBook Pro using internal speakers; stereo panning right");
+      LOG(LS_VERBOSE)
+          << "MacBook Pro using internal speakers; stereo panning right";
     } else {
-      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                   "MacBook Pro not using internal speakers");
+      LOG(LS_VERBOSE) << "MacBook Pro not using internal speakers";
     }
   }
 
   return 0;
 }
 int32_t AudioDeviceMac::HandleProcessorOverload(
     const AudioObjectPropertyAddress propertyAddress) {
   // TODO(xians): we probably want to notify the user in some way of the
   // overload. However, the Windows interpretations of these errors seem to
   // be more severe than what ProcessorOverload is thrown for.
   //
   // We don't log the notification, as it's sent from the HAL's IO thread. We
   // don't want to slow it down even further.
   if (propertyAddress.mScope == kAudioDevicePropertyScopeInput) {
-    // WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "Capture processor
-    // overload");
+    // LOG(LS_WARNING) << "Capture processor // overload";
     //_callback->ProblemIsReported(
     // SndCardStreamObserver::ERecordingProblem);
   } else {
-    // WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
-    // "Render processor overload");
+    // LOG(LS_WARNING) << "Render processor overload";
     //_callback->ProblemIsReported(
     // SndCardStreamObserver::EPlaybackProblem);
   }
 
   return 0;
 }
 
 // ============================================================================
 //                                  Thread Methods
 // ============================================================================
@@ skipping 70 matching lines @@
   if (_doStop) {
     _critSect.Enter();
     if (_doStop) {
       if (_twoDevices || (!_recording && !_playing)) {
         // In the case of a shared device, the single driving ioProc
         // is stopped here
         WEBRTC_CA_LOG_ERR(AudioDeviceStop(_outputDeviceID, _deviceIOProcID));
         WEBRTC_CA_LOG_WARN(
             AudioDeviceDestroyIOProcID(_outputDeviceID, _deviceIOProcID));
         if (err == noErr) {
-          WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                       " Playout or shared device stopped");
+          LOG(LS_VERBOSE) << "Playout or shared device stopped";
         }
       }
 
       _doStop = false;
       _stopEvent.Set();
       _critSect.Leave();
       return 0;
     }
     _critSect.Leave();
   }
 
   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;
   }
 
   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) {
       // This is our own error.
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   " Error in AudioConverterFillComplexBuffer()");
+      LOG(LS_ERROR) << "Error in AudioConverterFillComplexBuffer()";
       return 1;
     } else {
-      logCAMsg(kTraceError, kTraceAudioDevice, _id,
+      logCAMsg(rtc::LS_ERROR,
                "Error in AudioConverterFillComplexBuffer()", (const char*)&err);
       return 1;
     }
   }
 
   PaRingBufferSize bufSizeSamples =
       PaUtil_GetRingBufferReadAvailable(_paRenderBuffer);
 
   int32_t renderDelayUs =
       static_cast<int32_t>(1e-3 * (outputTimeNs - nowNs) + 0.5);
@@ skipping 17 matching lines @@
   // 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));
 
   PaUtil_ReadRingBuffer(_paRenderBuffer, _renderConvertData, numSamples);
 
   kern_return_t kernErr = semaphore_signal_all(_renderSemaphore);
   if (kernErr != KERN_SUCCESS) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 " semaphore_signal_all() error: %d", kernErr);
+    LOG(LS_ERROR) << "semaphore_signal_all() error: " << kernErr;
     return 1;
   }
 
   return 0;
 }
 
 OSStatus AudioDeviceMac::implInDeviceIOProc(const AudioBufferList* inputData,
                                             const AudioTimeStamp* inputTime) {
   OSStatus err = noErr;
   UInt64 inputTimeNs = AudioConvertHostTimeToNanos(inputTime->mHostTime);
   UInt64 nowNs = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
 
   // Check if we should close down audio device
   // Double-checked locking optimization to remove locking overhead
   if (_doStopRec) {
     _critSect.Enter();
     if (_doStopRec) {
       // This will be signalled only when a shared device is not in use.
       WEBRTC_CA_LOG_ERR(AudioDeviceStop(_inputDeviceID, _inDeviceIOProcID));
       WEBRTC_CA_LOG_WARN(
           AudioDeviceDestroyIOProcID(_inputDeviceID, _inDeviceIOProcID));
       if (err == noErr) {
-        WEBRTC_TRACE(kTraceDebug, kTraceAudioDevice, _id,
-                     " Recording device stopped");
+        LOG(LS_VERBOSE) << "Recording device stopped";
       }
 
       _doStopRec = false;
       _stopEventRec.Set();
       _critSect.Leave();
       return 0;
     }
     _critSect.Leave();
   }
 
@@ skipping 16 matching lines @@
 
   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);
+    LOG(LS_ERROR) << "semaphore_signal_all() error: " << kernErr;
   }
 
   return err;
 }
 
 OSStatus AudioDeviceMac::implInConverterProc(UInt32* numberDataPackets,
                                              AudioBufferList* data) {
   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);
     if (kernErr == KERN_OPERATION_TIMED_OUT) {
       int32_t signal = AtomicGet32(&_captureDeviceIsAlive);
       if (signal == 0) {
         // The capture device is no longer alive; stop the worker thread.
         *numberDataPackets = 0;
         return 1;
       }
     } else if (kernErr != KERN_SUCCESS) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   " semaphore_wait() error: %d", kernErr);
+      LOG(LS_ERROR) << "semaphore_wait() error: " << kernErr;
     }
   }
 
   // Pass the read pointer directly to the converter to avoid a memcpy.
   void* dummyPtr;
   PaRingBufferSize dummySize;
   PaUtil_GetRingBufferReadRegions(_paCaptureBuffer, numSamples,
                                   &data->mBuffers->mData, &numSamples,
                                   &dummyPtr, &dummySize);
   PaUtil_AdvanceRingBufferReadIndex(_paCaptureBuffer, numSamples);
@@ skipping 21 matching lines @@
     timeout.tv_nsec = TIMER_PERIOD_MS;
 
     kern_return_t kernErr = semaphore_timedwait(_renderSemaphore, timeout);
     if (kernErr == KERN_OPERATION_TIMED_OUT) {
       int32_t signal = AtomicGet32(&_renderDeviceIsAlive);
       if (signal == 0) {
         // The render device is no longer alive; stop the worker thread.
         return false;
       }
     } else if (kernErr != KERN_SUCCESS) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   " semaphore_timedwait() error: %d", kernErr);
+      LOG(LS_ERROR) << "semaphore_timedwait() error: " << kernErr;
     }
   }
 
   int8_t playBuffer[4 * ENGINE_PLAY_BUF_SIZE_IN_SAMPLES];
 
   if (!_ptrAudioBuffer) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  capture AudioBuffer is invalid");
+    LOG(LS_ERROR) << "capture AudioBuffer is invalid";
     return false;
   }
 
   // Ask for new PCM data to be played out using the AudioDeviceBuffer.
   uint32_t nSamples =
       _ptrAudioBuffer->RequestPlayoutData(ENGINE_PLAY_BUF_SIZE_IN_SAMPLES);
 
   nSamples = _ptrAudioBuffer->GetPlayoutData(playBuffer);
   if (nSamples != ENGINE_PLAY_BUF_SIZE_IN_SAMPLES) {
-    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                 "  invalid number of output samples(%d)", nSamples);
+    LOG(LS_ERROR) << "invalid number of output samples(" << nSamples << ")";
   }
 
   uint32_t nOutSamples = nSamples * _outDesiredFormat.mChannelsPerFrame;
 
   SInt16* pPlayBuffer = (SInt16*)&playBuffer;
   if (_macBookProPanRight && (_playChannels == 2)) {
     // Mix entirely into the right channel and zero the left channel.
     SInt32 sampleInt32 = 0;
     for (uint32_t sampleIdx = 0; sampleIdx < nOutSamples; sampleIdx += 2) {
       sampleInt32 = pPlayBuffer[sampleIdx];
@@ skipping 34 matching lines @@
       _inDesiredFormat.mBytesPerPacket * noRecSamples;
   engineBuffer.mBuffers->mData = recordBuffer;
 
   err = AudioConverterFillComplexBuffer(_captureConverter, inConverterProc,
                                         this, &size, &engineBuffer, NULL);
   if (err != noErr) {
     if (err == 1) {
       // This is our own error.
       return false;
     } else {
-      logCAMsg(kTraceError, kTraceAudioDevice, _id,
+      logCAMsg(rtc::LS_ERROR,
                "Error in AudioConverterFillComplexBuffer()", (const char*)&err);
       return false;
     }
   }
 
   // TODO(xians): what if the returned size is incorrect?
   if (size == ENGINE_REC_BUF_SIZE_IN_SAMPLES) {
     uint32_t currentMicLevel(0);
     uint32_t newMicLevel(0);
     int32_t msecOnPlaySide;
     int32_t msecOnRecordSide;
 
     int32_t captureDelayUs = AtomicGet32(&_captureDelayUs);
     int32_t renderDelayUs = AtomicGet32(&_renderDelayUs);
 
     msecOnPlaySide =
         static_cast<int32_t>(1e-3 * (renderDelayUs + _renderLatencyUs) + 0.5);
     msecOnRecordSide =
         static_cast<int32_t>(1e-3 * (captureDelayUs + _captureLatencyUs) + 0.5);
 
     if (!_ptrAudioBuffer) {
-      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                   "  capture AudioBuffer is invalid");
+      LOG(LS_ERROR) << "capture AudioBuffer is invalid";
       return false;
     }
 
     // store the recorded buffer (no action will be taken if the
     // #recorded samples is not a full buffer)
     _ptrAudioBuffer->SetRecordedBuffer((int8_t*)&recordBuffer, (uint32_t)size);
 
     if (AGC()) {
       // Use mod to ensure we check the volume on the first pass.
       if (get_mic_volume_counter_ms_ % kGetMicVolumeIntervalMs == 0) {
@@ skipping 15 matching lines @@
     // to the observer using callback
     _ptrAudioBuffer->DeliverRecordedData();
 
     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 true;
 }
 
 bool AudioDeviceMac::KeyPressed() {
   bool key_down = false;
   // Loop through all Mac virtual key constant values.
   for (unsigned int key_index = 0; key_index < arraysize(prev_key_state_);
        ++key_index) {
     bool keyState =
         CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, key_index);
     // A false -> true change in keymap means a key is pressed.
     key_down |= (keyState && !prev_key_state_[key_index]);
     // Save current state.
     prev_key_state_[key_index] = keyState;
   }
   return key_down;
 }
 }  // namespace webrtc