Wire up x-google-{min,start,max}-bitrate to WebRtcVoiceMediaChannel.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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 1598 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendParameters: "
                << params.ToString();
   // TODO(pthatcher): Refactor this to be more clean now that we have
   // all the information at once.
 
   if (!SetSendCodecs(params.codecs)) {
     return false;
   }
 
+  if (params.max_bandwidth_bps >= 0) {
+    // Note that max_bandwidth_bps intentionally takes priority over the
+    // bitrate config for the codec.
+    bitrate_config_.max_bitrate_bps =
+        params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps;
+  }
+  call_->SetBitrateConfig(bitrate_config_);

[minyue-webrtc, 2016/11/30 14:25:25]

can we determine bitrate_config in one util function, assuming
SetCallBitrateConfig, we can repeat some lines like

const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(...)

but it may be easier to maintain.

[stefan-webrtc, 2016/11/30 14:52:23]

I don't know. It's probably doable, but it doesn't seem unreasonable to me that
we get the BitrateConfig inside SetSendCodec if a new codec is actually
determined.

Here we use the already stored BitrateConfig and update it if necessary, so it
shouldn't be responsible for figuring out if the codec has changed.

+
   if (!ValidateRtpExtensions(params.extensions)) {
     return false;
   }
   std::vector<webrtc::RtpExtension> filtered_extensions =
       FilterRtpExtensions(params.extensions,
                           webrtc::RtpExtension::IsSupportedForAudio, true);
   if (send_rtp_extensions_ != filtered_extensions) {
     send_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : send_streams_) {
       it.second->RecreateAudioSendStream(send_rtp_extensions_);
@@ skipping 285 matching lines @@
     // Find send codec (the first non-telephone-event/CN codec).
     const AudioCodec* codec = WebRtcVoiceCodecs::GetPreferredCodec(
         codecs, &send_codec_spec.codec_inst);
     if (!codec) {
       LOG(LS_WARNING) << "Received empty list of codecs.";
       return false;
     }
 
     send_codec_spec.transport_cc_enabled = HasTransportCc(*codec);
     send_codec_spec.nack_enabled = HasNack(*codec);
+    bitrate_config_ = GetBitrateConfigForCodec(*codec);
 
     // For Opus as the send codec, we are to determine inband FEC, maximum
     // playback rate, and opus internal dtx.
     if (IsCodec(*codec, kOpusCodecName)) {
       GetOpusConfig(*codec, &send_codec_spec.codec_inst,
                     &send_codec_spec.enable_codec_fec,
                     &send_codec_spec.opus_max_playback_rate,
                     &send_codec_spec.enable_opus_dtx,
                     &send_codec_spec.min_ptime_ms,
                     &send_codec_spec.max_ptime_ms);
@@ skipping 46 matching lines @@
     // Find the telephone-event PT exactly matching the preferred send codec.
     for (const AudioCodec& dtmf_codec : dtmf_codecs) {
       if (dtmf_codec.clockrate == codec->clockrate) {
         dtmf_payload_type_ = rtc::Optional<int>(dtmf_codec.id);
         dtmf_payload_freq_ = dtmf_codec.clockrate;
         break;
       }
     }
   }
 
-  // Apply new settings to all streams.
   if (send_codec_spec_ != send_codec_spec) {
     send_codec_spec_ = std::move(send_codec_spec);
+    // Apply new settings to all streams.
     for (const auto& kv : send_streams_) {
       kv.second->RecreateAudioSendStream(send_codec_spec_);
     }
+  } else {
+    // If the codec isn't changing, set the start bitrate to -1 which means
+    // "unchanged" so that BWE isn't affected.
+    bitrate_config_.start_bitrate_bps = -1;
   }

[the sun, 2016/11/30 13:55:51]

If you move call_->SetBitrateConfig() here instead, do you even need to store
the config in WVoMC?

[stefan-webrtc, 2016/11/30 14:15:30]

It isn't that simple, since params.max_bandwidth_bps should override this, see
line 1622. Maybe if I have SetSendCodec() return a bitrate config that I can use
there? WDYT?

 
   // Check if the transport cc feedback or NACK status has changed on the
   // preferred send codec, and in that case reconfigure all receive streams.
   if (recv_transport_cc_enabled_ != send_codec_spec_.transport_cc_enabled ||
       recv_nack_enabled_ != send_codec_spec_.nack_enabled) {
     LOG(LS_INFO) << "Recreate all the receive streams because the send "
                     "codec has changed.";
     recv_transport_cc_enabled_ = send_codec_spec_.transport_cc_enabled;
     recv_nack_enabled_ = send_codec_spec_.nack_enabled;
     for (auto& kv : recv_streams_) {
@@ skipping 631 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = send_streams_.find(ssrc);
   if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE