Use C++11 loops in WebRtcVoiceMediaEngine/Channel.

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 196 matching lines @@
         kCodecPrefs[i].clockrate == codec.plfreq) {
       return kCodecPrefs[i].is_multi_rate;
     }
   }
   return false;
 }
 
 static bool FindCodec(const std::vector<AudioCodec>& codecs,
                       const AudioCodec& codec,
                       AudioCodec* found_codec) {
-  for (std::vector<AudioCodec>::const_iterator it = codecs.begin();
-       it != codecs.end(); ++it) {
-    if (it->Matches(codec)) {
+  for (const AudioCodec& c : codecs) {
+    if (c.Matches(codec)) {
       if (found_codec != NULL) {
-        *found_codec = *it;
+        *found_codec = c;
       }
       return true;
     }
   }
   return false;
 }
 
 static bool IsNackEnabled(const AudioCodec& codec) {
   return codec.HasFeedbackParam(FeedbackParam(kRtcpFbParamNack,
                                               kParamValueEmpty));
@@ skipping 317 matching lines @@
 
   // Set defaults for options, so that ApplyOptions applies them explicitly
   // when we clear option (channel) overrides. External clients can still
   // modify the defaults via SetOptions (on the media engine).
   if (!SetOptions(GetDefaultEngineOptions())) {
     return false;
   }
 
   // Print our codec list again for the call diagnostic log
   LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
-  for (std::vector<AudioCodec>::const_iterator it = codecs_.begin();
-      it != codecs_.end(); ++it) {
-    LOG(LS_INFO) << ToString(*it);
+  for (const AudioCodec& codec : codecs_) {
+    LOG(LS_INFO) << ToString(codec);
   }
 
   // Disable the DTMF playout when a tone is sent.
   // PlayDtmfTone will be used if local playout is needed.
   if (voe_wrapper_->dtmf()->SetDtmfFeedbackStatus(false) == -1) {
     LOG_RTCERR1(SetDtmfFeedbackStatus, false);
   }
 
   initialized_ = true;
   return true;
@@ skipping 369 matching lines @@
             << ")";
 
   // If we're running the local monitor, we need to stop it first.
   bool ret = true;
   if (!PauseLocalMonitor()) {
     LOG(LS_WARNING) << "Failed to pause local monitor";
     ret = false;
   }
 
   // Must also pause all audio playback and capture.
-  for (ChannelList::const_iterator i = channels_.begin();
-       i != channels_.end(); ++i) {
-    WebRtcVoiceMediaChannel *channel = *i;
+  for (WebRtcVoiceMediaChannel* channel : channels_) {
     if (!channel->PausePlayout()) {
       LOG(LS_WARNING) << "Failed to pause playout";
       ret = false;
     }
     if (!channel->PauseSend()) {
       LOG(LS_WARNING) << "Failed to pause send";
       ret = false;
     }
   }
 
@@ skipping 17 matching lines @@
     ret = false;
   }
   if (ret) {
     if (voe_wrapper_->hw()->SetPlayoutDevice(out_id) == -1) {
       LOG_RTCERR2(SetPlayoutDevice, out_name, out_id);
       ret = false;
     }
   }
 
   // Resume all audio playback and capture.
-  for (ChannelList::const_iterator i = channels_.begin();
-       i != channels_.end(); ++i) {
-    WebRtcVoiceMediaChannel *channel = *i;
+  for (WebRtcVoiceMediaChannel* channel : channels_) {
     if (!channel->ResumePlayout()) {
       LOG(LS_WARNING) << "Failed to resume playout";
       ret = false;
     }
     if (!channel->ResumeSend()) {
       LOG(LS_WARNING) << "Failed to resume send";
       ret = false;
     }
   }
 
@@ skipping 317 matching lines @@
   }
 }
 
 bool WebRtcVoiceEngine::FindChannelAndSsrc(
     int channel_num, WebRtcVoiceMediaChannel** channel, uint32* ssrc) const {
   DCHECK(channel != NULL && ssrc != NULL);
 
   *channel = NULL;
   *ssrc = 0;
   // Find corresponding channel and ssrc
-  for (ChannelList::const_iterator it = channels_.begin();
-      it != channels_.end(); ++it) {
-    DCHECK(*it != NULL);
-    if ((*it)->FindSsrc(channel_num, ssrc)) {
-      *channel = *it;
+  for (WebRtcVoiceMediaChannel* ch : channels_) {
+    DCHECK(ch != NULL);
+    if (ch->FindSsrc(channel_num, ssrc)) {
+      *channel = ch;
       return true;
     }
   }
 
   return false;
 }
 
 // This method will search through the WebRtcVoiceMediaChannels and
 // obtain the voice engine's channel number.
 bool WebRtcVoiceEngine::FindChannelNumFromSsrc(
     uint32 ssrc, MediaProcessorDirection direction, int* channel_num) {
   DCHECK(channel_num != NULL);
   DCHECK(direction == MPD_RX || direction == MPD_TX);
 
   *channel_num = -1;
   // Find corresponding channel for ssrc.
-  for (ChannelList::const_iterator it = channels_.begin();
-      it != channels_.end(); ++it) {
-    DCHECK(*it != NULL);
+  for (const WebRtcVoiceMediaChannel* ch : channels_) {
+    DCHECK(ch != NULL);
     if (direction & MPD_RX) {
-      *channel_num = (*it)->GetReceiveChannelNum(ssrc);
+      *channel_num = ch->GetReceiveChannelNum(ssrc);
     }
     if (*channel_num == -1 && (direction & MPD_TX)) {
-      *channel_num = (*it)->GetSendChannelNum(ssrc);
+      *channel_num = ch->GetSendChannelNum(ssrc);
     }
     if (*channel_num != -1) {
       return true;
     }
   }
   LOG(LS_WARNING) << "FindChannelFromSsrc. No Channel Found for Ssrc: " << ssrc;
   return false;
 }
 
 void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel *channel) {
@@ skipping 483 matching lines @@
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecs(
     const std::vector<AudioCodec>& codecs) {
   // Set the payload types to be used for incoming media.
   LOG(LS_INFO) << "Setting receive voice codecs:";
 
   std::vector<AudioCodec> new_codecs;
   // Find all new codecs. We allow adding new codecs but don't allow changing
   // the payload type of codecs that is already configured since we might
   // already be receiving packets with that payload type.
-  for (std::vector<AudioCodec>::const_iterator it = codecs.begin();
-       it != codecs.end(); ++it) {
+  for (const AudioCodec& codec : codecs) {
     AudioCodec old_codec;
-    if (FindCodec(recv_codecs_, *it, &old_codec)) {
-      if (old_codec.id != it->id) {
-        LOG(LS_ERROR) << it->name << " payload type changed.";
+    if (FindCodec(recv_codecs_, codec, &old_codec)) {
+      if (old_codec.id != codec.id) {
+        LOG(LS_ERROR) << codec.name << " payload type changed.";
         return false;
       }
     } else {
-      new_codecs.push_back(*it);
+      new_codecs.push_back(codec);
     }
   }
   if (new_codecs.empty()) {
     // There are no new codecs to configure. Already configured codecs are
     // never removed.
     return true;
   }
 
   if (playout_) {
     // Receive codecs can not be changed while playing. So we temporarily
     // pause playout.
     PausePlayout();
   }
 
-  bool ret = true;
-  for (std::vector<AudioCodec>::const_iterator it = new_codecs.begin();
-       it != new_codecs.end() && ret; ++it) {
-    webrtc::CodecInst voe_codec;
-    if (engine()->FindWebRtcCodec(*it, &voe_codec)) {
-      LOG(LS_INFO) << ToString(*it);
-      voe_codec.pltype = it->id;
-      if (default_receive_ssrc_ == 0) {
-        // Set the receive codecs on the default channel explicitly if the
-        // default channel is not used by |receive_channels_|, this happens in
-        // conference mode or in non-conference mode when there is no playout
-        // channel.
-        // TODO(xians): Figure out how we use the default channel in conference
-        // mode.
-        if (engine()->voe()->codec()->SetRecPayloadType(
-            voe_channel(), voe_codec) == -1) {
-          LOG_RTCERR2(SetRecPayloadType, voe_channel(), ToString(voe_codec));
-          ret = false;
-        }
-      }
-
-      // Set the receive codecs on all receiving channels.
-      for (ChannelMap::iterator it = receive_channels_.begin();
-           it != receive_channels_.end() && ret; ++it) {
-        if (engine()->voe()->codec()->SetRecPayloadType(
-                it->second->channel(), voe_codec) == -1) {
-          LOG_RTCERR2(SetRecPayloadType, it->second->channel(),
-                      ToString(voe_codec));
-          ret = false;
-        }
-      }
-    } else {
-      LOG(LS_WARNING) << "Unknown codec " << ToString(*it);
-      ret = false;
-    }
-  }
-  if (ret) {
+  bool result = SetRecvCodecsInternal(new_codecs);
+  if (result) {
     recv_codecs_ = codecs;
   }
 
   if (desired_playout_ && !playout_) {
     ResumePlayout();
   }
-  return ret;
+  return result;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
     int channel, const std::vector<AudioCodec>& codecs) {
   // Disable VAD, FEC, and RED unless we know the other side wants them.
   engine()->voe()->codec()->SetVADStatus(channel, false);
   engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   engine()->voe()->rtp()->SetREDStatus(channel, false);
   engine()->voe()->codec()->SetFECStatus(channel, false);
 
   // Scan through the list to figure out the codec to use for sending, along
   // with the proper configuration for VAD and DTMF.
   bool found_send_codec = false;
   webrtc::CodecInst send_codec;
   memset(&send_codec, 0, sizeof(send_codec));
 
   bool nack_enabled = nack_enabled_;
   bool enable_codec_fec = false;
   bool enable_opus_dtx = false;
   int opus_max_playback_rate = 0;
 
   // Set send codec (the first non-telephone-event/CN codec)
-  for (std::vector<AudioCodec>::const_iterator it = codecs.begin();
-       it != codecs.end(); ++it) {
+  for (const AudioCodec& codec : codecs) {
     // Ignore codecs we don't know about. The negotiation step should prevent
     // this, but double-check to be sure.
     webrtc::CodecInst voe_codec;
-    if (!engine()->FindWebRtcCodec(*it, &voe_codec)) {
-      LOG(LS_WARNING) << "Unknown codec " << ToString(*it);
+    if (!engine()->FindWebRtcCodec(codec, &voe_codec)) {
+      LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       continue;
     }
 
-    if (IsCodec(*it, kDtmfCodecName) || IsCodec(*it, kCnCodecName)) {
+    if (IsCodec(codec, kDtmfCodecName) || IsCodec(codec, kCnCodecName)) {
       // Skip telephone-event/CN codec, which will be handled later.
       continue;
     }
 
     // We'll use the first codec in the list to actually send audio data.
     // Be sure to use the payload type requested by the remote side.
     // "red", for RED audio, is a special case where the actual codec to be
     // used is specified in params.
-    if (IsCodec(*it, kRedCodecName)) {
+    if (IsCodec(codec, kRedCodecName)) {
       // Parse out the RED parameters. If we fail, just ignore RED;
       // we don't support all possible params/usage scenarios.
-      if (!GetRedSendCodec(*it, codecs, &send_codec)) {
+      if (!GetRedSendCodec(codec, codecs, &send_codec)) {
         continue;
       }
 
       // Enable redundant encoding of the specified codec. Treat any
       // failure as a fatal internal error.
       LOG(LS_INFO) << "Enabling RED on channel " << channel;
-      if (engine()->voe()->rtp()->SetREDStatus(channel, true, it->id) == -1) {
-        LOG_RTCERR3(SetREDStatus, channel, true, it->id);
+      if (engine()->voe()->rtp()->SetREDStatus(channel, true, codec.id) == -1) {
+        LOG_RTCERR3(SetREDStatus, channel, true, codec.id);
         return false;
       }
     } else {
       send_codec = voe_codec;
-      nack_enabled = IsNackEnabled(*it);
+      nack_enabled = IsNackEnabled(codec);
       // For Opus as the send codec, we are to determine inband FEC, maximum
       // playback rate, and opus internal dtx.
-      if (IsCodec(*it, kOpusCodecName)) {
-        GetOpusConfig(*it, &send_codec, &enable_codec_fec,
+      if (IsCodec(codec, kOpusCodecName)) {
+        GetOpusConfig(codec, &send_codec, &enable_codec_fec,
                       &opus_max_playback_rate, &enable_opus_dtx);
       }
 
       // Set packet size if the AudioCodec param kCodecParamPTime is set.
       int ptime_ms = 0;
-      if (it->GetParam(kCodecParamPTime, &ptime_ms)) {
+      if (codec.GetParam(kCodecParamPTime, &ptime_ms)) {
         if (!SetPTimeAsPacketSize(&send_codec, ptime_ms)) {
           LOG(LS_WARNING) << "Failed to set packet size for codec "
                           << send_codec.plname;
           return false;
         }
       }
     }
     found_send_codec = true;
     break;
   }
@@ skipping 54 matching lines @@
   }
 
   // Always update the |send_codec_| to the currently set send codec.
   send_codec_.reset(new webrtc::CodecInst(send_codec));
 
   if (send_bitrate_setting_) {
     SetSendBitrateInternal(send_bitrate_bps_);
   }
 
   // Loop through the codecs list again to config the telephone-event/CN codec.
-  for (std::vector<AudioCodec>::const_iterator it = codecs.begin();
-       it != codecs.end(); ++it) {
+  for (const AudioCodec& codec : codecs) {
     // Ignore codecs we don't know about. The negotiation step should prevent
     // this, but double-check to be sure.
     webrtc::CodecInst voe_codec;
-    if (!engine()->FindWebRtcCodec(*it, &voe_codec)) {
-      LOG(LS_WARNING) << "Unknown codec " << ToString(*it);
+    if (!engine()->FindWebRtcCodec(codec, &voe_codec)) {
+      LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       continue;
     }
 
     // Find the DTMF telephone event "codec" and tell VoiceEngine channels
     // about it.
-    if (IsCodec(*it, kDtmfCodecName)) {
+    if (IsCodec(codec, kDtmfCodecName)) {
       if (engine()->voe()->dtmf()->SetSendTelephoneEventPayloadType(
-              channel, it->id) == -1) {
-        LOG_RTCERR2(SetSendTelephoneEventPayloadType, channel, it->id);
+              channel, codec.id) == -1) {
+        LOG_RTCERR2(SetSendTelephoneEventPayloadType, channel, codec.id);
         return false;
       }
-    } else if (IsCodec(*it, kCnCodecName)) {
+    } else if (IsCodec(codec, kCnCodecName)) {
       // Turn voice activity detection/comfort noise on if supported.
       // Set the wideband CN payload type appropriately.
       // (narrowband always uses the static payload type 13).
       webrtc::PayloadFrequencies cn_freq;
-      switch (it->clockrate) {
+      switch (codec.clockrate) {
         case 8000:
           cn_freq = webrtc::kFreq8000Hz;
           break;
         case 16000:
           cn_freq = webrtc::kFreq16000Hz;
           break;
         case 32000:
           cn_freq = webrtc::kFreq32000Hz;
           break;
         default:
-          LOG(LS_WARNING) << "CN frequency " << it->clockrate
+          LOG(LS_WARNING) << "CN frequency " << codec.clockrate
                           << " not supported.";
           continue;
       }
       // Set the CN payloadtype and the VAD status.
       // The CN payload type for 8000 Hz clockrate is fixed at 13.
       if (cn_freq != webrtc::kFreq8000Hz) {
         if (engine()->voe()->codec()->SetSendCNPayloadType(
-                channel, it->id, cn_freq) == -1) {
-          LOG_RTCERR3(SetSendCNPayloadType, channel, it->id, cn_freq);
+                channel, codec.id, cn_freq) == -1) {
+          LOG_RTCERR3(SetSendCNPayloadType, channel, codec.id, cn_freq);
           // TODO(ajm): This failure condition will be removed from VoE.
           // Restore the return here when we update to a new enough webrtc.
           //
           // Not returning false because the SetSendCNPayloadType will fail if
           // the channel is already sending.
           // This can happen if the remote description is applied twice, for
           // example in the case of ROAP on top of JSEP, where both side will
           // send the offer.
         }
       }
       // Only turn on VAD if we have a CN payload type that matches the
       // clockrate for the codec we are going to use.
-      if (it->clockrate == send_codec.plfreq && send_codec.channels != 2) {
+      if (codec.clockrate == send_codec.plfreq && send_codec.channels != 2) {
         // TODO(minyue): If CN frequency == 48000 Hz is allowed, consider the
         // interaction between VAD and Opus FEC.
         LOG(LS_INFO) << "Enabling VAD";
         if (engine()->voe()->codec()->SetVADStatus(channel, true) == -1) {
           LOG_RTCERR2(SetVADStatus, channel, true);
           return false;
         }
       }
     }
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
     const std::vector<AudioCodec>& codecs) {
   dtmf_allowed_ = false;
-  for (std::vector<AudioCodec>::const_iterator it = codecs.begin();
-       it != codecs.end(); ++it) {
+  for (const AudioCodec& codec : codecs) {
     // Find the DTMF telephone event "codec".
-    if (IsCodec(*it, kDtmfCodecName)) {
+    if (IsCodec(codec, kDtmfCodecName)) {
       dtmf_allowed_ = true;
     }
   }
 
   // Cache the codecs in order to configure the channel created later.
   send_codecs_ = codecs;
-  for (ChannelMap::iterator iter = send_channels_.begin();
-       iter != send_channels_.end(); ++iter) {
-    if (!SetSendCodecs(iter->second->channel(), codecs)) {
+  for (const auto& ch : send_channels_) {
+    if (!SetSendCodecs(ch.second->channel(), codecs)) {
       return false;
     }
   }
 
   // Set nack status on receive channels and update |nack_enabled_|.
   SetNack(receive_channels_, nack_enabled_);
   return true;
 }
 
 void WebRtcVoiceMediaChannel::SetNack(const ChannelMap& channels,
                                       bool nack_enabled) {
-  for (ChannelMap::const_iterator it = channels.begin();
-       it != channels.end(); ++it) {
-    SetNack(it->second->channel(), nack_enabled);
+  for (const auto& ch : channels) {
+    SetNack(ch.second->channel(), nack_enabled);
   }
 }
 
 void WebRtcVoiceMediaChannel::SetNack(int channel, bool nack_enabled) {
   if (nack_enabled) {
     LOG(LS_INFO) << "Enabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, true, kNackMaxPackets);
   } else {
     LOG(LS_INFO) << "Disabling NACK for channel " << channel;
     engine()->voe()->rtp()->SetNACKStatus(channel, false, 0);
   }
 }
 
 bool WebRtcVoiceMediaChannel::SetSendCodec(
     const webrtc::CodecInst& send_codec) {
   LOG(LS_INFO) << "Selected voice codec " << ToString(send_codec)
                << ", bitrate=" << send_codec.rate;
-  for (ChannelMap::iterator iter = send_channels_.begin();
-       iter != send_channels_.end(); ++iter) {
-    if (!SetSendCodec(iter->second->channel(), send_codec))
+  for (const auto& ch : send_channels_) {
+    if (!SetSendCodec(ch.second->channel(), send_codec))
       return false;
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetSendCodec(
     int channel, const webrtc::CodecInst& send_codec) {
   LOG(LS_INFO) << "Send channel " << channel <<  " selected voice codec "
                << ToString(send_codec) << ", bitrate=" << send_codec.rate;
@@ skipping 18 matching lines @@
     return true;
   }
 
   // The default channel may or may not be in |receive_channels_|. Set the rtp
   // header extensions for default channel regardless.
   if (!SetChannelRecvRtpHeaderExtensions(voe_channel(), extensions)) {
     return false;
   }
 
   // Loop through all receive channels and enable/disable the extensions.
-  for (ChannelMap::const_iterator channel_it = receive_channels_.begin();
-       channel_it != receive_channels_.end(); ++channel_it) {
-    if (!SetChannelRecvRtpHeaderExtensions(channel_it->second->channel(),
-                                           extensions)) {
+  for (const auto& ch : receive_channels_) {
+    if (!SetChannelRecvRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
   receive_extensions_ = extensions;
 
   // Recreate AudioReceiveStream:s.
   {
     std::vector<webrtc::RtpExtension> exts;
 
@@ skipping 46 matching lines @@
   }
 
   // The default channel may or may not be in |send_channels_|. Set the rtp
   // header extensions for default channel regardless.
 
   if (!SetChannelSendRtpHeaderExtensions(voe_channel(), extensions)) {
     return false;
   }
 
   // Loop through all send channels and enable/disable the extensions.
-  for (ChannelMap::const_iterator channel_it = send_channels_.begin();
-       channel_it != send_channels_.end(); ++channel_it) {
-    if (!SetChannelSendRtpHeaderExtensions(channel_it->second->channel(),
-                                           extensions)) {
+  for (const auto& ch : send_channels_) {
+    if (!SetChannelSendRtpHeaderExtensions(ch.second->channel(), extensions)) {
       return false;
     }
   }
 
   send_extensions_ = extensions;
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetChannelSendRtpHeaderExtensions(
     int channel_id, const std::vector<RtpHeaderExtension>& extensions) {
@@ skipping 34 matching lines @@
   if (playout_ == playout) {
     return true;
   }
 
   // Change the playout of all channels to the new state.
   bool result = true;
   if (receive_channels_.empty()) {
     // Only toggle the default channel if we don't have any other channels.
     result = SetPlayout(voe_channel(), playout);
   }
-  for (ChannelMap::iterator it = receive_channels_.begin();
-       it != receive_channels_.end() && result; ++it) {
-    if (!SetPlayout(it->second->channel(), playout)) {
+  for (const auto& ch : receive_channels_) {
+    if (!SetPlayout(ch.second->channel(), playout)) {
       LOG(LS_ERROR) << "SetPlayout " << playout << " on channel "
-                    << it->second->channel() << " failed";
+                    << ch.second->channel() << " failed";
       result = false;
+      break;
     }
   }
 
   if (result) {
     playout_ = playout;
   }
   return result;
 }
 
 bool WebRtcVoiceMediaChannel::SetSend(SendFlags send) {
@@ skipping 14 matching lines @@
 bool WebRtcVoiceMediaChannel::ChangeSend(SendFlags send) {
   if (send_ == send) {
     return true;
   }
 
   // Change the settings on each send channel.
   if (send == SEND_MICROPHONE)
     engine()->SetOptionOverrides(options_);
 
   // Change the settings on each send channel.
-  for (ChannelMap::iterator iter = send_channels_.begin();
-       iter != send_channels_.end(); ++iter) {
-    if (!ChangeSend(iter->second->channel(), send))
+  for (const auto& ch : send_channels_) {
+    if (!ChangeSend(ch.second->channel(), send))
       return false;
   }
 
   // Clear up the options after stopping sending.
   if (send == SEND_NOTHING)
     engine()->ClearOptionOverrides();
 
   send_ = send;
   return true;
 }
@@ skipping 53 matching lines @@
 bool WebRtcVoiceMediaChannel::AddSendStream(const StreamParams& sp) {
   // If the default channel is already used for sending create a new channel
   // otherwise use the default channel for sending.
   int channel = GetSendChannelNum(sp.first_ssrc());
   if (channel != -1) {
     LOG(LS_ERROR) << "Stream already exists with ssrc " << sp.first_ssrc();
     return false;
   }
 
   bool default_channel_is_available = true;
-  for (ChannelMap::const_iterator iter = send_channels_.begin();
-       iter != send_channels_.end(); ++iter) {
-    if (IsDefaultChannel(iter->second->channel())) {
+  for (const auto& ch : send_channels_) {
+    if (IsDefaultChannel(ch.second->channel())) {
       default_channel_is_available = false;
       break;
     }
   }
   if (default_channel_is_available) {
     channel = voe_channel();
   } else {
     // Create a new channel for sending audio data.
     channel = engine()->CreateMediaVoiceChannel();
     if (channel == -1) {
@@ skipping 19 matching lines @@
   if (engine()->voe()->rtp()->SetLocalSSRC(channel, sp.first_ssrc()) == -1) {
     LOG_RTCERR2(SetSendSSRC, channel, sp.first_ssrc());
     return false;
   }
 
   // At this point the channel's local SSRC has been updated. If the channel is
   // the default channel make sure that all the receive channels are updated as
   // well. Receive channels have to have the same SSRC as the default channel in
   // order to send receiver reports with this SSRC.
   if (IsDefaultChannel(channel)) {
-    for (ChannelMap::const_iterator it = receive_channels_.begin();
-         it != receive_channels_.end(); ++it) {
+    for (const auto& ch : receive_channels_) {
       // Only update the SSRC for non-default channels.
-      if (!IsDefaultChannel(it->second->channel())) {
-        if (engine()->voe()->rtp()->SetLocalSSRC(it->second->channel(),
+      if (!IsDefaultChannel(ch.second->channel())) {
+        if (engine()->voe()->rtp()->SetLocalSSRC(ch.second->channel(),
                                                  sp.first_ssrc()) != 0) {
-          LOG_RTCERR2(SetLocalSSRC, it->second->channel(), sp.first_ssrc());
+          LOG_RTCERR2(SetLocalSSRC, ch.second->channel(), sp.first_ssrc());
           return false;
         }
       }
     }
   }
 
   if (engine()->voe()->rtp()->SetRTCP_CNAME(channel, sp.cname.c_str()) == -1) {
     LOG_RTCERR2(SetRTCP_CNAME, channel, sp.cname);
     return false;
   }
@@ skipping 121 matching lines @@
   // Associate receive channel to default channel (so the receive channel can
   // obtain RTT from the send channel)
   engine()->voe()->base()->AssociateSendChannel(channel, voe_channel());
   LOG(LS_INFO) << "VoiceEngine channel #"
                << channel << " is associated with channel #"
                << voe_channel() << ".";
 
   // Use the same recv payload types as our default channel.
   ResetRecvCodecs(channel);
   if (!recv_codecs_.empty()) {
-    for (std::vector<AudioCodec>::const_iterator it = recv_codecs_.begin();
-        it != recv_codecs_.end(); ++it) {
+    for (const auto& codec : recv_codecs_) {
       webrtc::CodecInst voe_codec;
-      if (engine()->FindWebRtcCodec(*it, &voe_codec)) {
-        voe_codec.pltype = it->id;
+      if (engine()->FindWebRtcCodec(codec, &voe_codec)) {
+        voe_codec.pltype = codec.id;
         voe_codec.rate = 0;  // Needed to make GetRecPayloadType work for ISAC
         if (engine()->voe()->codec()->GetRecPayloadType(
             voe_channel(), voe_codec) != -1) {
           if (engine()->voe()->codec()->SetRecPayloadType(
               channel, voe_codec) == -1) {
             LOG_RTCERR2(SetRecPayloadType, channel, ToString(voe_codec));
             return false;
           }
         }
       }
@@ skipping 124 matching lines @@
     it->second->Stop();
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::GetActiveStreams(
     AudioInfo::StreamList* actives) {
   // In conference mode, the default channel should not be in
   // |receive_channels_|.
   actives->clear();
-  for (ChannelMap::iterator it = receive_channels_.begin();
-       it != receive_channels_.end(); ++it) {
-    int level = GetOutputLevel(it->second->channel());
+  for (const auto& ch : receive_channels_) {
+    int level = GetOutputLevel(ch.second->channel());
     if (level > 0) {
-      actives->push_back(std::make_pair(it->first, level));
+      actives->push_back(std::make_pair(ch.first, level));
     }
   }
   return true;
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel() {
   // return the highest output level of all streams
   int highest = GetOutputLevel(voe_channel());
-  for (ChannelMap::iterator it = receive_channels_.begin();
-       it != receive_channels_.end(); ++it) {
-    int level = GetOutputLevel(it->second->channel());
+  for (const auto& ch : receive_channels_) {
+    int level = GetOutputLevel(ch.second->channel());
     highest = std::max(level, highest);
   }
   return highest;
 }
 
 int WebRtcVoiceMediaChannel::GetTimeSinceLastTyping() {
   int ret;
   if (engine()->voe()->processing()->TimeSinceLastTyping(ret) == -1) {
     // In case of error, log the info and continue
     LOG_RTCERR0(TimeSinceLastTyping);
@@ skipping 20 matching lines @@
 bool WebRtcVoiceMediaChannel::SetOutputScaling(
     uint32 ssrc, double left, double right) {
   rtc::CritScope lock(&receive_channels_cs_);
   // Collect the channels to scale the output volume.
   std::vector<int> channels;
   if (0 == ssrc) {  // Collect all channels, including the default one.
     // Default channel is not in receive_channels_ if it is not being used for
     // playout.
     if (default_receive_ssrc_ == 0)
       channels.push_back(voe_channel());
-    for (ChannelMap::const_iterator it = receive_channels_.begin();
-         it != receive_channels_.end(); ++it) {
-      channels.push_back(it->second->channel());
+    for (const auto& ch : receive_channels_) {
+      channels.push_back(ch.second->channel());
     }
   } else {  // Collect only the channel of the specified ssrc.
     int channel = GetReceiveChannelNum(ssrc);
     if (-1 == channel) {
       LOG(LS_WARNING) << "Cannot find channel for ssrc:" << ssrc;
       return false;
     }
     channels.push_back(channel);
   }
 
   // Scale the output volume for the collected channels. We first normalize to
   // scale the volume and then set the left and right pan.
   float scale = static_cast<float>(std::max(left, right));
   if (scale > 0.0001f) {
     left /= scale;
     right /= scale;
   }
-  for (std::vector<int>::const_iterator it = channels.begin();
-      it != channels.end(); ++it) {
+  for (int ch_id : channels) {
     if (-1 == engine()->voe()->volume()->SetChannelOutputVolumeScaling(
-        *it, scale)) {
-      LOG_RTCERR2(SetChannelOutputVolumeScaling, *it, scale);
+        ch_id, scale)) {
+      LOG_RTCERR2(SetChannelOutputVolumeScaling, ch_id, scale);
       return false;
     }
     if (-1 == engine()->voe()->volume()->SetOutputVolumePan(
-        *it, static_cast<float>(left), static_cast<float>(right))) {
-      LOG_RTCERR3(SetOutputVolumePan, *it, left, right);
+        ch_id, static_cast<float>(left), static_cast<float>(right))) {
+      LOG_RTCERR3(SetOutputVolumePan, ch_id, left, right);
       // Do not return if fails. SetOutputVolumePan is not available for all
       // pltforms.
     }
     LOG(LS_INFO) << "SetOutputScaling to left=" << left * scale
                  << " right=" << right * scale
-                 << " for channel " << *it << " and ssrc " << ssrc;
+                 << " for channel " << ch_id << " and ssrc " << ssrc;
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::GetOutputScaling(
     uint32 ssrc, double* left, double* right) {
   if (!left || !right) return false;
 
   rtc::CritScope lock(&receive_channels_cs_);
   // Determine which channel based on ssrc.
@@ skipping 80 matching lines @@
                                          int duration, int flags) {
   if (!dtmf_allowed_) {
     return false;
   }
 
   // Send the event.
   if (flags & cricket::DF_SEND) {
     int channel = -1;
     if (ssrc == 0) {
       bool default_channel_is_inuse = false;
-      for (ChannelMap::const_iterator iter = send_channels_.begin();
-           iter != send_channels_.end(); ++iter) {
-        if (IsDefaultChannel(iter->second->channel())) {
+      for (const auto& ch : send_channels_) {
+        if (IsDefaultChannel(ch.second->channel())) {
           default_channel_is_inuse = true;
           break;
         }
       }
       if (default_channel_is_inuse) {
         channel = voe_channel();
       } else if (!send_channels_.empty()) {
         channel = send_channels_.begin()->second->channel();
       }
     } else {
@@ skipping 95 matching lines @@
           which_channel, packet->data(), packet->size());
 
       if (IsDefaultChannel(which_channel))
         has_sent_to_default_channel = true;
     }
   }
 
   // SR may continue RR and any RR entry may correspond to any one of the send
   // channels. So all RTCP packets must be forwarded all send channels. VoE
   // will filter out RR internally.
-  for (ChannelMap::iterator iter = send_channels_.begin();
-       iter != send_channels_.end(); ++iter) {
+  for (const auto& ch : send_channels_) {
     // Make sure not sending the same packet to default channel more than once.
-    if (IsDefaultChannel(iter->second->channel()) &&
+    if (IsDefaultChannel(ch.second->channel()) &&
         has_sent_to_default_channel)
       continue;
 
     engine()->voe()->network()->ReceivedRTCPPacket(
-        iter->second->channel(), packet->data(), packet->size());
+        ch.second->channel(), packet->data(), packet->size());
   }
 }
 
 bool WebRtcVoiceMediaChannel::MuteStream(uint32 ssrc, bool muted) {
   int channel = (ssrc == 0) ? voe_channel() : GetSendChannelNum(ssrc);
   if (channel == -1) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
   }
   if (engine()->voe()->volume()->SetInputMute(channel, muted) == -1) {
     LOG_RTCERR2(SetInputMute, channel, muted);
     return false;
   }
   // We set the AGC to mute state only when all the channels are muted.
   // This implementation is not ideal, instead we should signal the AGC when
   // the mic channel is muted/unmuted. We can't do it today because there
   // is no good way to know which stream is mapping to the mic channel.
   bool all_muted = muted;
-  for (ChannelMap::const_iterator iter = send_channels_.begin();
-       iter != send_channels_.end() && all_muted; ++iter) {
-    if (engine()->voe()->volume()->GetInputMute(iter->second->channel(),
+  for (const auto& ch : send_channels_) {
+    if (!all_muted) {
+      break;
+    }
+    if (engine()->voe()->volume()->GetInputMute(ch.second->channel(),
                                                 all_muted)) {
-      LOG_RTCERR1(GetInputMute, iter->second->channel());
+      LOG_RTCERR1(GetInputMute, ch.second->channel());
       return false;
     }
   }
 
   webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
   if (ap)
     ap->set_output_will_be_muted(all_muted);
   return true;
 }
 
@@ skipping 78 matching lines @@
       echo_delay_median_ms = median;
       echo_delay_std_ms = std;
     }
   }
 
   webrtc::CallStatistics cs;
   unsigned int ssrc;
   webrtc::CodecInst codec;
   unsigned int level;
 
-  for (ChannelMap::const_iterator channel_iter = send_channels_.begin();
-       channel_iter != send_channels_.end(); ++channel_iter) {
-    const int channel = channel_iter->second->channel();
+  for (const auto& ch : send_channels_) {
+    const int channel = ch.second->channel();
 
     // Fill in the sender info, based on what we know, and what the
     // remote side told us it got from its RTCP report.
     VoiceSenderInfo sinfo;
 
     if (engine()->voe()->rtp()->GetRTCPStatistics(channel, cs) == -1 ||
         engine()->voe()->rtp()->GetLocalSSRC(channel, ssrc) == -1) {
       continue;
     }
 
     sinfo.add_ssrc(ssrc);
     sinfo.codec_name = send_codec_.get() ? send_codec_->plname : "";
     sinfo.bytes_sent = cs.bytesSent;
     sinfo.packets_sent = cs.packetsSent;
     // RTT isn't known until a RTCP report is received. Until then, VoiceEngine
     // returns 0 to indicate an error value.
     sinfo.rtt_ms = (cs.rttMs > 0) ? cs.rttMs : -1;
 
     // Get data from the last remote RTCP report. Use default values if no data
     // available.
     sinfo.fraction_lost = -1.0;
     sinfo.jitter_ms = -1;
     sinfo.packets_lost = -1;
     sinfo.ext_seqnum = -1;
     std::vector<webrtc::ReportBlock> receive_blocks;
     if (engine()->voe()->rtp()->GetRemoteRTCPReportBlocks(
             channel, &receive_blocks) != -1 &&
         engine()->voe()->codec()->GetSendCodec(channel, codec) != -1) {
-      std::vector<webrtc::ReportBlock>::iterator iter;
-      for (iter = receive_blocks.begin(); iter != receive_blocks.end();
-           ++iter) {
+      for (const webrtc::ReportBlock& block : receive_blocks) {
         // Lookup report for send ssrc only.
-        if (iter->source_SSRC == sinfo.ssrc()) {
+        if (block.source_SSRC == sinfo.ssrc()) {
           // Convert Q8 to floating point.
-          sinfo.fraction_lost = static_cast<float>(iter->fraction_lost) / 256;
+          sinfo.fraction_lost = static_cast<float>(block.fraction_lost) / 256;
           // Convert samples to milliseconds.
           if (codec.plfreq / 1000 > 0) {
-            sinfo.jitter_ms = iter->interarrival_jitter / (codec.plfreq / 1000);
+            sinfo.jitter_ms = block.interarrival_jitter / (codec.plfreq / 1000);
           }
-          sinfo.packets_lost = iter->cumulative_num_packets_lost;
-          sinfo.ext_seqnum = iter->extended_highest_sequence_number;
+          sinfo.packets_lost = block.cumulative_num_packets_lost;
+          sinfo.ext_seqnum = block.extended_highest_sequence_number;
           break;
         }
       }
     }
 
     // Local speech level.
     sinfo.audio_level = (engine()->voe()->volume()->
         GetSpeechInputLevelFullRange(level) != -1) ? level : -1;
 
     // TODO(xians): We are injecting the same APM logging to all the send
     // channels here because there is no good way to know which send channel
     // is using the APM. The correct fix is to allow the send channels to have
     // their own APM so that we can feed the correct APM logging to different
     // send channels. See issue crbug/264611 .
     sinfo.echo_return_loss = echo_return_loss;
     sinfo.echo_return_loss_enhancement = echo_return_loss_enhancement;
     sinfo.echo_delay_median_ms = echo_delay_median_ms;
     sinfo.echo_delay_std_ms = echo_delay_std_ms;
     // TODO(ajm): Re-enable this metric once we have a reliable implementation.
     sinfo.aec_quality_min = -1;
     sinfo.typing_noise_detected = typing_noise_detected_;
 
     info->senders.push_back(sinfo);
   }
 
   // Build the list of receivers, one for each receiving channel, or 1 in
   // a 1:1 call.
   std::vector<int> channels;
-  for (ChannelMap::const_iterator it = receive_channels_.begin();
-       it != receive_channels_.end(); ++it) {
-    channels.push_back(it->second->channel());
+  for (const auto& ch : receive_channels_) {
+    channels.push_back(ch.second->channel());
   }
   if (channels.empty()) {
     channels.push_back(voe_channel());
   }
 
   // Get the SSRC and stats for each receiver, based on our own calculations.
-  for (std::vector<int>::const_iterator it = channels.begin();
-       it != channels.end(); ++it) {
+  for (int ch_id : channels) {
     memset(&cs, 0, sizeof(cs));
-    if (engine()->voe()->rtp()->GetRemoteSSRC(*it, ssrc) != -1 &&
-        engine()->voe()->rtp()->GetRTCPStatistics(*it, cs) != -1 &&
-        engine()->voe()->codec()->GetRecCodec(*it, codec) != -1) {
+    if (engine()->voe()->rtp()->GetRemoteSSRC(ch_id, ssrc) != -1 &&
+        engine()->voe()->rtp()->GetRTCPStatistics(ch_id, cs) != -1 &&
+        engine()->voe()->codec()->GetRecCodec(ch_id, codec) != -1) {
       VoiceReceiverInfo rinfo;
       rinfo.add_ssrc(ssrc);
       rinfo.bytes_rcvd = cs.bytesReceived;
       rinfo.packets_rcvd = cs.packetsReceived;
       // The next four fields are from the most recently sent RTCP report.
       // Convert Q8 to floating point.
       rinfo.fraction_lost = static_cast<float>(cs.fractionLost) / (1 << 8);
       rinfo.packets_lost = cs.cumulativeLost;
       rinfo.ext_seqnum = cs.extendedMax;
       rinfo.capture_start_ntp_time_ms = cs.capture_start_ntp_time_ms_;
       if (codec.pltype != -1) {
         rinfo.codec_name = codec.plname;
       }
       // Convert samples to milliseconds.
       if (codec.plfreq / 1000 > 0) {
         rinfo.jitter_ms = cs.jitterSamples / (codec.plfreq / 1000);
       }
 
       // Get jitter buffer and total delay (alg + jitter + playout) stats.
       webrtc::NetworkStatistics ns;
       if (engine()->voe()->neteq() &&
           engine()->voe()->neteq()->GetNetworkStatistics(
-              *it, ns) != -1) {
+              ch_id, ns) != -1) {
         rinfo.jitter_buffer_ms = ns.currentBufferSize;
         rinfo.jitter_buffer_preferred_ms = ns.preferredBufferSize;
         rinfo.expand_rate =
             static_cast<float>(ns.currentExpandRate) / (1 << 14);
         rinfo.speech_expand_rate =
             static_cast<float>(ns.currentSpeechExpandRate) / (1 << 14);
         rinfo.secondary_decoded_rate =
             static_cast<float>(ns.currentSecondaryDecodedRate) / (1 << 14);
         rinfo.accelerate_rate =
             static_cast<float>(ns.currentAccelerateRate) / (1 << 14);
         rinfo.preemptive_expand_rate =
             static_cast<float>(ns.currentPreemptiveRate) / (1 << 14);
       }
 
       webrtc::AudioDecodingCallStats ds;
       if (engine()->voe()->neteq() &&
           engine()->voe()->neteq()->GetDecodingCallStatistics(
-              *it, &ds) != -1) {
+              ch_id, &ds) != -1) {
         rinfo.decoding_calls_to_silence_generator =
             ds.calls_to_silence_generator;
         rinfo.decoding_calls_to_neteq = ds.calls_to_neteq;
         rinfo.decoding_normal = ds.decoded_normal;
         rinfo.decoding_plc = ds.decoded_plc;
         rinfo.decoding_cng = ds.decoded_cng;
         rinfo.decoding_plc_cng = ds.decoded_plc_cng;
       }
 
       if (engine()->voe()->sync()) {
         int jitter_buffer_delay_ms = 0;
         int playout_buffer_delay_ms = 0;
         engine()->voe()->sync()->GetDelayEstimate(
-            *it, &jitter_buffer_delay_ms, &playout_buffer_delay_ms);
+            ch_id, &jitter_buffer_delay_ms, &playout_buffer_delay_ms);
         rinfo.delay_estimate_ms = jitter_buffer_delay_ms +
             playout_buffer_delay_ms;
       }
 
       // Get speech level.
       rinfo.audio_level = (engine()->voe()->volume()->
-          GetSpeechOutputLevelFullRange(*it, level) != -1) ? level : -1;
+          GetSpeechOutputLevelFullRange(ch_id, level) != -1) ? level : -1;
       info->receivers.push_back(rinfo);
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::GetLastMediaError(
     uint32* ssrc, VoiceMediaChannel::Error* error) {
   DCHECK(ssrc != NULL);
   DCHECK(error != NULL);
   FindSsrc(voe_channel(), ssrc);
   *error = WebRtcErrorToChannelError(GetLastEngineError());
 }
 
 bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
   rtc::CritScope lock(&receive_channels_cs_);
   DCHECK(ssrc != NULL);
   if (channel_num == -1 && send_ != SEND_NOTHING) {
     // Sometimes the VoiceEngine core will throw error with channel_num = -1.
     // This means the error is not limited to a specific channel.  Signal the
     // message using ssrc=0.  If the current channel is sending, use this
     // channel for sending the message.
     *ssrc = 0;
     return true;
   } else {
     // Check whether this is a sending channel.
-    for (ChannelMap::const_iterator it = send_channels_.begin();
-         it != send_channels_.end(); ++it) {
-      if (it->second->channel() == channel_num) {
+    for (const auto& ch : send_channels_) {
+      if (ch.second->channel() == channel_num) {
         // This is a sending channel.
         uint32 local_ssrc = 0;
         if (engine()->voe()->rtp()->GetLocalSSRC(
                 channel_num, local_ssrc) != -1) {
           *ssrc = local_ssrc;
         }
         return true;
       }
     }
 
     // Check whether this is a receiving channel.
-    for (ChannelMap::const_iterator it = receive_channels_.begin();
-        it != receive_channels_.end(); ++it) {
-      if (it->second->channel() == channel_num) {
-        *ssrc = it->first;
+    for (const auto& ch : receive_channels_) {
+      if (ch.second->channel() == channel_num) {
+        *ssrc = ch.first;
         return true;
       }
     }
   }
   return false;
 }
 
 void WebRtcVoiceMediaChannel::OnError(uint32 ssrc, int error) {
   if (error == VE_TYPING_NOISE_WARNING) {
     typing_noise_detected_ = true;
   } else if (error == VE_TYPING_NOISE_OFF_WARNING) {
     typing_noise_detected_ = false;
   }
   SignalMediaError(ssrc, WebRtcErrorToChannelError(error));
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel;
   int ret =
       engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
-int WebRtcVoiceMediaChannel::GetReceiveChannelNum(uint32 ssrc) {
-  ChannelMap::iterator it = receive_channels_.find(ssrc);
+int WebRtcVoiceMediaChannel::GetReceiveChannelNum(uint32 ssrc) const {
+  ChannelMap::const_iterator it = receive_channels_.find(ssrc);
   if (it != receive_channels_.end())
     return it->second->channel();
   return (ssrc == default_receive_ssrc_) ? voe_channel() : -1;
 }
 
-int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32 ssrc) {
-  ChannelMap::iterator it = send_channels_.find(ssrc);
+int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32 ssrc) const {
+  ChannelMap::const_iterator it = send_channels_.find(ssrc);
   if (it != send_channels_.end())
     return it->second->channel();
 
   return -1;
 }
 
 void WebRtcVoiceMediaChannel::SetCall(webrtc::Call* call) {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (const auto& it : receive_channels_) {
     TryRemoveAudioRecvStream(it.first);
@@ skipping 26 matching lines @@
       return false;
     }
   } else if (red_codec.params.empty()) {
     LOG(LS_WARNING) << "RED params not present, using defaults";
     if (all_codecs.size() > 1) {
       red_pt = all_codecs[1].id;
     }
   }
 
   // Try to find red_pt in |codecs|.
-  std::vector<AudioCodec>::const_iterator codec;
-  for (codec = all_codecs.begin(); codec != all_codecs.end(); ++codec) {
-    if (codec->id == red_pt)
-      break;
+  for (const AudioCodec& codec : all_codecs) {
+    if (codec.id == red_pt) {
+      // If we find the right codec, that will be the codec we pass to
+      // SetSendCodec, with the desired payload type.
+      if (engine()->FindWebRtcCodec(codec, send_codec)) {
+        return true;
+      } else {
+        break;
+      }
+    }
   }
-
-  // If we find the right codec, that will be the codec we pass to
-  // SetSendCodec, with the desired payload type.
-  if (codec != all_codecs.end() &&
-    engine()->FindWebRtcCodec(*codec, send_codec)) {
-  } else {
-    LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
-    return false;
-  }
-
-  return true;
+  LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
+  return false;
 }
 
 bool WebRtcVoiceMediaChannel::EnableRtcp(int channel) {
   if (engine()->voe()->rtp()->SetRTCPStatus(channel, true) == -1) {
     LOG_RTCERR2(SetRTCPStatus, channel, 1);
     return false;
   }
   // TODO(juberti): Enable VQMon and RTCP XR reports, once we know what
   // what we want to do with them.
   // engine()->voe().EnableVQMon(voe_channel(), true);
@@ skipping 118 matching lines @@
   // AudioReceiveStream to destroy too.
   if (call_) {
     auto stream_it = receive_streams_.find(ssrc);
     if (stream_it != receive_streams_.end()) {
       call_->DestroyAudioReceiveStream(stream_it->second);
       receive_streams_.erase(stream_it);
     }
   }
 }
 
+bool WebRtcVoiceMediaChannel::SetRecvCodecsInternal(
+    const std::vector<AudioCodec>& new_codecs) {
+  for (const AudioCodec& codec : new_codecs) {
+    webrtc::CodecInst voe_codec;
+    if (engine()->FindWebRtcCodec(codec, &voe_codec)) {
+      LOG(LS_INFO) << ToString(codec);
+      voe_codec.pltype = codec.id;
+      if (default_receive_ssrc_ == 0) {
+        // Set the receive codecs on the default channel explicitly if the
+        // default channel is not used by |receive_channels_|, this happens in
+        // conference mode or in non-conference mode when there is no playout
+        // channel.
+        // TODO(xians): Figure out how we use the default channel in conference
+        // mode.
+        if (engine()->voe()->codec()->SetRecPayloadType(
+            voe_channel(), voe_codec) == -1) {
+          LOG_RTCERR2(SetRecPayloadType, voe_channel(), ToString(voe_codec));
+          return false;
+        }
+      }
+
+      // Set the receive codecs on all receiving channels.
+      for (const auto& ch : receive_channels_) {
+        if (engine()->voe()->codec()->SetRecPayloadType(
+                ch.second->channel(), voe_codec) == -1) {
+          LOG_RTCERR2(SetRecPayloadType, ch.second->channel(),
+                      ToString(voe_codec));
+          return false;
+        }
+      }
+    } else {
+      LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
+      return false;
+    }
+  }
+  return true;
+}
+
 int WebRtcSoundclipStream::Read(void *buf, size_t len) {
   size_t res = 0;
   mem_.Read(buf, len, &res, NULL);
   return static_cast<int>(res);
 }
 
 int WebRtcSoundclipStream::Rewind() {
   mem_.Rewind();
   // Return -1 to keep VoiceEngine from looping.
   return (loop_) ? 0 : -1;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE