Pass time constant to bwe smoothing filter.

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 102 matching lines @@
 
   void OnTransportOverheadChanged(MediaType media,
                                   int transport_overhead_per_packet) override;
 
   void OnNetworkRouteChanged(const std::string& transport_name,
                              const rtc::NetworkRoute& network_route) 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;
+  void OnNetworkChanged(uint32_t bitrate_bps,
+                        uint8_t fraction_loss,
+                        int64_t rtt_ms,
+                        int64_t probing_interval_ms) override;
 
   // Implements BitrateAllocator::LimitObserver.
   void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
                                  uint32_t max_padding_bitrate_bps) override;
 
  private:
   DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
                              size_t length);
   DeliveryStatus DeliverRtp(MediaType media_type,
                             const uint8_t* packet,
@@ skipping 735 matching lines @@
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
   if (first_packet_sent_ms_ == -1)
     first_packet_sent_ms_ = clock_->TimeInMilliseconds();
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
   congestion_controller_->OnSentPacket(sent_packet);
 }
 
-void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
-                            int64_t rtt_ms) {
+void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
+                            uint8_t fraction_loss,
+                            int64_t rtt_ms,
+                            int64_t probing_interval_ms) {
   // TODO(perkj): Consider making sure CongestionController operates on
   // |worker_queue_|.
   if (!worker_queue_.IsCurrent()) {
-    worker_queue_.PostTask([this, target_bitrate_bps, fraction_loss, rtt_ms] {
-      OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms);
-    });
+    worker_queue_.PostTask(
+        [this, target_bitrate_bps, fraction_loss, rtt_ms, probing_interval_ms] {
+          OnNetworkChanged(target_bitrate_bps, fraction_loss, rtt_ms,
+                           probing_interval_ms);
+        });
     return;
   }
   RTC_DCHECK_RUN_ON(&worker_queue_);
   bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss,
-                                       rtt_ms);
+                                       rtt_ms, probing_interval_ms);
 
   // Ignore updates if bitrate is zero (the aggregate network state is down).
   if (target_bitrate_bps == 0) {
     rtc::CritScope lock(&bitrate_crit_);
     estimated_send_bitrate_kbps_counter_.ProcessAndPause();
     pacer_bitrate_kbps_counter_.ProcessAndPause();
     return;
   }
 
   bool sending_video;
@@ skipping 197 matching lines @@
   uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
   ReadLockScoped read_lock(*receive_crit_);
   auto it = video_receive_ssrcs_.find(ssrc);
   if (it == video_receive_ssrcs_.end())
     return false;
   return it->second->OnRecoveredPacket(packet, length);
 }
 
 }  // namespace internal
 }  // namespace webrtc