Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/linux/audio_device_alsa_linux.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 42 matching lines @@
 static const unsigned int ALSA_PLAYOUT_LATENCY = 40*1000; // in us
 static const unsigned int ALSA_CAPTURE_FREQ = 48000;
 static const unsigned int ALSA_CAPTURE_CH = 2;
 static const unsigned int ALSA_CAPTURE_LATENCY = 40*1000; // in us
 static const unsigned int ALSA_CAPTURE_WAIT_TIMEOUT = 5; // in ms
 
 #define FUNC_GET_NUM_OF_DEVICE 0
 #define FUNC_GET_DEVICE_NAME 1
 #define FUNC_GET_DEVICE_NAME_FOR_AN_ENUM 2
 
-AudioDeviceLinuxALSA::AudioDeviceLinuxALSA(const int32_t id) :
-    _ptrAudioBuffer(NULL),
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
-    _id(id),
-    _mixerManager(id),
-    _inputDeviceIndex(0),
-    _outputDeviceIndex(0),
-    _inputDeviceIsSpecified(false),
-    _outputDeviceIsSpecified(false),
-    _handleRecord(NULL),
-    _handlePlayout(NULL),
-    _recordingBuffersizeInFrame(0),
-    _recordingPeriodSizeInFrame(0),
-    _playoutBufferSizeInFrame(0),
-    _playoutPeriodSizeInFrame(0),
-    _recordingBufferSizeIn10MS(0),
-    _playoutBufferSizeIn10MS(0),
-    _recordingFramesIn10MS(0),
-    _playoutFramesIn10MS(0),
-    _recordingFreq(ALSA_CAPTURE_FREQ),
-    _playoutFreq(ALSA_PLAYOUT_FREQ),
-    _recChannels(ALSA_CAPTURE_CH),
-    _playChannels(ALSA_PLAYOUT_CH),
-    _recordingBuffer(NULL),
-    _playoutBuffer(NULL),
-    _recordingFramesLeft(0),
-    _playoutFramesLeft(0),
-    _playBufType(AudioDeviceModule::kFixedBufferSize),
-    _initialized(false),
-    _recording(false),
-    _playing(false),
-    _recIsInitialized(false),
-    _playIsInitialized(false),
-    _AGC(false),
-    _recordingDelay(0),
-    _playoutDelay(0),
-    _playWarning(0),
-    _playError(0),
-    _recWarning(0),
-    _recError(0),
-    _playBufDelay(80),
-    _playBufDelayFixed(80)
-{
-    memset(_oldKeyState, 0, sizeof(_oldKeyState));
-    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id,
-                 "%s created", __FUNCTION__);
+AudioDeviceLinuxALSA::AudioDeviceLinuxALSA(const int32_t id)
+    : _ptrAudioBuffer(nullptr),
+      _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
+      _id(id),
+      _mixerManager(id),
+      _inputDeviceIndex(0),
+      _outputDeviceIndex(0),
+      _inputDeviceIsSpecified(false),
+      _outputDeviceIsSpecified(false),
+      _handleRecord(nullptr),
+      _handlePlayout(nullptr),
+      _recordingBuffersizeInFrame(0),
+      _recordingPeriodSizeInFrame(0),
+      _playoutBufferSizeInFrame(0),
+      _playoutPeriodSizeInFrame(0),
+      _recordingBufferSizeIn10MS(0),
+      _playoutBufferSizeIn10MS(0),
+      _recordingFramesIn10MS(0),
+      _playoutFramesIn10MS(0),
+      _recordingFreq(ALSA_CAPTURE_FREQ),
+      _playoutFreq(ALSA_PLAYOUT_FREQ),
+      _recChannels(ALSA_CAPTURE_CH),
+      _playChannels(ALSA_PLAYOUT_CH),
+      _recordingBuffer(nullptr),
+      _playoutBuffer(nullptr),
+      _recordingFramesLeft(0),
+      _playoutFramesLeft(0),
+      _playBufType(AudioDeviceModule::kFixedBufferSize),
+      _initialized(false),
+      _recording(false),
+      _playing(false),
+      _recIsInitialized(false),
+      _playIsInitialized(false),
+      _AGC(false),
+      _recordingDelay(0),
+      _playoutDelay(0),
+      _playWarning(0),
+      _playError(0),
+      _recWarning(0),
+      _recError(0),
+      _playBufDelay(80),
+      _playBufDelayFixed(80) {
+  memset(_oldKeyState, 0, sizeof(_oldKeyState));
+  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
 }
 
 // ----------------------------------------------------------------------------
 //  AudioDeviceLinuxALSA - dtor
 // ----------------------------------------------------------------------------
 
 AudioDeviceLinuxALSA::~AudioDeviceLinuxALSA()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id,
                  "%s destroyed", __FUNCTION__);
 
     Terminate();
 
     // Clean up the recording buffer and playout buffer.
     if (_recordingBuffer)
     {
         delete [] _recordingBuffer;
-        _recordingBuffer = NULL;
+        _recordingBuffer = nullptr;
     }
     if (_playoutBuffer)
     {
         delete [] _playoutBuffer;
-        _playoutBuffer = NULL;
+        _playoutBuffer = nullptr;
     }
     delete &_critSect;
 }
 
 void AudioDeviceLinuxALSA::AttachAudioBuffer(AudioDeviceBuffer* audioBuffer)
 {
 
     CriticalSectionScoped lock(&_critSect);
 
     _ptrAudioBuffer = audioBuffer;
@@ skipping 22 matching lines @@
     // Alsa is not installed on this system
     LOG(LS_ERROR) << "failed to load symbol table";
     return InitStatus::OTHER_ERROR;
   }
 
   if (_initialized) {
     return InitStatus::OK;
   }
 #if defined(USE_X11)
     //Get X display handle for typing detection
