Return a long timeout value from TimeUntilNextProcess when the PacedSender is paused

webrtc/modules/pacing/paced_sender.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.
  */
 
 #include "webrtc/modules/pacing/paced_sender.h"
 
 #include <algorithm>
 #include <map>
 #include <queue>
 #include <set>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/pacing/alr_detector.h"
 #include "webrtc/modules/pacing/bitrate_prober.h"
+#include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace {
 // Time limit in milliseconds between packet bursts.
 const int64_t kMinPacketLimitMs = 5;
 
 // Upper cap on process interval, in case process has not been called in a long
 // time.
@@ skipping 234 matching lines @@
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::CreateProbeCluster(int bitrate_bps) {
   CriticalSectionScoped cs(critsect_.get());
   prober_->CreateProbeCluster(bitrate_bps, clock_->TimeInMilliseconds());
 }
 
 void PacedSender::Pause() {
   LOG(LS_INFO) << "PacedSender paused.";
-  CriticalSectionScoped cs(critsect_.get());
-  paused_ = true;
+  {
+    CriticalSectionScoped cs(critsect_.get());
+    paused_ = true;
+  }
+  if (process_thread_)
+    process_thread_->WakeUp(this);

[stefan-webrtc, 2017/03/15 12:43:18]

Is there a point in waking up the thread if we're being paused? In that case I
assume there's nothing to send?

[tommi, 2017/03/15 13:42:56]

Yes, I added a comment that explains why:

  // Tell the process thread to call our TimeUntilNextProcess() method to get
  // a new (longer) estimate for when to call Process().

 }
 
 void PacedSender::Resume() {
   LOG(LS_INFO) << "PacedSender resumed.";
-  CriticalSectionScoped cs(critsect_.get());
-  paused_ = false;
+  {
+    CriticalSectionScoped cs(critsect_.get());
+    paused_ = false;
+  }
+  if (process_thread_)
+    process_thread_->WakeUp(this);
 }
 
 void PacedSender::SetProbingEnabled(bool enabled) {
   RTC_CHECK_EQ(0, packet_counter_);
   CriticalSectionScoped cs(critsect_.get());
   prober_->SetEnabled(enabled);
 }
 
 void PacedSender::SetEstimatedBitrate(uint32_t bitrate_bps) {
   if (bitrate_bps == 0)
@@ skipping 70 matching lines @@
 }
 
 int64_t PacedSender::AverageQueueTimeMs() {
   CriticalSectionScoped cs(critsect_.get());
   packets_->UpdateQueueTime(clock_->TimeInMilliseconds());
   return packets_->AverageQueueTimeMs();
 }
 
 int64_t PacedSender::TimeUntilNextProcess() {
   CriticalSectionScoped cs(critsect_.get());
+  if (paused_)
+    return 1000 * 60 * 60;
+
   if (prober_->IsProbing()) {
     int64_t ret = prober_->TimeUntilNextProbe(clock_->TimeInMilliseconds());
     if (ret > 0 || (ret == 0 && !probing_send_failure_))
       return ret;
   }
   int64_t elapsed_time_us = clock_->TimeInMicroseconds() - time_last_update_us_;
   int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000;
   return std::max<int64_t>(kMinPacketLimitMs - elapsed_time_ms, 0);
 }
 
@@ skipping 64 matching lines @@
     }
   }
   if (is_probing) {
     probing_send_failure_ = bytes_sent == 0;
     if (!probing_send_failure_)
       prober_->ProbeSent(clock_->TimeInMilliseconds(), bytes_sent);
   }
   alr_detector_->OnBytesSent(bytes_sent, now_us / 1000);
 }
 
+void PacedSender::ProcessThreadAttached(ProcessThread* process_thread) {

[stefan-webrtc, 2017/03/15 12:43:18]

We're never detaching because the thread is assumed to outlive the object?

[tommi, 2017/03/15 13:42:56]

This method is called when the module is registered with the thread,
unregistered (process_thread == nullptr) or when the process thread itself
stops.  Here's the documentation:

  // This method is called when the module is attached to a *running* process
  // thread or detached from one.  In the case of detaching, |process_thread|
  // will be nullptr.
  //
  // This method will be called in the following cases:
  //
  // * Non-null process_thread:
  //   * ProcessThread::RegisterModule() is called while the thread is running.
  //   * ProcessThread::Start() is called and RegisterModule has previously
  //     been called.  The thread will be started immediately after notifying
  //     all modules.
  //
  // * Null process_thread:
  //   * ProcessThread::DeRegisterModule() is called while the thread is
  //     running.
  //   * ProcessThread::Stop() was called and the thread has been stopped.
  //
  // NOTE: This method is not called from the worker thread itself, but from
  //       the thread that registers/deregisters the module or calls Start/Stop.

[stefan-webrtc, 2017/03/15 13:51:17]

I see, thanks

+  LOG(LS_INFO) << "ProcessThreadAttached 0x" << std::hex << process_thread;
+  process_thread_ = process_thread;
+}
+
 bool PacedSender::SendPacket(const paced_sender::Packet& packet,
                              const PacedPacketInfo& pacing_info) {
   if (paused_)
     return false;
   if (media_budget_->bytes_remaining() == 0 &&
       pacing_info.probe_cluster_id == PacedPacketInfo::kNotAProbe) {
     return false;
   }
 
   critsect_->Leave();
@@ skipping 30 matching lines @@
 void PacedSender::UpdateBudgetWithElapsedTime(int64_t delta_time_ms) {
   media_budget_->IncreaseBudget(delta_time_ms);
   padding_budget_->IncreaseBudget(delta_time_ms);
 }
 
 void PacedSender::UpdateBudgetWithBytesSent(size_t bytes_sent) {
   media_budget_->UseBudget(bytes_sent);
   padding_budget_->UseBudget(bytes_sent);
 }
 }  // namespace webrtc