Remove |running_| state from NackModule to avoid running a tight loop.

webrtc/modules/video_coding/nack_module.cc

 /*
  *  Copyright (c) 2016 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 @@
       sent_at_time(-1),
       retries(0) {}
 
 NackModule::NackModule(Clock* clock,
                        NackSender* nack_sender,
                        KeyFrameRequestSender* keyframe_request_sender)
     : clock_(clock),
       nack_sender_(nack_sender),
       keyframe_request_sender_(keyframe_request_sender),
       reordering_histogram_(kNumReorderingBuckets, kMaxReorderedPackets),
-      running_(true),
       initialized_(false),
       rtt_ms_(kDefaultRttMs),
       newest_seq_num_(0),
       next_process_time_ms_(-1) {
   RTC_DCHECK(clock_);
   RTC_DCHECK(nack_sender_);
   RTC_DCHECK(keyframe_request_sender_);
 }
 
 int NackModule::OnReceivedPacket(const VCMPacket& packet) {
   rtc::CritScope lock(&crit_);
-  if (!running_)
-    return -1;
   uint16_t seq_num = packet.seqNum;
   // TODO(philipel): When the packet includes information whether it is
   //                 retransmitted or not, use that value instead. For
   //                 now set it to true, which will cause the reordering
   //                 statistics to never be updated.
   bool is_retransmitted = true;
   bool is_keyframe =
       packet.is_first_packet_in_frame && packet.frameType == kVideoFrameKey;
 
   if (!initialized_) {
@@ skipping 52 matching lines @@
   rtc::CritScope lock(&crit_);
   rtt_ms_ = rtt_ms;
 }
 
 void NackModule::Clear() {
   rtc::CritScope lock(&crit_);
   nack_list_.clear();
   keyframe_list_.clear();
 }
 
-void NackModule::Stop() {
-  rtc::CritScope lock(&crit_);
-  running_ = false;
-}
-
 int64_t NackModule::TimeUntilNextProcess() {
-  rtc::CritScope lock(&crit_);
   return std::max<int64_t>(next_process_time_ms_ - clock_->TimeInMilliseconds(),
                            0);
 }
 
 void NackModule::Process() {
-  rtc::CritScope lock(&crit_);
-  if (!running_)
-    return;
+  if (nack_sender_) {
+    std::vector<uint16_t> nack_batch;
+    {
+      rtc::CritScope lock(&crit_);
+      nack_batch = GetNackBatch(kTimeOnly);
+    }
+
+    if (!nack_batch.empty())
+      nack_sender_->SendNack(nack_batch);
+  }
 
   // Update the next_process_time_ms_ in intervals to achieve
   // the targeted frequency over time. Also add multiple intervals
   // in case of a skip in time as to not make uneccessary
   // calls to Process in order to catch up.
   int64_t now_ms = clock_->TimeInMilliseconds();
   if (next_process_time_ms_ == -1) {
     next_process_time_ms_ = now_ms + kProcessIntervalMs;
   } else {
     next_process_time_ms_ = next_process_time_ms_ + kProcessIntervalMs +
                             (now_ms - next_process_time_ms_) /
                                 kProcessIntervalMs * kProcessIntervalMs;
   }
-
-  std::vector<uint16_t> nack_batch = GetNackBatch(kTimeOnly);
-  if (!nack_batch.empty() && nack_sender_ != nullptr)
-    nack_sender_->SendNack(nack_batch);
 }
 
 bool NackModule::RemovePacketsUntilKeyFrame() {
   while (!keyframe_list_.empty()) {
     auto it = nack_list_.lower_bound(*keyframe_list_.begin());
 
     if (it != nack_list_.begin()) {
       // We have found a keyframe that actually is newer than at least one
       // packet in the nack list.
       RTC_DCHECK(it != nack_list_.end());
@@ skipping 85 matching lines @@
   reordering_histogram_.Add(diff);
 }
 
 int NackModule::WaitNumberOfPackets(float probability) const {
   if (reordering_histogram_.NumValues() == 0)
     return 0;
   return reordering_histogram_.InverseCdf(probability);
 }
 
 }  // namespace webrtc