-    _XDisplay = XOpenDisplay(NULL);
-    if (!_XDisplay) {
-      LOG(LS_WARNING)
-          << "failed to open X display, typing detection will not work";
+  _XDisplay = XOpenDisplay(nullptr);
+  if (!_XDisplay) {
+    LOG(LS_WARNING)
+        << "failed to open X display, typing detection will not work";
     }
 #endif
     _playWarning = 0;
     _playError = 0;
     _recWarning = 0;
     _recError = 0;
 
     _initialized = true;
 
     return InitStatus::OK;
@@ skipping 30 matching lines @@
 
         tmpThread->Stop();
         delete tmpThread;
 
         _critSect.Enter();
     }
 #if defined(USE_X11)
     if (_XDisplay)
     {
       XCloseDisplay(_XDisplay);
-      _XDisplay = NULL;
+      _XDisplay = nullptr;
     }
 #endif
     _initialized = false;
     _outputDeviceIsSpecified = false;
     _inputDeviceIsSpecified = false;
 
     return 0;
 }
 
 bool AudioDeviceLinuxALSA::Initialized() const
@@ skipping 615 matching lines @@
 }
 
 int32_t AudioDeviceLinuxALSA::PlayoutDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize])
 {
 
     const uint16_t nDevices(PlayoutDevices());
 
-    if ((index > (nDevices-1)) || (name == NULL))
-    {
-        return -1;
+    if ((index > (nDevices - 1)) || (name == nullptr)) {
+      return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
-    if (guid != NULL)
-    {
-        memset(guid, 0, kAdmMaxGuidSize);
+    if (guid != nullptr) {
+      memset(guid, 0, kAdmMaxGuidSize);
     }
 
     return GetDevicesInfo(1, true, index, name, kAdmMaxDeviceNameSize);
 }
 
 int32_t AudioDeviceLinuxALSA::RecordingDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize])
 {
 
     const uint16_t nDevices(RecordingDevices());
 
-    if ((index > (nDevices-1)) || (name == NULL))
-    {
-        return -1;
+    if ((index > (nDevices - 1)) || (name == nullptr)) {
+      return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
-    if (guid != NULL)
-    {
-        memset(guid, 0, kAdmMaxGuidSize);
+    if (guid != nullptr) {
+      memset(guid, 0, kAdmMaxGuidSize);
     }
 
     return GetDevicesInfo(1, false, index, name, kAdmMaxDeviceNameSize);
 }
 
 int16_t AudioDeviceLinuxALSA::RecordingDevices()
 {
 
     return (int16_t)GetDevicesInfo(0, false);
 }
@@ skipping 119 matching lines @@
     }
     // Initialize the speaker (devices might have been added or removed)
     if (InitSpeaker() == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                      "  InitSpeaker() failed");
     }
 
     // Start by closing any existing wave-output devices
     //
-    if (_handlePlayout != NULL)
-    {
-        LATE(snd_pcm_close)(_handlePlayout);
-        _handlePlayout = NULL;
-        _playIsInitialized = false;
-        if (errVal < 0)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "  Error closing current playout sound device, error:"
-                         " %s", LATE(snd_strerror)(errVal));
-        }
+    if (_handlePlayout != nullptr) {
+      LATE(snd_pcm_close)(_handlePlayout);
+      _handlePlayout = nullptr;
+      _playIsInitialized = false;
+      if (errVal < 0) {
+        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                     "  Error closing current playout sound device, error:"
+                     " %s",
+                     LATE(snd_strerror)(errVal));
+      }
     }
 
     // Open PCM device for playout
     char deviceName[kAdmMaxDeviceNameSize] = {0};
     GetDevicesInfo(2, true, _outputDeviceIndex, deviceName,
                    kAdmMaxDeviceNameSize);
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "  InitPlayout open (%s)", deviceName);
 
