Simplify logging statements.

webrtc/modules/audio_device/audio_device_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 542 matching lines @@
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->SpeakerVolumeIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetSpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetSpeakerVolume(uint32_t volume) {
   LOG(INFO) << __FUNCTION__ << "(" << volume << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetSpeakerVolume(volume));
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SpeakerVolume(uint32_t* volume) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint32_t level(0);
 
   if (_ptrAudioDevice->SpeakerVolume(level) == -1) {
     return -1;
   }
 
   *volume = level;
-
-  LOG(INFO) << __FUNCTION__ << " output: " << *volume;
+  LOG(INFO) << "output: " << *volume;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetWaveOutVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetWaveOutVolume(uint16_t volumeLeft,
                                                 uint16_t volumeRight) {
   LOG(INFO) << __FUNCTION__ << "(" << volumeLeft << ", " << volumeRight << ")";
@@ skipping 12 matching lines @@
 
   uint16_t volLeft(0);
   uint16_t volRight(0);
 
   if (_ptrAudioDevice->WaveOutVolume(volLeft, volRight) == -1) {
     return -1;
   }
 
   *volumeLeft = volLeft;
   *volumeRight = volRight;
-
-  LOG(INFO) << __FUNCTION__ << " output: volumeLeft = " << *volumeLeft
-            << ", volumeRight = " << *volumeRight;
+  LOG(INFO) << "output: " << *volumeLeft << ", " << *volumeRight;
 
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceModuleImpl::SpeakerIsInitialized() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
 
   bool isInitialized = _ptrAudioDevice->SpeakerIsInitialized();
-
-  if (isInitialized) {
-    LOG(INFO) << __FUNCTION__ << " output: initialized";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not initialized";
-  }
+  LOG(INFO) << "output: " << isInitialized;
   return (isInitialized);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceModuleImpl::MicrophoneIsInitialized() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
 
   bool isInitialized = _ptrAudioDevice->MicrophoneIsInitialized();
-
-  if (isInitialized) {
-    LOG(INFO) << __FUNCTION__ << " output: initialized";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not initialized";
-  }
+  LOG(INFO) << "output: " << isInitialized;
   return (isInitialized);
 }
 
 // ----------------------------------------------------------------------------
 //  MaxSpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MaxSpeakerVolume(uint32_t* maxVolume) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint32_t maxVol(0);
 
   if (_ptrAudioDevice->MaxSpeakerVolume(maxVol) == -1) {
     return -1;
   }
 
   *maxVolume = maxVol;
-
-  LOG(INFO) << __FUNCTION__ << " output: maxVolume = " << *maxVolume;
+  LOG(INFO) << "output: " << *maxVolume;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MinSpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MinSpeakerVolume(uint32_t* minVolume) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint32_t minVol(0);
 
   if (_ptrAudioDevice->MinSpeakerVolume(minVol) == -1) {
     return -1;
   }
 
   *minVolume = minVol;
-
-  LOG(INFO) << __FUNCTION__ << " output: " << *minVolume;
+  LOG(INFO) << "output: " << *minVolume;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerVolumeStepSize
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SpeakerVolumeStepSize(uint16_t* stepSize) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t delta(0);
 
   if (_ptrAudioDevice->SpeakerVolumeStepSize(delta) == -1) {
     LOG(LERROR) << "failed to retrieve the speaker-volume step size";
     return -1;
   }
 
   *stepSize = delta;
-
-  LOG(INFO) << __FUNCTION__ << " output: " << *stepSize;
+  LOG(INFO) << "output: " << *stepSize;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SpeakerMuteIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->SpeakerMuteIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetSpeakerMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetSpeakerMute(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetSpeakerMute(enable));
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SpeakerMute(bool* enabled) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool muted(false);
 
   if (_ptrAudioDevice->SpeakerMute(muted) == -1) {
     return -1;
   }
 
   *enabled = muted;
-
-  if (muted) {
-    LOG(INFO) << __FUNCTION__ << " output: muted";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not muted";
-  }
+  LOG(INFO) << "output: " << muted;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneMuteIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->MicrophoneMuteIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetMicrophoneMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetMicrophoneMute(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetMicrophoneMute(enable));
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneMute(bool* enabled) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool muted(false);
 
   if (_ptrAudioDevice->MicrophoneMute(muted) == -1) {
     return -1;
   }
 
   *enabled = muted;
