Move PacedSender ownership to RtpTransportControllerSend.

webrtc/modules/congestion_controller/send_side_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 80 matching lines @@
   std::sort(input->begin(), input->end(), PacketFeedbackComparator());
 }
 
 }  // namespace
 
 SendSideCongestionController::SendSideCongestionController(
     const Clock* clock,
     Observer* observer,
     RtcEventLog* event_log,
     PacketRouter* packet_router)
-    : SendSideCongestionController(
-          clock,
-          observer,
-          event_log,
-          std::unique_ptr<PacedSender>(
-              new PacedSender(clock, packet_router, event_log))) {}
+    : clock_(clock),
+      observer_(observer),
+      event_log_(event_log),
+      owned_pacer_(
+          rtc::MakeUnique<PacedSender>(clock, packet_router, event_log)),

[stefan-webrtc, 2017/08/11 13:53:38]

This is now a copy of the constructor below, besides this line. Will be removed
soon.

+      pacer_(owned_pacer_.get()),
+      bitrate_controller_(
+          BitrateController::CreateBitrateController(clock_, event_log)),
+      acknowledged_bitrate_estimator_(
+          rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
+      probe_controller_(new ProbeController(pacer_, clock_)),
+      retransmission_rate_limiter_(
+          new RateLimiter(clock, kRetransmitWindowSizeMs)),
+      transport_feedback_adapter_(clock_),
+      last_reported_bitrate_bps_(0),
+      last_reported_fraction_loss_(0),
+      last_reported_rtt_(0),
+      network_state_(kNetworkUp),
+      pause_pacer_(false),
+      pacer_paused_(false),
+      min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
+      delay_based_bwe_(new DelayBasedBwe(event_log_, clock_)),
+      in_cwnd_experiment_(CwndExperimentEnabled()),
+      accepted_queue_ms_(kDefaultAcceptedQueueMs),
+      was_in_alr_(0) {
+  delay_based_bwe_->SetMinBitrate(min_bitrate_bps_);
+  if (in_cwnd_experiment_ &&
+      !ReadCwndExperimentParameter(&accepted_queue_ms_)) {
+    LOG(LS_WARNING) << "Failed to parse parameters for CwndExperiment "
+                       "from field trial string. Experiment disabled.";
+    in_cwnd_experiment_ = false;
+  }
+}
 
 SendSideCongestionController::SendSideCongestionController(
     const Clock* clock,
     Observer* observer,
     RtcEventLog* event_log,
-    std::unique_ptr<PacedSender> pacer)
+    PacedSender* pacer)
     : clock_(clock),
       observer_(observer),
       event_log_(event_log),
-      pacer_(std::move(pacer)),
+      pacer_(pacer),
       bitrate_controller_(
           BitrateController::CreateBitrateController(clock_, event_log)),
       acknowledged_bitrate_estimator_(
           rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
-      probe_controller_(new ProbeController(pacer_.get(), clock_)),
+      probe_controller_(new ProbeController(pacer_, clock_)),
       retransmission_rate_limiter_(
           new RateLimiter(clock, kRetransmitWindowSizeMs)),
       transport_feedback_adapter_(clock_),
       last_reported_bitrate_bps_(0),
       last_reported_fraction_loss_(0),
       last_reported_rtt_(0),
       network_state_(kNetworkUp),
       pause_pacer_(false),
       pacer_paused_(false),
       min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
@@ skipping 104 matching lines @@
 }
 
 int64_t SendSideCongestionController::GetPacerQueuingDelayMs() const {
   return IsNetworkDown() ? 0 : pacer_->QueueInMs();
 }
 
 int64_t SendSideCongestionController::GetFirstPacketTimeMs() const {
   return pacer_->FirstSentPacketTimeMs();
 }
 
-PacedSender* SendSideCongestionController::pacer() {
-  return pacer_.get();
-}
-
 TransportFeedbackObserver*
 SendSideCongestionController::GetTransportFeedbackObserver() {
   return this;
 }
 
 void SendSideCongestionController::SignalNetworkState(NetworkState state) {
   LOG(LS_INFO) << "SignalNetworkState "
                << (state == kNetworkUp ? "Up" : "Down");
   {
     rtc::CritScope cs(&network_state_lock_);
@@ skipping 180 matching lines @@
 bool SendSideCongestionController::IsSendQueueFull() const {
   return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
 }
 
 bool SendSideCongestionController::IsNetworkDown() const {
   rtc::CritScope cs(&network_state_lock_);
   return network_state_ == kNetworkDown;
 }
 
 }  // namespace webrtc