Increase STUN RTOs

webrtc/base/messagequeue.cc

 /*
  *  Copyright 2004 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 <algorithm>
@@ skipping 128 matching lines @@
     }
     ~ScopedIncrement() override { AtomicOps::Decrement(value_); }
 
    private:
     volatile int* value_;
   };
 
   {
     DebugNonReentrantCritScope cs(&crit_, &locked_);
     for (MessageQueue* queue : message_queues_) {
-      if (queue->IsQuitting()) {
-        // If the queue is quitting, it's done processing messages so it can
-        // be ignored. If we tried to post a message to it, it would be dropped.
+      if (!queue->WaitForProcess()) {
         continue;
       }
       queue->PostDelayed(RTC_FROM_HERE, 0, nullptr, MQID_DISPOSE,
                          new ScopedIncrement(&queues_not_done));
     }
   }
   // Note: One of the message queues may have been on this thread, which is why
   // we can't synchronously wait for queues_not_done to go to 0; we need to
   // process messages as well.
   while (AtomicOps::AcquireLoad(&queues_not_done) > 0) {
-    rtc::Thread::Current()->ProcessMessages(0);
+    // We have to limit the number of messages that may be processed
+    // because we may get into an infinite processing loop even after
+    // "queues_not_done" is 0.

[Taylor Brandstetter, 2017/02/06 19:23:42]

How does that happen? That seems like a deeper problem.

+    rtc::Thread::Current()->ProcessMessages(0, 100);
   }
 }
 
 //------------------------------------------------------------------
 // MessageQueue
 MessageQueue::MessageQueue(SocketServer* ss, bool init_queue)
     : fPeekKeep_(false),
       dmsgq_next_num_(0),
       fInitialized_(false),
       fDestroyed_(false),
@@ skipping 70 matching lines @@
 }
 
 void MessageQueue::Quit() {
   AtomicOps::ReleaseStore(&stop_, 1);
   WakeUpSocketServer();
 }
 
 bool MessageQueue::IsQuitting() {
   return AtomicOps::AcquireLoad(&stop_) != 0;
 }
+bool MessageQueue::WaitForProcess() {
+  // If the queue is quitting, it's done processing messages so it can
+  // be ignored.  If we tried to post a message to it, it would be dropped.
+  return !IsQuitting();
+}
 
 void MessageQueue::Restart() {
   AtomicOps::ReleaseStore(&stop_, 0);
 }
 
 bool MessageQueue::Peek(Message *pmsg, int cmsWait) {
   if (fPeekKeep_) {
     *pmsg = msgPeek_;
     return true;
   }
@@ skipping 270 matching lines @@
   pmsg->phandler->OnMessage(pmsg);
   int64_t end_time = TimeMillis();
   int64_t diff = TimeDiff(end_time, start_time);
   if (diff >= kSlowDispatchLoggingThreshold) {
     LOG(LS_INFO) << "Message took " << diff << "ms to dispatch. Posted from: "
                  << pmsg->posted_from.ToString();
   }
 }
 
 }  // namespace rtc