Remove ViEEncoder::SetNetworkStatus

webrtc/modules/congestion_controller/congestion_controller.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 133 matching lines @@
       packet_router_(new PacketRouter()),
       pacer_(new PacedSender(clock_,
                              packet_router_.get(),
                              BitrateController::kDefaultStartBitratebps)),
       remote_bitrate_estimator_(
           new WrappingBitrateEstimator(remote_bitrate_observer, clock_)),
       bitrate_controller_(BitrateController::CreateBitrateController(clock_)),
       remote_estimator_proxy_(clock_, packet_router_.get()),
       transport_feedback_adapter_(bitrate_controller_.get(), clock_),
       min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps),
-      send_queue_is_full_(false) {
+      send_queue_is_full_(false),
+      network_state_(kNetworkUp),
+      network_state_changed_(false) {
   Init();
 }
 
 CongestionController::CongestionController(
     Clock* clock,
     Observer* observer,
     RemoteBitrateObserver* remote_bitrate_observer,
     std::unique_ptr<PacketRouter> packet_router,
     std::unique_ptr<PacedSender> pacer)
     : clock_(clock),
       observer_(observer),
       packet_router_(std::move(packet_router)),
       pacer_(std::move(pacer)),
       remote_bitrate_estimator_(
           new WrappingBitrateEstimator(remote_bitrate_observer, clock_)),
       // Constructed last as this object calls the provided callback on
       // construction.
       bitrate_controller_(BitrateController::CreateBitrateController(clock_)),
       remote_estimator_proxy_(clock_, packet_router_.get()),
       transport_feedback_adapter_(bitrate_controller_.get(), clock_),
       min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps),
-      send_queue_is_full_(false) {
+      send_queue_is_full_(false),
+      network_state_(kNetworkUp),
+      network_state_changed_(false) {
   Init();
 }
 
 CongestionController::~CongestionController() {}
 
 void CongestionController::Init() {
   transport_feedback_adapter_.SetBitrateEstimator(
       new RemoteBitrateEstimatorAbsSendTime(&transport_feedback_adapter_));
   transport_feedback_adapter_.GetBitrateEstimator()->SetMinBitrate(
       min_bitrate_bps_);
@@ skipping 57 matching lines @@
 int64_t CongestionController::GetPacerQueuingDelayMs() const {
   return pacer_->QueueInMs();
 }
 
 void CongestionController::SignalNetworkState(NetworkState state) {
   if (state == kNetworkUp) {
     pacer_->Resume();
   } else {
     pacer_->Pause();
   }
+  rtc::CritScope cs(&critsect_);
+  network_state_ = state;
+  network_state_changed_ = true;
 }
 
 void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) {
   transport_feedback_adapter_.OnSentPacket(sent_packet.packet_id,
                                             sent_packet.send_time_ms);
 }
 
 void CongestionController::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
   remote_bitrate_estimator_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
   transport_feedback_adapter_.OnRttUpdate(avg_rtt_ms, max_rtt_ms);
 }
 
 int64_t CongestionController::TimeUntilNextProcess() {
   return std::min(bitrate_controller_->TimeUntilNextProcess(),
                   remote_bitrate_estimator_->TimeUntilNextProcess());
 }
 
 void CongestionController::Process() {
   bitrate_controller_->Process();
   remote_bitrate_estimator_->Process();
   MaybeTriggerOnNetworkChanged();
 }
 
 void CongestionController::MaybeTriggerOnNetworkChanged() {
   uint32_t bitrate_bps;
   uint8_t fraction_loss;
   int64_t rtt;
-  bool network_changed = bitrate_controller_->GetNetworkParameters(
+  bool estimate_changed = bitrate_controller_->GetNetworkParameters(
       &bitrate_bps, &fraction_loss, &rtt);
-  if (network_changed)
+  if (estimate_changed)
     pacer_->SetEstimatedBitrate(bitrate_bps);
   bool send_queue_is_full =
       pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
-  bitrate_bps = send_queue_is_full ? 0 : bitrate_bps;
-  if ((network_changed && !send_queue_is_full) ||
+
+  bool network_state_changed = false;
+  bitrate_bps = IsNetworkDown(&network_state_changed) || send_queue_is_full
+                    ? 0
+                    : bitrate_bps;
+
+  if ((estimate_changed && !send_queue_is_full) || network_state_changed ||
       UpdateSendQueueStatus(send_queue_is_full)) {

[stefan-webrtc, 2016/05/04 07:28:58]

I don't like this if statement. Can we do something to make it easier to read?
Maybe move out UpdateSendQueueStatus()? It's not even clear to me what that
method would return based on just reading the if statement.

[perkj_webrtc, 2016/05/04 10:00:15]

I agree - and its not even 100% correct. PTAL

     observer_->OnNetworkChanged(bitrate_bps, fraction_loss, rtt);
   }
 }
 
 bool CongestionController::UpdateSendQueueStatus(bool send_queue_is_full) {
   rtc::CritScope cs(&critsect_);
   bool result = send_queue_is_full_ != send_queue_is_full;
   send_queue_is_full_ = send_queue_is_full;
   return result;
 }
 
+bool CongestionController::IsNetworkDown(bool* changed) {
+  rtc::CritScope cs(&critsect_);
+  *changed = network_state_changed_;
+  network_state_changed_ = false;
+  return network_state_ == kNetworkDown;
+}
+
 }  // namespace webrtc