@@ skipping 18 matching lines @@
                 break;
             }
         }
     }
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "     unable to open playback device: %s (%d)",
                      LATE(snd_strerror)(errVal),
                      errVal);
-        _handlePlayout = NULL;
+        _handlePlayout = nullptr;
         return -1;
     }
 
     _playoutFramesIn10MS = _playoutFreq/100;
     if ((errVal = LATE(snd_pcm_set_params)( _handlePlayout,
 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
         SND_PCM_FORMAT_S16_BE,
 #else
         SND_PCM_FORMAT_S16_LE, //format
 #endif
         SND_PCM_ACCESS_RW_INTERLEAVED, //access
         _playChannels, //channels
         _playoutFreq, //rate
         1, //soft_resample
         ALSA_PLAYOUT_LATENCY //40*1000 //latency required overall latency in us
     )) < 0)
     {   /* 0.5sec */
         _playoutFramesIn10MS = 0;
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "     unable to set playback device: %s (%d)",
                      LATE(snd_strerror)(errVal),
                      errVal);
         ErrorRecovery(errVal, _handlePlayout);
         errVal = LATE(snd_pcm_close)(_handlePlayout);
-        _handlePlayout = NULL;
+        _handlePlayout = nullptr;
         return -1;
     }
 
     errVal = LATE(snd_pcm_get_params)(_handlePlayout,
         &_playoutBufferSizeInFrame, &_playoutPeriodSizeInFrame);
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "    snd_pcm_get_params %s",
                      LATE(snd_strerror)(errVal),
@@ skipping 16 matching lines @@
     }
 
     // Set play buffer size
     _playoutBufferSizeIn10MS = LATE(snd_pcm_frames_to_bytes)(
         _handlePlayout, _playoutFramesIn10MS);
 
     // Init varaibles used for play
     _playWarning = 0;
     _playError = 0;
 
-    if (_handlePlayout != NULL)
-    {
-        _playIsInitialized = true;
-        return 0;
+    if (_handlePlayout != nullptr) {
+      _playIsInitialized = true;
+      return 0;
     }
     else
     {
         return -1;
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::InitRecording()
@@ skipping 20 matching lines @@
 
     // Initialize the microphone (devices might have been added or removed)
     if (InitMicrophone() == -1)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                    "  InitMicrophone() failed");
     }
 
     // Start by closing any existing pcm-input devices
     //
-    if (_handleRecord != NULL)
-    {
-        int errVal = LATE(snd_pcm_close)(_handleRecord);
-        _handleRecord = NULL;
-        _recIsInitialized = false;
-        if (errVal < 0)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                         "     Error closing current recording sound device,"
-                         " error: %s",
-                         LATE(snd_strerror)(errVal));
-        }
+    if (_handleRecord != nullptr) {
+      int errVal = LATE(snd_pcm_close)(_handleRecord);
+      _handleRecord = nullptr;
+      _recIsInitialized = false;
+      if (errVal < 0) {
+        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                     "     Error closing current recording sound device,"
+                     " error: %s",
+                     LATE(snd_strerror)(errVal));
+      }
     }
 
     // Open PCM device for recording
     // The corresponding settings for playout are made after the record settings
     char deviceName[kAdmMaxDeviceNameSize] = {0};
     GetDevicesInfo(2, false, _inputDeviceIndex, deviceName,
                    kAdmMaxDeviceNameSize);
 
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                  "InitRecording open (%s)", deviceName);
@@ skipping 18 matching lines @@
             {
                 break;
             }
         }
     }
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "    unable to open record device: %s",
                      LATE(snd_strerror)(errVal));
