Revert of Move congestion controller processing to the pacer thread.

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 155 matching lines @@
 
   void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
   void UpdateReceiveHistograms();
   void UpdateHistograms();
   void UpdateAggregateNetworkState();
 
   Clock* const clock_;
 
   const int num_cpu_cores_;
   const std::unique_ptr<ProcessThread> module_process_thread_;
-  const std::unique_ptr<ProcessThread> congestion_controller_thread_;
+  const std::unique_ptr<ProcessThread> pacer_thread_;
   const std::unique_ptr<CallStats> call_stats_;
   const std::unique_ptr<BitrateAllocator> bitrate_allocator_;
   Call::Config config_;
   rtc::ThreadChecker configuration_thread_checker_;
 
   NetworkState audio_network_state_;
   NetworkState video_network_state_;
 
   std::unique_ptr<RWLockWrapper> receive_crit_;
   // Audio, Video, and FlexFEC receive streams are owned by the client that
@@ skipping 83 matching lines @@
 Call* Call::Create(const Call::Config& config) {
   return new internal::Call(config);
 }
 
 namespace internal {
 
 Call::Call(const Call::Config& config)
     : clock_(Clock::GetRealTimeClock()),
       num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
       module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
-      congestion_controller_thread_(
-          ProcessThread::Create("CongestionControllerThread")),
+      pacer_thread_(ProcessThread::Create("PacerThread")),
       call_stats_(new CallStats(clock_)),
       bitrate_allocator_(new BitrateAllocator(this)),
       config_(config),
       audio_network_state_(kNetworkDown),
       video_network_state_(kNetworkDown),
       receive_crit_(RWLockWrapper::CreateRWLock()),
       send_crit_(RWLockWrapper::CreateRWLock()),
       event_log_(config.event_log),
       first_packet_sent_ms_(-1),
       received_bytes_per_second_counter_(clock_, nullptr, true),
@@ skipping 26 matching lines @@
   call_stats_->RegisterStatsObserver(congestion_controller_.get());
 
   congestion_controller_->SignalNetworkState(kNetworkDown);
   congestion_controller_->SetBweBitrates(
       config_.bitrate_config.min_bitrate_bps,
       config_.bitrate_config.start_bitrate_bps,
       config_.bitrate_config.max_bitrate_bps);
 
   module_process_thread_->Start();
   module_process_thread_->RegisterModule(call_stats_.get());
-  congestion_controller_thread_->RegisterModule(congestion_controller_.get());
-  congestion_controller_thread_->Start();
+  module_process_thread_->RegisterModule(congestion_controller_.get());
+  pacer_thread_->RegisterModule(congestion_controller_->pacer());
+  pacer_thread_->RegisterModule(
+      congestion_controller_->GetRemoteBitrateEstimator(true));
+  pacer_thread_->Start();
 }
 
 Call::~Call() {
   RTC_DCHECK(!remb_.InUse());
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   RTC_CHECK(audio_send_ssrcs_.empty());
   RTC_CHECK(video_send_ssrcs_.empty());
   RTC_CHECK(video_send_streams_.empty());
   RTC_CHECK(audio_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_streams_.empty());
 
-  congestion_controller_thread_->Stop();
-  congestion_controller_thread_->DeRegisterModule(congestion_controller_.get());
+  pacer_thread_->Stop();
+  pacer_thread_->DeRegisterModule(congestion_controller_->pacer());
+  pacer_thread_->DeRegisterModule(
+      congestion_controller_->GetRemoteBitrateEstimator(true));
+  module_process_thread_->DeRegisterModule(congestion_controller_.get());
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
   call_stats_->DeregisterStatsObserver(congestion_controller_.get());
 
   // Only update histograms after process threads have been shut down, so that
   // they won't try to concurrently update stats.
   {
     rtc::CritScope lock(&bitrate_crit_);
     UpdateSendHistograms();
   }
@@ skipping 846 matching lines @@
 
 void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet) {
   RTPHeader header;
   packet.GetHeader(&header);
   congestion_controller_->OnReceivedPacket(packet.arrival_time_ms(),
                                            packet.payload_size(), header);
 }
 
 }  // namespace internal
 }  // namespace webrtc