Make RtpTransportControllerSend::send_side_cc_ a direct member.

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 74 matching lines @@
 }
 
 bool UseSendSideBwe(const FlexfecReceiveStream::Config& config) {
   return UseSendSideBwe(config.rtp_header_extensions, config.transport_cc);
 }
 
 class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
  public:
   RtpTransportControllerSend(Clock* clock, webrtc::RtcEventLog* event_log);
 
-  void InitCongestionControl(SendSideCongestionController::Observer* observer);
+  void RegisterNetworkObserver(
+      SendSideCongestionController::Observer* observer);
+
+  // Implements RtpTransportControllerSendInterface
   PacketRouter* packet_router() override { return &packet_router_; }
   SendSideCongestionController* send_side_cc() override {
-    return send_side_cc_.get();
+    return &send_side_cc_;
   }
   TransportFeedbackObserver* transport_feedback_observer() override {
-    return send_side_cc_.get();
+    return &send_side_cc_;
   }
-  RtpPacketSender* packet_sender() override { return send_side_cc_->pacer(); }
+  RtpPacketSender* packet_sender() override { return send_side_cc_.pacer(); }
 
  private:
-  Clock* const clock_;
-  webrtc::RtcEventLog* const event_log_;
   PacketRouter packet_router_;
-  // Construction delayed until InitCongestionControl, since the
-  // CongestionController wants its observer as a construction time
-  // argument, and setting it later seems non-trivial.
-  std::unique_ptr<SendSideCongestionController> send_side_cc_;
+  SendSideCongestionController send_side_cc_;
 };
 
 RtpTransportControllerSend::RtpTransportControllerSend(
     Clock* clock,
     webrtc::RtcEventLog* event_log)
-    : clock_(clock), event_log_(event_log) {}
+    : send_side_cc_(clock, nullptr /* observer */, event_log, &packet_router_) {
+}
 
-void RtpTransportControllerSend::InitCongestionControl(
+void RtpTransportControllerSend::RegisterNetworkObserver(
     SendSideCongestionController::Observer* observer) {
   // Must be called only once.
-  RTC_CHECK(!send_side_cc_);
-  send_side_cc_.reset(new SendSideCongestionController(
-      clock_, observer, event_log_, &packet_router_));
+  send_side_cc_.RegisterNetworkObserver(observer);
 }
 
 }  // namespace
 
 namespace internal {
 
 class Call : public webrtc::Call,
              public PacketReceiver,
              public RecoveredPacketReceiver,
              public SendSideCongestionController::Observer,
@@ skipping 167 matching lines @@
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
   uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
   AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
   AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
 
-  std::unique_ptr<RtpTransportControllerSend> transport_send_;
+  std::unique_ptr<RtpTransportControllerSendInterface> transport_send_;
   VieRemb remb_;
   ReceiveSideCongestionController receive_side_cc_;
   const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
   const int64_t start_ms_;
   // TODO(perkj): |worker_queue_| is supposed to replace
   // |module_process_thread_|.
   // |worker_queue| is defined last to ensure all pending tasks are cancelled
   // and deleted before any other members.
   rtc::TaskQueue worker_queue_;
 
@@ skipping 38 matching lines @@
       event_log_(config.event_log),
       first_packet_sent_ms_(-1),
       received_bytes_per_second_counter_(clock_, nullptr, true),
       received_audio_bytes_per_second_counter_(clock_, nullptr, true),
       received_video_bytes_per_second_counter_(clock_, nullptr, true),
       received_rtcp_bytes_per_second_counter_(clock_, nullptr, true),
       min_allocated_send_bitrate_bps_(0),
       configured_max_padding_bitrate_bps_(0),
       estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
       pacer_bitrate_kbps_counter_(clock_, nullptr, true),
-      transport_send_(std::move(transport_send)),
       remb_(clock_),
-      receive_side_cc_(clock_, &remb_, transport_send_->packet_router()),
+      receive_side_cc_(clock_, &remb_, transport_send->packet_router()),
       video_send_delay_stats_(new SendDelayStats(clock_)),
       start_ms_(clock_->TimeInMilliseconds()),
       worker_queue_("call_worker_queue") {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(config.event_log != nullptr);
   RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
   RTC_DCHECK_GT(config.bitrate_config.start_bitrate_bps,
                 config.bitrate_config.min_bitrate_bps);
   if (config.bitrate_config.max_bitrate_bps != -1) {
     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
                   config.bitrate_config.start_bitrate_bps);
   }
   Trace::CreateTrace();
-  transport_send_->InitCongestionControl(this);
+  transport_send->RegisterNetworkObserver(this);
+  transport_send_ = std::move(transport_send);
   transport_send_->send_side_cc()->SignalNetworkState(kNetworkDown);
   transport_send_->send_side_cc()->SetBweBitrates(
       config_.bitrate_config.min_bitrate_bps,
       config_.bitrate_config.start_bitrate_bps,
       config_.bitrate_config.max_bitrate_bps);
   call_stats_->RegisterStatsObserver(&receive_side_cc_);
   call_stats_->RegisterStatsObserver(transport_send_->send_side_cc());
 
   module_process_thread_->Start();
   module_process_thread_->RegisterModule(call_stats_.get(), RTC_FROM_HERE);
@@ skipping 926 matching lines @@
       (use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
     receive_side_cc_.OnReceivedPacket(
         packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),
         header);
   }
 }
 
 }  // namespace internal
 
 }  // namespace webrtc