-        _handleRecord = NULL;
+        _handleRecord = nullptr;
         return -1;
     }
 
     _recordingFramesIn10MS = _recordingFreq/100;
     if ((errVal = LATE(snd_pcm_set_params)(_handleRecord,
 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
         SND_PCM_FORMAT_S16_BE, //format
 #else
         SND_PCM_FORMAT_S16_LE, //format
 #endif
@@ skipping 22 matching lines @@
              1, //soft_resample
              ALSA_CAPTURE_LATENCY //latency in us
          )) < 0)
          {
              _recordingFramesIn10MS = 0;
              WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                           "    unable to set record settings: %s (%d)",
                           LATE(snd_strerror)(errVal), errVal);
              ErrorRecovery(errVal, _handleRecord);
              errVal = LATE(snd_pcm_close)(_handleRecord);
-             _handleRecord = NULL;
+             _handleRecord = nullptr;
              return -1;
          }
     }
 
     errVal = LATE(snd_pcm_get_params)(_handleRecord,
         &_recordingBuffersizeInFrame, &_recordingPeriodSizeInFrame);
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "    snd_pcm_get_params %s",
@@ skipping 12 matching lines @@
     {
         // Update webrtc audio buffer with the selected parameters
         _ptrAudioBuffer->SetRecordingSampleRate(_recordingFreq);
         _ptrAudioBuffer->SetRecordingChannels(_recChannels);
     }
 
     // Set rec buffer size and create buffer
     _recordingBufferSizeIn10MS = LATE(snd_pcm_frames_to_bytes)(
         _handleRecord, _recordingFramesIn10MS);
 
-    if (_handleRecord != NULL)
-    {
-        // Mark recording side as initialized
-        _recIsInitialized = true;
-        return 0;
+    if (_handleRecord != nullptr) {
+      // Mark recording side as initialized
+      _recIsInitialized = true;
+      return 0;
     }
     else
     {
         return -1;
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::StartRecording()
@@ skipping 65 matching lines @@
 {
 
     {
       CriticalSectionScoped lock(&_critSect);
 
       if (!_recIsInitialized)
       {
           return 0;
       }
 
-      if (_handleRecord == NULL)
-      {
-          return -1;
+      if (_handleRecord == nullptr) {
+        return -1;
       }
 
       // Make sure we don't start recording (it's asynchronous).
       _recIsInitialized = false;
       _recording = false;
     }
 
     if (_ptrThreadRec)
     {
         _ptrThreadRec->Stop();
         _ptrThreadRec.reset();
     }
 
     CriticalSectionScoped lock(&_critSect);
     _recordingFramesLeft = 0;
     if (_recordingBuffer)
     {
         delete [] _recordingBuffer;
-        _recordingBuffer = NULL;
+        _recordingBuffer = nullptr;
     }
 
     // Stop and close pcm recording device.
     int errVal = LATE(snd_pcm_drop)(_handleRecord);
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "     Error stop recording: %s",
                      LATE(snd_strerror)(errVal));
         return -1;
     }
 
     errVal = LATE(snd_pcm_close)(_handleRecord);
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "     Error closing record sound device, error: %s",
                      LATE(snd_strerror)(errVal));
         return -1;
     }
 
     // Check if we have muted and unmute if so.
     bool muteEnabled = false;
     MicrophoneMute(muteEnabled);
     if (muteEnabled)
     {
         SetMicrophoneMute(false);
     }
 
