Cast: Make pacing controllable by the extension

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/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 kTargetBurstSize = 10;
-static const size_t kMaxBurstSize = 20;
 static const size_t kMaxDedupeWindowMs = 500;
 
-// Number of packets that we keep the information of sent time and sent bytes.
-// This number allows 0.5 seconds of history if sending at maximum rate.
-static const size_t kPacketHistorySize =
-    kMaxBurstSize * kMaxDedupeWindowMs / 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));
 }
 
 PacedSender::PacketSendRecord::PacketSendRecord()
     : last_byte_sent(0), last_byte_sent_for_audio(0) {}
 
 PacedSender::PacedSender(
+    size_t target_burst_size,
+    size_t max_burst_size,
     base::TickClock* clock,
     LoggingImpl* logging,
     PacketSender* transport,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner)
     : clock_(clock),
       logging_(logging),
       transport_(transport),
       transport_task_runner_(transport_task_runner),
       audio_ssrc_(0),
       video_ssrc_(0),
-      max_burst_size_(kTargetBurstSize),
-      next_max_burst_size_(kTargetBurstSize),
-      next_next_max_burst_size_(kTargetBurstSize),
+      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),
       weak_factory_(this) {
 }
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::RegisterAudioSsrc(uint32 audio_ssrc) {
   audio_ssrc_ = audio_ssrc;
 }
@@ skipping 170 matching lines @@
     // 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(
-        kMaxBurstSize,
-        std::max(kTargetBurstSize, size() / kPacingMaxBurstsPerFrame));
+        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();
     }
 
-    max_burst_size_ = std::max(next_max_burst_size_, max_burst_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_ >= max_burst_size_) {
+    if (current_burst_size_ >= current_max_burst_size_) {
       transport_task_runner_->PostDelayedTask(FROM_HERE,
                                               cb,
                                               burst_end_ - now);
       state_ = State_BurstFull;
       return;
     }
     PacketType packet_type;
     PacketKey packet_key;
     PacketRef packet = PopNextPacket(&packet_type, &packet_key);
     PacketSendRecord send_record;
@@ skipping 20 matching lines @@
     last_byte_sent_[packet_key.second.first] = send_record.last_byte_sent;
 
     if (socket_blocked) {
       state_ = State_TransportBlocked;
       return;
     }
     current_burst_size_++;
   }
 
   // Keep ~0.5 seconds of data (1000 packets).
-  if (send_history_buffer_.size() >= kPacketHistorySize) {
+  if (send_history_buffer_.size() >=
+      max_burst_size_ * kMaxDedupeWindowMs / kPacingIntervalMs) {
     send_history_.swap(send_history_buffer_);
     send_history_buffer_.clear();
   }
-  DCHECK_LE(send_history_buffer_.size(), kPacketHistorySize);
+  DCHECK_LE(send_history_buffer_.size(),
+            max_burst_size_ * kMaxDedupeWindowMs / kPacingIntervalMs);
   state_ = State_Unblocked;
 }
 
 void PacedSender::LogPacketEvent(const Packet& packet, CastLoggingEvent event) {
   // Get SSRC from packet and compare with the audio_ssrc / video_ssrc to see
   // if the packet is audio or video.
   DCHECK_GE(packet.size(), 12u);
   base::BigEndianReader reader(reinterpret_cast<const char*>(&packet[8]), 4);
   uint32 ssrc;
   bool success = reader.ReadU32(&ssrc);
   DCHECK(success);
   bool is_audio;
   if (ssrc == audio_ssrc_) {
     is_audio = true;
   } else if (ssrc == video_ssrc_) {
     is_audio = false;
   } else {
     DVLOG(3) << "Got unknown ssrc " << ssrc << " when logging packet event";
     return;
   }
 
   EventMediaType media_type = is_audio ? AUDIO_EVENT : VIDEO_EVENT;
   logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, media_type,
       packet);
 }
 
 }  // namespace cast
 }  // namespace media