[Cast] Sanity-check for unbounded queue growth in PacedSender.

media/cast/net/pacing/paced_sender.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/net/pacing/paced_sender.h"
 
 #include "base/big_endian.h"
 #include "base/bind.h"
+#include "base/debug/dump_without_crashing.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/logging/logging_impl.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 static const int64 kPacingIntervalMs = 10;
 // Each frame will be split into no more than kPacingMaxBurstsPerFrame
 // bursts of packets.
 static const size_t kPacingMaxBurstsPerFrame = 3;
 static const size_t kMaxDedupeWindowMs = 500;
 
+// "Impossible" upper-bound on the maximum number of packets that should ever be
+// enqueued in the pacer.  This is used to detect bugs, reported as crash dumps.
+static const size_t kHugeQueueLengthSeconds = 10;
+static const size_t kRidiculousNumberOfPackets =
+    kHugeQueueLengthSeconds * (kMaxBurstSize * 1000 / kPacingIntervalMs);
+
 }  // namespace
 
 DedupInfo::DedupInfo() : last_byte_acked_for_audio(0) {}
 
 // static
 PacketKey PacedPacketSender::MakePacketKey(const base::TimeTicks& ticks,
                                            uint32 ssrc,
                                            uint16 packet_id) {
   return std::make_pair(ticks, std::make_pair(ssrc, packet_id));
 }
@@ skipping 14 matching lines @@
       transport_task_runner_(transport_task_runner),
       audio_ssrc_(0),
       video_ssrc_(0),
       target_burst_size_(target_burst_size),
       max_burst_size_(max_burst_size),
       current_max_burst_size_(target_burst_size_),
       next_max_burst_size_(target_burst_size_),
       next_next_max_burst_size_(target_burst_size_),
       current_burst_size_(0),
       state_(State_Unblocked),
+      has_reached_upper_bound_once_(false),
       weak_factory_(this) {
 }
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::RegisterAudioSsrc(uint32 audio_ssrc) {
   audio_ssrc_ = audio_ssrc;
 }
 
 void PacedSender::RegisterVideoSsrc(uint32 video_ssrc) {
@@ skipping 148 matching lines @@
 //    let us know that it's ok to send again.
 // 3. state_ == State_BurstFull and there are still packets to send. In this
 //    case we called PostDelayedTask on this function to start a new burst.
 void PacedSender::SendStoredPackets() {
   State previous_state = state_;
   state_ = State_Unblocked;
   if (empty()) {
     return;
   }
 
+  // If the queue ever becomes impossibly long, send a crash dump without
+  // actually crashing the process.
+  if (size() > kRidiculousNumberOfPackets && !has_reached_upper_bound_once_) {
+    NOTREACHED();
+    // Please use Cr=Internals-Cast label in bug reports:
+    base::debug::DumpWithoutCrashing();
+    has_reached_upper_bound_once_ = true;
+  }
+
   base::TimeTicks now = clock_->NowTicks();
   // I don't actually trust that PostDelayTask(x - now) will mean that
   // now >= x when the call happens, so check if the previous state was
   // State_BurstFull too.
   if (now >= burst_end_ || previous_state == State_BurstFull) {
     // Start a new burst.
     current_burst_size_ = 0;
     burst_end_ = now + base::TimeDelta::FromMilliseconds(kPacingIntervalMs);
 
     // The goal here is to try to send out the queued packets over the next
     // three bursts, while trying to keep the burst size below 10 if possible.
     // We have some evidence that sending more than 12 packets in a row doesn't
     // work very well, but we don't actually know why yet. Sending out packets
     // sooner is better than sending out packets later as that gives us more
     // time to re-send them if needed. So if we have less than 30 packets, just
     // send 10 at a time. If we have less than 60 packets, send n / 3 at a time.
     // if we have more than 60, we send 20 at a time. 20 packets is ~24Mbit/s
     // which is more bandwidth than the cast library should need, and sending
     // out more data per second is unlikely to be helpful.
     size_t max_burst_size = std::min(
         max_burst_size_,
         std::max(target_burst_size_, size() / kPacingMaxBurstsPerFrame));
-
-    // If the queue is long, issue a warning. Try to limit the number of
-    // warnings issued by only issuing the warning when the burst size
-    // grows. Otherwise we might get 100 warnings per second.
-    if (max_burst_size > next_next_max_burst_size_ && size() > 100) {
-      LOG(WARNING) << "Packet queue is very long:" << size();
-    }
-
     current_max_burst_size_ = std::max(next_max_burst_size_, max_burst_size);
     next_max_burst_size_ = std::max(next_next_max_burst_size_, max_burst_size);
     next_next_max_burst_size_ = max_burst_size;
   }
 
   base::Closure cb = base::Bind(&PacedSender::SendStoredPackets,
                                 weak_factory_.GetWeakPtr());
   while (!empty()) {
     if (current_burst_size_ >= current_max_burst_size_) {
       transport_task_runner_->PostDelayedTask(FROM_HERE,
@@ skipping 64 matching lines @@
     return;
   }
 
   EventMediaType media_type = is_audio ? AUDIO_EVENT : VIDEO_EVENT;
   logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, media_type,
       packet);
 }
 
 }  // namespace cast
 }  // namespace media