-    // set the pcm input handle to NULL
-    _handleRecord = NULL;
+    // set the pcm input handle to null
+    _handleRecord = nullptr;
     return 0;
 }
 
 bool AudioDeviceLinuxALSA::RecordingIsInitialized() const
 {
     return (_recIsInitialized);
 }
 
 bool AudioDeviceLinuxALSA::Recording() const
 {
@@ skipping 53 matching lines @@
 {
 
     {
         CriticalSectionScoped lock(&_critSect);
 
         if (!_playIsInitialized)
         {
             return 0;
         }
 
-        if (_handlePlayout == NULL)
-        {
-            return -1;
+        if (_handlePlayout == nullptr) {
+          return -1;
         }
 
         _playing = false;
     }
 
     // stop playout thread first
     if (_ptrThreadPlay)
     {
         _ptrThreadPlay->Stop();
         _ptrThreadPlay.reset();
     }
 
     CriticalSectionScoped lock(&_critSect);
 
     _playoutFramesLeft = 0;
     delete [] _playoutBuffer;
-    _playoutBuffer = NULL;
+    _playoutBuffer = nullptr;
 
     // stop and close pcm playout device
     int errVal = LATE(snd_pcm_drop)(_handlePlayout);
     if (errVal < 0)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "    Error stop playing: %s",
                      LATE(snd_strerror)(errVal));
     }
 
     errVal = LATE(snd_pcm_close)(_handlePlayout);
      if (errVal < 0)
          WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                       "    Error closing playout sound device, error: %s",
                       LATE(snd_strerror)(errVal));
 
-     // set the pcm input handle to NULL
+     // set the pcm input handle to null
      _playIsInitialized = false;
-     _handlePlayout = NULL;
+     _handlePlayout = nullptr;
      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                  "  handle_playout is now set to NULL");
+                  "  handle_playout is now set to null");
 
      return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::PlayoutDelay(uint16_t& delayMS) const
 {
     delayMS = (uint16_t)_playoutDelay * 1000 / _playoutFreq;
     return 0;
 }
 
@@ skipping 150 matching lines @@
             if (err != 0)
             {
                 WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                              "GetDevicesInfo - device name free hint error: %s",
                              LATE(snd_strerror)(err));
             }
 
             return 0;
         }
 
