Reset the BWE when the network changes

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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 70 matching lines @@
 
   DeliveryStatus DeliverPacket(MediaType media_type,
                                const uint8_t* packet,
                                size_t length,
                                const PacketTime& packet_time) override;
 
   void SetBitrateConfig(
       const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
   void SignalNetworkState(NetworkState state) override;
 
+  void OnNetworkChanged(int local_net_id, int remote_net_id) override;
+
   void OnSentPacket(const rtc::SentPacket& sent_packet) override;
 
   // Implements BitrateObserver.
   void OnNetworkChanged(uint32_t bitrate_bps, uint8_t fraction_loss,
                         int64_t rtt_ms) override;
 
  private:
   DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
                              size_t length);
   DeliveryStatus DeliverRtp(MediaType media_type,
                             const uint8_t* packet,
                             size_t length,
                             const PacketTime& packet_time);
-
+  void ResetBweBitrates();
   void ConfigureSync(const std::string& sync_group)
       EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
 
   VoiceEngine* voice_engine() {
     internal::AudioState* audio_state =
         static_cast<internal::AudioState*>(config_.audio_state.get());
     if (audio_state)
       return audio_state->voice_engine();
     else
       return nullptr;
@@ skipping 45 matching lines @@
   int64_t last_rtp_packet_received_ms_;
   int64_t first_packet_sent_ms_;
 
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
   int64_t estimated_send_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
   int64_t pacer_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
   int64_t num_bitrate_updates_ GUARDED_BY(&bitrate_crit_);
 
+  int local_network_id_ = 0;
+  int remote_network_id_ = 0;

[pthatcher1, 2016/03/16 21:22:03]

If the signal has both old and new route infos, we don't have to store these.

[honghaiz3, 2016/03/17 03:38:27]

Keep this as we have discussed.

+
   VieRemb remb_;
   const std::unique_ptr<CongestionController> congestion_controller_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
 
 Call* Call::Create(const Call::Config& config) {
   return new internal::Call(config);
 }
@@ skipping 383 matching lines @@
     }
   }
   {
     ReadLockScoped write_lock(*receive_crit_);
     for (auto& kv : video_receive_ssrcs_) {
       kv.second->SignalNetworkState(state);
     }
   }
 }
 
+void Call::OnNetworkChanged(int local_net_id, int remote_net_id) {
+  RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
+  // Reset the BWE estimate when network changes.
+  // Check if the network has actually changed.
+  if (local_net_id == local_network_id_ &&
+      remote_net_id == remote_network_id_) {

[pthatcher1, 2016/03/16 21:22:03]

If we use NetworkRoute structs, we should also check if they are connected or
not.

[honghaiz3, 2016/03/17 03:38:27]

We can now use the null pointer for best connection being deleted.

+    return;
+  }
+  LOG(LS_INFO) << "Network changed: new local network id " << local_net_id
+               << " new remote network id " << remote_net_id;
+  local_network_id_ = local_net_id;
+  remote_network_id_ = remote_net_id;
+  ResetBweBitrates();
+}
+
+void Call::ResetBweBitrates() {

[pthatcher1, 2016/03/16 21:22:03]

If !new_route.connected, we probably want to do something more drastic with the
BWE.  I'm not sure what, though, so perhaps just a TODO for now.

[honghaiz3, 2016/03/17 03:38:27]

Done. Add TODO.

+  LOG(LS_INFO) << "Reset BWE estimate to "
+               << config_.bitrate_config.start_bitrate_bps << "bps";
+  congestion_controller_->SetBweBitrates(
+      config_.bitrate_config.min_bitrate_bps,
+      config_.bitrate_config.start_bitrate_bps,
+      config_.bitrate_config.max_bitrate_bps);

[pthatcher1, 2016/03/16 21:22:03]

Does this really restart the BWE?  

[honghaiz3, 2016/03/17 03:38:27]

Actually It may not. Maybe we can leave this to BWE experts. 

+}
+
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
   if (first_packet_sent_ms_ == -1)
     first_packet_sent_ms_ = clock_->TimeInMilliseconds();
   congestion_controller_->OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
                             int64_t rtt_ms) {
   uint32_t allocated_bitrate_bps = bitrate_allocator_->OnNetworkChanged(
       target_bitrate_bps, fraction_loss, rtt_ms);
@@ skipping 162 matching lines @@
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
   if (RtpHeaderParser::IsRtcp(packet, length))
     return DeliverRtcp(media_type, packet, length);
 
   return DeliverRtp(media_type, packet, length, packet_time);
 }
 
 }  // namespace internal
 }  // namespace webrtc