Add methods to register congestion controller observer after construction.

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 28 matching lines @@
   if (*max_bitrate_bps > 0)
     *max_bitrate_bps = std::max(*min_bitrate_bps, *max_bitrate_bps);
   if (*bitrate_bps > 0)
     *bitrate_bps = std::max(*min_bitrate_bps, *bitrate_bps);
 }
 
 }  // namespace
 
 SendSideCongestionController::SendSideCongestionController(
     const Clock* clock,
     Observer* observer,

[terelius, 2017/04/03 09:48:04]

Going forward, will we deprecate passing an observer to the constructor? If so,
should there be a comment explaining this?

[nisse-webrtc, 2017/04/03 09:54:42]

Hmm. Maybe. 

The CongestionController class (old all-in-one-class, both send and receive
side, which we should eventually delete) has a corresponding constructor
argument, which I don't think it makes sense to touch. But we could delete the
argument from *this* constructor, and let the CongestionController class call
RegisterNetworkObserver. What do you think?

[terelius, 2017/04/03 10:55:28]

Agree about not spending time on changing something that we plan to delete
anyway. I don't know what interface would be most useful in
SendSideCongestionController. However, if we know that we're always going to set
the oberser using the new functions, then I think it would be nice to add a TODO
in the constructor. 

     RtcEventLog* event_log,
     PacketRouter* packet_router)
     : SendSideCongestionController(
           clock,
           observer,
           event_log,
           std::unique_ptr<PacedSender>(
               new PacedSender(clock, packet_router, event_log))) {}
 
 SendSideCongestionController::SendSideCongestionController(
@@ skipping 26 matching lines @@
 void SendSideCongestionController::RegisterPacketFeedbackObserver(
     PacketFeedbackObserver* observer) {
   transport_feedback_adapter_.RegisterPacketFeedbackObserver(observer);
 }
 
 void SendSideCongestionController::DeRegisterPacketFeedbackObserver(
     PacketFeedbackObserver* observer) {
   transport_feedback_adapter_.DeRegisterPacketFeedbackObserver(observer);
 }
 
+void SendSideCongestionController::RegisterNetworkObserver(Observer* observer) {
+  rtc::CritScope cs(&observer_lock_);
+  RTC_DCHECK(observer_ == nullptr);
+  observer_ = observer;
+}
+
+void SendSideCongestionController::DeRegisterNetworkObserver(
+    Observer* observer) {
+  rtc::CritScope cs(&observer_lock_);
+  RTC_DCHECK_EQ(observer_, observer);
+  observer_ = nullptr;
+}
+
 void SendSideCongestionController::SetBweBitrates(int min_bitrate_bps,
                                                   int start_bitrate_bps,
                                                   int max_bitrate_bps) {
   ClampBitrates(&start_bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
   bitrate_controller_->SetBitrates(start_bitrate_bps, min_bitrate_bps,
                                    max_bitrate_bps);
 
   probe_controller_->SetBitrates(min_bitrate_bps, start_bitrate_bps,
                                  max_bitrate_bps);
 
@@ skipping 132 matching lines @@
     bitrate_controller_->OnDelayBasedBweResult(result);
 }
 
 std::vector<PacketFeedback>
 SendSideCongestionController::GetTransportFeedbackVector() const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return transport_feedback_adapter_.GetTransportFeedbackVector();
 }
 
 void SendSideCongestionController::MaybeTriggerOnNetworkChanged() {
-  // TODO(perkj): |observer_| can be nullptr if the ctor that accepts a
-  // BitrateObserver is used. Remove this check once the ctor is removed.
-  if (!observer_)
-    return;
-
   uint32_t bitrate_bps;
   uint8_t fraction_loss;
   int64_t rtt;
   bool estimate_changed = bitrate_controller_->GetNetworkParameters(
       &bitrate_bps, &fraction_loss, &rtt);
   if (estimate_changed) {
     pacer_->SetEstimatedBitrate(bitrate_bps);
     probe_controller_->SetEstimatedBitrate(bitrate_bps);
     retransmission_rate_limiter_->SetMaxRate(bitrate_bps);
   }
 
   bitrate_bps = IsNetworkDown() || IsSendQueueFull() ? 0 : bitrate_bps;
 
   if (HasNetworkParametersToReportChanged(bitrate_bps, fraction_loss, rtt)) {
     int64_t probing_interval_ms;
     {
       rtc::CritScope cs(&bwe_lock_);
       probing_interval_ms = delay_based_bwe_->GetProbingIntervalMs();
     }
-    observer_->OnNetworkChanged(bitrate_bps, fraction_loss, rtt,
-                                probing_interval_ms);
+    {
+      rtc::CritScope cs(&observer_lock_);
+      if (observer_) {
+        observer_->OnNetworkChanged(bitrate_bps, fraction_loss, rtt,
+                                    probing_interval_ms);
+      }
+    }
   }
 }
 
 bool SendSideCongestionController::HasNetworkParametersToReportChanged(
     uint32_t bitrate_bps,
     uint8_t fraction_loss,
     int64_t rtt) {
   rtc::CritScope cs(&network_state_lock_);
   bool changed =
       last_reported_bitrate_bps_ != bitrate_bps ||
@@ skipping 12 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