-        for (void **list = hints; *list != NULL; ++list)
-        {
-            char *actualType = LATE(snd_device_name_get_hint)(*list, "IOID");
-            if (actualType)
-            {   // NULL means it's both.
-                bool wrongType = (strcmp(actualType, type) != 0);
-                free(actualType);
-                if (wrongType)
-                {
-                    // Wrong type of device (i.e., input vs. output).
-                    continue;
-                }
+        for (void** list = hints; *list != nullptr; ++list) {
+          char* actualType = LATE(snd_device_name_get_hint)(*list, "IOID");
+          if (actualType) {  // nullptr means it's both.
+            bool wrongType = (strcmp(actualType, type) != 0);
+            free(actualType);
+            if (wrongType) {
+              // Wrong type of device (i.e., input vs. output).
+              continue;
+            }
+          }
+
+          char* name = LATE(snd_device_name_get_hint)(*list, "NAME");
+          if (!name) {
+            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                         "Device has no name");
+            // Skip it.
+            continue;
+          }
+
+          // Now check if we actually want to show this device.
+          if (strcmp(name, "default") != 0 && strcmp(name, "null") != 0 &&
+              strcmp(name, "pulse") != 0 &&
+              strncmp(name, ignorePrefix, strlen(ignorePrefix)) != 0) {
+            // Yes, we do.
+            char* desc = LATE(snd_device_name_get_hint)(*list, "DESC");
+            if (!desc) {
+              // Virtual devices don't necessarily have descriptions.
+              // Use their names instead.
+              desc = name;
             }
 
-            char *name = LATE(snd_device_name_get_hint)(*list, "NAME");
-            if (!name)
-            {
-                WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                             "Device has no name");
-                // Skip it.
-                continue;
+            if (FUNC_GET_NUM_OF_DEVICE == function) {
+              WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                           "    Enum device %d - %s", enumCount, name);
+            }
+            if ((FUNC_GET_DEVICE_NAME == function) &&
+                (enumDeviceNo == enumCount)) {
+              // We have found the enum device, copy the name to buffer.
+              strncpy(enumDeviceName, desc, ednLen);
+              enumDeviceName[ednLen - 1] = '\0';
+              keepSearching = false;
+              // Replace '\n' with '-'.
+              char* pret = strchr(enumDeviceName, '\n' /*0xa*/);  // LF
+              if (pret)
+                *pret = '-';
+            }
+            if ((FUNC_GET_DEVICE_NAME_FOR_AN_ENUM == function) &&
+                (enumDeviceNo == enumCount)) {
+              // We have found the enum device, copy the name to buffer.
+              strncpy(enumDeviceName, name, ednLen);
+              enumDeviceName[ednLen - 1] = '\0';
+              keepSearching = false;
             }
 
-            // Now check if we actually want to show this device.
-            if (strcmp(name, "default") != 0 &&
-                strcmp(name, "null") != 0 &&
-                strcmp(name, "pulse") != 0 &&
-                strncmp(name, ignorePrefix, strlen(ignorePrefix)) != 0)
-            {
-                // Yes, we do.
-                char *desc = LATE(snd_device_name_get_hint)(*list, "DESC");
-                if (!desc)
-                {
-                    // Virtual devices don't necessarily have descriptions.
-                    // Use their names instead.
-                    desc = name;
-                }
+            if (keepSearching)
+              ++enumCount;
 
-                if (FUNC_GET_NUM_OF_DEVICE == function)
-                {
-                    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
-                                 "    Enum device %d - %s", enumCount, name);
+            if (desc != name)
+              free(desc);
+          }
 
-                }
-                if ((FUNC_GET_DEVICE_NAME == function) &&
-                    (enumDeviceNo == enumCount))
-                {
-                    // We have found the enum device, copy the name to buffer.
-                    strncpy(enumDeviceName, desc, ednLen);
-                    enumDeviceName[ednLen-1] = '\0';
-                    keepSearching = false;
-                    // Replace '\n' with '-'.
-                    char * pret = strchr(enumDeviceName, '\n'/*0xa*/); //LF
-                    if (pret)
-                        *pret = '-';
-                }
-                if ((FUNC_GET_DEVICE_NAME_FOR_AN_ENUM == function) &&
-                    (enumDeviceNo == enumCount))
-                {
-                    // We have found the enum device, copy the name to buffer.
-                    strncpy(enumDeviceName, name, ednLen);
-                    enumDeviceName[ednLen-1] = '\0';
-                    keepSearching = false;
-                }
+          free(name);
 
-                if (keepSearching)
-                    ++enumCount;
-
-                if (desc != name)
-                    free(desc);
-            }
-
-            free(name);
-
-            if (!keepSearching)
-                break;
+          if (!keepSearching)
+            break;
         }
 
         err = LATE(snd_device_name_free_hint)(hints);
         if (err != 0)
         {
             WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                          "GetDevicesInfo - device name free hint error: %s",
                          LATE(snd_strerror)(err));
             // Continue and return true anyway, since we did get the whole list.
         }
@@ skipping 13 matching lines @@
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
                      "GetDevicesInfo - Could not find device name or numbers");
         return -1;
     }
 
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::InputSanityCheckAfterUnlockedPeriod() const
 {
-    if (_handleRecord == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  input state has been modified during unlocked period");
-        return -1;
+  if (_handleRecord == nullptr) {
+    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                 "  input state has been modified during unlocked period");
+    return -1;
     }
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::OutputSanityCheckAfterUnlockedPeriod() const
 {
-    if (_handlePlayout == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
-                     "  output state has been modified during unlocked period");
-        return -1;
+  if (_handlePlayout == nullptr) {
+    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                 "  output state has been modified during unlocked period");
+    return -1;
     }
     return 0;
 }
 
 int32_t AudioDeviceLinuxALSA::ErrorRecovery(int32_t error,
                                             snd_pcm_t* deviceHandle)
 {
     int st = LATE(snd_pcm_state)(deviceHandle);
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                "Trying to recover from error: %s (%d) (state %d)",
@@ skipping 333 matching lines @@
     state |= (szKey[i] ^ _oldKeyState[i]) & szKey[i];
 
   // Save old state
   memcpy((char*)_oldKeyState, (char*)szKey, sizeof(_oldKeyState));
   return (state != 0);
 #else
   return false;
 #endif
 }
 }  // namespace webrtc