-
-  if (muted) {
-    LOG(INFO) << __FUNCTION__ << " output: muted";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not muted";
-  }
+  LOG(INFO) << "output: " << muted;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneBoostIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneBoostIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->MicrophoneBoostIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetMicrophoneBoost
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetMicrophoneBoost(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetMicrophoneBoost(enable));
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneBoost
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneBoost(bool* enabled) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool onOff(false);
 
   if (_ptrAudioDevice->MicrophoneBoost(onOff) == -1) {
     return -1;
   }
 
   *enabled = onOff;
-
-  if (onOff) {
-    LOG(INFO) << __FUNCTION__ << " output: enabled";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not enabled";
-  }
+  LOG(INFO) << "output: " << onOff;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolumeIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneVolumeIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->MicrophoneVolumeIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetMicrophoneVolume(uint32_t volume) {
   LOG(INFO) << __FUNCTION__ << "(" << volume << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetMicrophoneVolume(volume));
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneVolume(uint32_t* volume) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint32_t level(0);
 
   if (_ptrAudioDevice->MicrophoneVolume(level) == -1) {
     return -1;
   }
 
   *volume = level;
-
-  LOG(INFO) << __FUNCTION__ << " output: volume = " << *volume;
+  LOG(INFO) << "output: " << *volume;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  StereoRecordingIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StereoRecordingIsAvailable(
     bool* available) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->StereoRecordingIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetStereoRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetStereoRecording(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
 
   if (_ptrAudioDevice->RecordingIsInitialized()) {
     LOG(WARNING) << "recording in stereo is not supported";
     return -1;
   }
 
   if (_ptrAudioDevice->SetStereoRecording(enable) == -1) {
-    if (enable) {
-      LOG(WARNING) << "failed to enable stereo recording";
-    } else {
-      LOG(WARNING) << "failed to disable stereo recording";
-    }
+    LOG(WARNING) << "failed to change stereo recording";
     return -1;
   }
 
   int8_t nChannels(1);
   if (enable) {
     nChannels = 2;
   }
   _audioDeviceBuffer.SetRecordingChannels(nChannels);
 
   return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  StereoRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StereoRecording(bool* enabled) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool stereo(false);
 
   if (_ptrAudioDevice->StereoRecording(stereo) == -1) {
     return -1;
   }
 
   *enabled = stereo;
-
-  if (stereo) {
-    LOG(INFO) << __FUNCTION__ << " output: enabled";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not enabled";
-  }
+  LOG(INFO) << "output: " << stereo;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetRecordingChannel
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetRecordingChannel(const ChannelType channel) {
   if (channel == kChannelBoth) {
     LOG(INFO) << __FUNCTION__ << "(both)";
@@ skipping 22 matching lines @@
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   ChannelType chType;
 
   if (_audioDeviceBuffer.RecordingChannel(chType) == -1) {
     return -1;
   }
 
   *channel = chType;
-
   if (*channel == kChannelBoth) {
-    LOG(INFO) << __FUNCTION__ << " output: both";
+    LOG(INFO) << "output: both";
   } else if (*channel == kChannelLeft) {
-    LOG(INFO) << __FUNCTION__ << " output: left";
+    LOG(INFO) << "output: left";
   } else {
-    LOG(INFO) << __FUNCTION__ << " output: right";
+    LOG(INFO) << "output: right";
   }
-
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  StereoPlayoutIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::StereoPlayoutIsAvailable(bool* available) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->StereoPlayoutIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetStereoPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetStereoPlayout(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
@@ skipping 26 matching lines @@
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool stereo(false);
 
   if (_ptrAudioDevice->StereoPlayout(stereo) == -1) {
     return -1;
   }
 
   *enabled = stereo;
-
-  if (stereo) {
-    LOG(INFO) << __FUNCTION__ << " output: enabled";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not enabled";
-  }
+  LOG(INFO) << "output: " << stereo;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetAGC
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetAGC(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
@@ skipping 18 matching lines @@
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->PlayoutIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::RecordingIsAvailable(bool* available) {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   bool isAvailable(0);
 
   if (_ptrAudioDevice->RecordingIsAvailable(isAvailable) == -1) {
     return -1;
   }
 
   *available = isAvailable;
-
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MaxMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MaxMicrophoneVolume(uint32_t* maxVolume) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint32_t maxVol(0);
 
   if (_ptrAudioDevice->MaxMicrophoneVolume(maxVol) == -1) {
     return -1;
   }
 
   *maxVolume = maxVol;
-
-  LOG(INFO) << __FUNCTION__ << " output: = " << *maxVolume;
+  LOG(INFO) << "output: " << *maxVolume;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MinMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MinMicrophoneVolume(uint32_t* minVolume) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint32_t minVol(0);
 
   if (_ptrAudioDevice->MinMicrophoneVolume(minVol) == -1) {
     return -1;
   }
 
   *minVolume = minVol;
-
-  LOG(INFO) << __FUNCTION__ << " output: = " << *minVolume;
+  LOG(INFO) << "output: " << *minVolume;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolumeStepSize
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::MicrophoneVolumeStepSize(
     uint16_t* stepSize) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t delta(0);
 
   if (_ptrAudioDevice->MicrophoneVolumeStepSize(delta) == -1) {
     return -1;
   }
 
   *stepSize = delta;
-
-  LOG(INFO) << __FUNCTION__ << " output: " << *stepSize;
+  LOG(INFO) << "output: " << *stepSize;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutDevices
 // ----------------------------------------------------------------------------
 
 int16_t AudioDeviceModuleImpl::PlayoutDevices() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t nPlayoutDevices = _ptrAudioDevice->PlayoutDevices();
-
-  LOG(INFO) << __FUNCTION__ << " output: " << nPlayoutDevices;
+  LOG(INFO) << "output: " << nPlayoutDevices;
   return ((int16_t)(nPlayoutDevices));
 }
 
 // ----------------------------------------------------------------------------
 //  SetPlayoutDevice I (II)
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetPlayoutDevice(uint16_t index) {
   LOG(INFO) << __FUNCTION__ << "(" << index << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetPlayoutDevice(index));
 }
 
 // ----------------------------------------------------------------------------
 //  SetPlayoutDevice II (II)
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetPlayoutDevice(WindowsDeviceType device) {
-  if (device == kDefaultDevice) {
-  } else {
-  }
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   return (_ptrAudioDevice->SetPlayoutDevice(device));
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutDeviceName
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::PlayoutDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize]) {
   LOG(INFO) << __FUNCTION__ << "(" << index << ", ...)";
   CHECK_INITIALIZED();
 
   if (name == NULL) {
     _lastError = kAdmErrArgument;
     return -1;
   }
 
   if (_ptrAudioDevice->PlayoutDeviceName(index, name, guid) == -1) {
     return -1;
   }
 
   if (name != NULL) {
-    LOG(INFO) << __FUNCTION__ << " output: name = " << name;
+    LOG(INFO) << "output: name = " << name;
   }
   if (guid != NULL) {
-    LOG(INFO) << __FUNCTION__ << " output: guid = " << guid;
+    LOG(INFO) << "output: guid = " << guid;
   }
 
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDeviceName
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::RecordingDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize]) {
   LOG(INFO) << __FUNCTION__ << "(" << index << ", ...)";
   CHECK_INITIALIZED();
 
   if (name == NULL) {
     _lastError = kAdmErrArgument;
     return -1;
   }
 
   if (_ptrAudioDevice->RecordingDeviceName(index, name, guid) == -1) {
     return -1;
   }
 
   if (name != NULL) {
-    LOG(INFO) << __FUNCTION__ << " output: name = " << name;
+    LOG(INFO) << "output: name = " << name;
   }
   if (guid != NULL) {
-    LOG(INFO) << __FUNCTION__ << " output: guid = " << guid;
+    LOG(INFO) << "output: guid = " << guid;
   }
 
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDevices
 // ----------------------------------------------------------------------------
 
 int16_t AudioDeviceModuleImpl::RecordingDevices() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t nRecordingDevices = _ptrAudioDevice->RecordingDevices();
 
-  LOG(INFO) << __FUNCTION__ << " output: " << nRecordingDevices;
+  LOG(INFO) << "output: " << nRecordingDevices;
   return ((int16_t)nRecordingDevices);
 }
 
 // ----------------------------------------------------------------------------
 //  SetRecordingDevice I (II)
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetRecordingDevice(uint16_t index) {
   LOG(INFO) << __FUNCTION__ << "(" << index << ")";
   CHECK_INITIALIZED();
   return (_ptrAudioDevice->SetRecordingDevice(index));
 }
 
 // ----------------------------------------------------------------------------
 //  SetRecordingDevice II (II)
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetRecordingDevice(WindowsDeviceType device) {
-  if (device == kDefaultDevice) {
-  } else {
-  }
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   return (_ptrAudioDevice->SetRecordingDevice(device));
 }
 
 // ----------------------------------------------------------------------------
 //  InitPlayout
 // ----------------------------------------------------------------------------
 
@@ skipping 198 matching lines @@
   return (_audioDeviceBuffer.StopOutputFileRecording());
 }
 
 // ----------------------------------------------------------------------------
 //  SetPlayoutBuffer
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetPlayoutBuffer(const BufferType type,
                                                 uint16_t sizeMS) {
   if (type == kFixedBufferSize) {
-    LOG(INFO) << __FUNCTION__ << "("
-              << "fixed buffer, " << sizeMS << "ms"
-              << ")";
+    LOG(INFO) << __FUNCTION__ << "(fixed buffer, " << sizeMS << "ms)";
   } else if (type == kAdaptiveBufferSize) {
-    LOG(INFO) << __FUNCTION__ << "("
-              << "adaptive buffer, " << sizeMS << "ms"
-              << ")";
+    LOG(INFO) << __FUNCTION__ << "(adaptive buffer, " << sizeMS << "ms)";
   } else {
-    LOG(INFO) << __FUNCTION__ << "("
-              << "?, " << sizeMS << "ms"
-              << ")";
+    LOG(INFO) << __FUNCTION__ << "(?, " << sizeMS << "ms)";
   }
   CHECK_INITIALIZED();
 
   if (_ptrAudioDevice->PlayoutIsInitialized()) {
     LOG(LERROR) << "unable to modify the playout buffer while playing side is "
                    "initialized";
     return -1;
   }
 
   int32_t ret(0);
@@ skipping 27 matching lines @@
   uint16_t size(0);
 
   if (_ptrAudioDevice->PlayoutBuffer(bufType, size) == -1) {
     LOG(LERROR) << "failed to retrieve the buffer type and size";
     return -1;
   }
 
   *type = bufType;
   *sizeMS = size;
 
-  LOG(INFO) << __FUNCTION__ << " output: type = " << *type
-            << ", sizeMS = " << *sizeMS;
+  LOG(INFO) << "output: type = " << *type << ", sizeMS = " << *sizeMS;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutDelay
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::PlayoutDelay(uint16_t* delayMS) const {
   LOG(LS_VERBOSE) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t delay(0);
 
   if (_ptrAudioDevice->PlayoutDelay(delay) == -1) {
     LOG(LERROR) << "failed to retrieve the playout delay";
     return -1;
   }
 
   *delayMS = delay;
-
-  LOG(LS_VERBOSE) << __FUNCTION__ << " output: delayMS = " << *delayMS;
+  LOG(LS_VERBOSE) << "output: " << *delayMS;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDelay
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::RecordingDelay(uint16_t* delayMS) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t delay(0);
 
   if (_ptrAudioDevice->RecordingDelay(delay) == -1) {
     LOG(LERROR) << "failed to retrieve the recording delay";
     return -1;
   }
 
   *delayMS = delay;
-
-  LOG(INFO) << __FUNCTION__ << " output: delayMS = " << *delayMS;
+  LOG(INFO) << "output: " << *delayMS;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  CPULoad
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::CPULoad(uint16_t* load) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
 
   uint16_t cpuLoad(0);
 
   if (_ptrAudioDevice->CPULoad(cpuLoad) == -1) {
     LOG(LERROR) << "failed to retrieve the CPU load";
     return -1;
   }
 
   *load = cpuLoad;
-
-  LOG(INFO) << __FUNCTION__ << " output: load = " << *load;
+  LOG(INFO) << "output: " << *load;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetRecordingSampleRate
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetRecordingSampleRate(
     const uint32_t samplesPerSec) {
   LOG(INFO) << __FUNCTION__ << "(" << samplesPerSec << ")";
@@ skipping 16 matching lines @@
   CHECK_INITIALIZED();
 
   int32_t sampleRate = _audioDeviceBuffer.RecordingSampleRate();
 
   if (sampleRate == -1) {
     LOG(LERROR) << "failed to retrieve the sample rate";
     return -1;
   }
 
   *samplesPerSec = sampleRate;
-
-  LOG(INFO) << __FUNCTION__ << " output: samplesPerSec = " << *samplesPerSec;
+  LOG(INFO) << "output: " << *samplesPerSec;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SetPlayoutSampleRate
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::SetPlayoutSampleRate(
     const uint32_t samplesPerSec) {
   LOG(INFO) << __FUNCTION__ << "(" << samplesPerSec << ")";
@@ skipping 16 matching lines @@
   CHECK_INITIALIZED();
 
   int32_t sampleRate = _audioDeviceBuffer.PlayoutSampleRate();
 
   if (sampleRate == -1) {
     LOG(LERROR) << "failed to retrieve the sample rate";
     return -1;
   }
 
   *samplesPerSec = sampleRate;
-
-  LOG(INFO) << __FUNCTION__ << " output: samplesPerSec = " << *samplesPerSec;
+  LOG(INFO) << "output: " << *samplesPerSec;
   return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  ResetAudioDevice
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::ResetAudioDevice() {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
@@ skipping 24 matching lines @@
 //  GetLoudspeakerStatus
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceModuleImpl::GetLoudspeakerStatus(bool* enabled) const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED();
   int32_t ok = 0;
   if (_ptrAudioDevice->GetLoudspeakerStatus(*enabled) != 0) {
     ok = -1;
   }
-  LOG(INFO) << __FUNCTION__ << " output: " << ok;
+  LOG(INFO) << "output: " << ok;
   return ok;
 }
 
 bool AudioDeviceModuleImpl::BuiltInAECIsEnabled() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   bool isEnabled = _ptrAudioDevice->BuiltInAECIsEnabled();
-  if (isEnabled) {
-    LOG(INFO) << __FUNCTION__ << " output: enabled";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not enabled";
-  }
+  LOG(INFO) << "output: " << isEnabled;
   return isEnabled;
 }
 
 bool AudioDeviceModuleImpl::BuiltInAECIsAvailable() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   bool isAvailable = _ptrAudioDevice->BuiltInAECIsAvailable();
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return isAvailable;
 }
 
 int32_t AudioDeviceModuleImpl::EnableBuiltInAEC(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
   int32_t ok = _ptrAudioDevice->EnableBuiltInAEC(enable);
-  LOG(INFO) << __FUNCTION__ << " output: " << ok;
+  LOG(INFO) << "output: " << ok;
   return ok;
 }
 
 bool AudioDeviceModuleImpl::BuiltInAGCIsAvailable() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   bool isAvailable = _ptrAudioDevice->BuiltInAGCIsAvailable();
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return isAvailable;
 }
 
 int32_t AudioDeviceModuleImpl::EnableBuiltInAGC(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
   int32_t ok = _ptrAudioDevice->EnableBuiltInAGC(enable);
-  LOG(INFO) << __FUNCTION__ << " output: " << ok;
+  LOG(INFO) << "output: " << ok;
   return ok;
 }
 
 bool AudioDeviceModuleImpl::BuiltInNSIsAvailable() const {
   LOG(INFO) << __FUNCTION__;
   CHECK_INITIALIZED_BOOL();
   bool isAvailable = _ptrAudioDevice->BuiltInNSIsAvailable();
-  if (isAvailable) {
-    LOG(INFO) << __FUNCTION__ << " output: available";
-  } else {
-    LOG(INFO) << __FUNCTION__ << " output: not available";
-  }
+  LOG(INFO) << "output: " << isAvailable;
   return isAvailable;
 }
 
 int32_t AudioDeviceModuleImpl::EnableBuiltInNS(bool enable) {
   LOG(INFO) << __FUNCTION__ << "(" << enable << ")";
   CHECK_INITIALIZED();
   int32_t ok = _ptrAudioDevice->EnableBuiltInNS(enable);
-  LOG(INFO) << __FUNCTION__ << " output: " << ok;
+  LOG(INFO) << "output: " << ok;
   return ok;
 }
 
 int AudioDeviceModuleImpl::GetPlayoutAudioParameters(
     AudioParameters* params) const {
   LOG(INFO) << __FUNCTION__;
   int r = _ptrAudioDevice->GetPlayoutAudioParameters(params);
-  LOG(INFO) << __FUNCTION__ << " output: " << r;
+  LOG(INFO) << "output: " << r;
   return r;
 }
 
 int AudioDeviceModuleImpl::GetRecordAudioParameters(
     AudioParameters* params) const {
   LOG(INFO) << __FUNCTION__;
   int r = _ptrAudioDevice->GetRecordAudioParameters(params);
-  LOG(INFO) << __FUNCTION__ << " output: " << r;
+  LOG(INFO) << "output: " << r;
   return r;
 }
 
 // ============================================================================
 //                                 Private Methods
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  Platform
 // ----------------------------------------------------------------------------
 
 AudioDeviceModuleImpl::PlatformType AudioDeviceModuleImpl::Platform() const {
   LOG(INFO) << __FUNCTION__;
   return _platformType;
 }
 
 // ----------------------------------------------------------------------------
 //  PlatformAudioLayer
 // ----------------------------------------------------------------------------
 
 AudioDeviceModule::AudioLayer AudioDeviceModuleImpl::PlatformAudioLayer()
     const {
   LOG(INFO) << __FUNCTION__;
   return _platformAudioLayer;
 }
 
 }  // namespace webrtc