Remove ignored return code from modules.

webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_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 171 matching lines @@
     if(_timeScheduler.TimeToNextUpdate(timeUntilNextProcess) != 0) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "failed in TimeToNextUpdate() call");
         // Sanity check
         assert(false);
         return -1;
     }
     return timeUntilNextProcess;
 }
 
-int32_t AudioConferenceMixerImpl::Process() {
+void AudioConferenceMixerImpl::Process() {
     size_t remainingParticipantsAllowedToMix =
         kMaximumAmountOfMixedParticipants;
     {
         CriticalSectionScoped cs(_crit.get());
         assert(_processCalls == 0);
         _processCalls++;
 
         // Let the scheduler know that we are running one iteration.
         _timeScheduler.UpdateScheduler();
     }
@@ skipping 12 matching lines @@
         // TODO(henrike): this is probably more appropriate to do in
         //                GetLowestMixingFrequency().
         if (lowFreq == 12000) {
             lowFreq = 16000;
         } else if (lowFreq == 24000) {
             lowFreq = 32000;
         }
         if(lowFreq <= 0) {
             CriticalSectionScoped cs(_crit.get());
             _processCalls--;
-            return 0;
+            return;
         } else {
             switch(lowFreq) {
             case 8000:
                 if(OutputFrequency() != kNbInHz) {
                     SetOutputFrequency(kNbInHz);
                 }
                 break;
             case 16000:
                 if(OutputFrequency() != kWbInHz) {
                     SetOutputFrequency(kWbInHz);
                 }
                 break;
             case 32000:
                 if(OutputFrequency() != kSwbInHz) {
                     SetOutputFrequency(kSwbInHz);
                 }
                 break;
             case 48000:
                 if(OutputFrequency() != kFbInHz) {
                     SetOutputFrequency(kFbInHz);
                 }
                 break;
             default:
                 assert(false);
 
                 CriticalSectionScoped cs(_crit.get());
                 _processCalls--;
-                return -1;
+                return;
             }
         }
 
         UpdateToMix(&mixList, &rampOutList, &mixedParticipantsMap,
                     &remainingParticipantsAllowedToMix);
 
         GetAdditionalAudio(&additionalFramesList);
         UpdateMixedStatus(mixedParticipantsMap);
     }
 
     // Get an AudioFrame for mixing from the memory pool.
     AudioFrame* mixedAudio = NULL;
     if(_audioFramePool->PopMemory(mixedAudio) == -1) {
         WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                      "failed PopMemory() call");
         assert(false);
-        return -1;
+        return;
     }
 
-    int retval = 0;
     {
         CriticalSectionScoped cs(_crit.get());
 
         // TODO(henrike): it might be better to decide the number of channels
         //                with an API instead of dynamically.
 
         // Find the max channels over all mixing lists.
         const size_t num_mixed_channels = std::max(MaxNumChannels(&mixList),
             std::max(MaxNumChannels(&additionalFramesList),
                      MaxNumChannels(&rampOutList)));
@@ skipping 13 matching lines @@
         MixFromList(mixedAudio, mixList);
         MixAnonomouslyFromList(mixedAudio, additionalFramesList);
         MixAnonomouslyFromList(mixedAudio, rampOutList);
 
         if(mixedAudio->samples_per_channel_ == 0) {
             // Nothing was mixed, set the audio samples to silence.
             mixedAudio->samples_per_channel_ = _sampleSize;
             mixedAudio->Mute();
         } else {
             // Only call the limiter if we have something to mix.
-            if(!LimitMixedAudio(mixedAudio))
-                retval = -1;
+            LimitMixedAudio(mixedAudio);
         }
     }
 
     {
         CriticalSectionScoped cs(_cbCrit.get());
         if(_mixReceiver != NULL) {
             const AudioFrame** dummy = NULL;
             _mixReceiver->NewMixedAudio(
                 _id,
                 *mixedAudio,
                 dummy,
                 0);
         }
     }
 
     // Reclaim all outstanding memory.
     _audioFramePool->PushMemory(mixedAudio);
     ClearAudioFrameList(&mixList);
     ClearAudioFrameList(&rampOutList);
     ClearAudioFrameList(&additionalFramesList);
     {
         CriticalSectionScoped cs(_crit.get());
         _processCalls--;
     }
-    return retval;
+    return;
 }
 
 int32_t AudioConferenceMixerImpl::RegisterMixedStreamCallback(
     AudioMixerOutputReceiver* mixReceiver) {
     CriticalSectionScoped cs(_cbCrit.get());
     if(_mixReceiver != NULL) {
         return -1;
     }
     _mixReceiver = mixReceiver;
     return 0;
@@ skipping 562 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc