Cast: Log sender side packet events.

media/cast/transport/pacing/paced_sender.cc

Index: media/cast/transport/pacing/paced_sender.cc
diff --git a/media/cast/transport/pacing/paced_sender.cc b/media/cast/transport/pacing/paced_sender.cc
index 976e68ad8d60c33e50ff84f806a3cfcd24d84d32..8c1281131f564ce7467958b7419ce7e6e75dba36 100644
--- a/media/cast/transport/pacing/paced_sender.cc
+++ b/media/cast/transport/pacing/paced_sender.cc
@@ -4,6 +4,7 @@
 
 #include "media/cast/transport/pacing/paced_sender.h"
 
+#include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 
@@ -17,15 +18,31 @@ static const int64 kPacingIntervalMs = 10;
 // bursts of packets.
 static const size_t kPacingMaxBurstsPerFrame = 3;
 
+using media::cast::CastLoggingEvent;
+
+CastLoggingEvent GetLoggingEvent(bool is_audio, bool retransmit) {
+  if (retransmit) {
+    return is_audio ? media::cast::kAudioPacketRetransmitted
+                    : media::cast::kVideoPacketRetransmitted;
+  } else {
+    return is_audio ? media::cast::kAudioPacketSentToNetwork
+                    : media::cast::kVideoPacketSentToNetwork;
+  }
+}
+
 }  // namespace
 
 PacedSender::PacedSender(
     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),
       burst_size_(1),
       packets_sent_in_burst_(0),
       weak_factory_(this) {
@@ -34,16 +51,25 @@ PacedSender::PacedSender(
 
 PacedSender::~PacedSender() {}
 
+void PacedSender::RegisterAudioSsrc(uint32 audio_ssrc) {
+  audio_ssrc_ = audio_ssrc;
+}
+
+void PacedSender::RegisterVideoSsrc(uint32 video_ssrc) {
+  video_ssrc_ = video_ssrc;
+}
+
 bool PacedSender::SendPackets(const PacketList& packets) {
-  return SendPacketsToTransport(packets, &packet_list_);
+  return SendPacketsToTransport(packets, &packet_list_, false);
 }
 
 bool PacedSender::ResendPackets(const PacketList& packets) {
-  return SendPacketsToTransport(packets, &resend_packet_list_);
+  return SendPacketsToTransport(packets, &resend_packet_list_, true);
 }
 
 bool PacedSender::SendPacketsToTransport(const PacketList& packets,
-                                         PacketList* packets_not_sent) {
+                                         PacketList* packets_not_sent,
+                                         bool retransmit) {
   UpdateBurstSize(packets.size());
 
   if (!packets_not_sent->empty()) {
@@ -71,6 +97,12 @@ bool PacedSender::SendPacketsToTransport(const PacketList& packets,
   if (packets_to_send.empty())
     return true;
 
+  for (PacketList::iterator it = packets_to_send.begin();
+       it != packets_to_send.end();
+       ++it) {
+    LogPacketEvent(*it, retransmit);
+  }
+
   return TransmitPackets(packets_to_send);
 }
 
@@ -111,6 +143,12 @@ void PacedSender::SendStoredPackets() {
     size_t packets_to_send_now =
         std::min(packets_to_send, resend_packet_list_.size());
     std::advance(it, packets_to_send_now);
+
+    for (PacketList::iterator log_it = resend_packet_list_.begin();
+         log_it != it;
+         ++log_it) {
+      LogPacketEvent(*log_it, true);
+    }
     packets_to_resend.insert(
         packets_to_resend.begin(), resend_packet_list_.begin(), it);
     resend_packet_list_.erase(resend_packet_list_.begin(), it);
@@ -119,8 +157,13 @@ void PacedSender::SendStoredPackets() {
   if (!packet_list_.empty() && packets_to_send > 0) {
     PacketList::iterator it = packet_list_.begin();
     size_t packets_to_send_now = std::min(packets_to_send, packet_list_.size());
-
     std::advance(it, packets_to_send_now);
+
+    for (PacketList::iterator log_it = packet_list_.begin(); log_it != it;
+         ++log_it) {
+      LogPacketEvent(*log_it, false);
+    }
+
     packets_to_resend.insert(packets_to_resend.end(), packet_list_.begin(), it);
     packet_list_.erase(packet_list_.begin(), it);
 
@@ -151,6 +194,29 @@ void PacedSender::UpdateBurstSize(size_t packets_to_send) {
       std::max(packets_to_send / kPacingMaxBurstsPerFrame, burst_size_);
 }
 
+void PacedSender::LogPacketEvent(const Packet& packet, bool retransmit) {
+  // 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;

[Alpha Left Google, 2014/03/13 19:56:14]

This can be simplified as:

DCHECK(ssrc == audio_ssrc_ || ssrc == video_ssrc_);
GetLoggingEvent(ssrc == audio_ssrc, retransmit);

[imcheng, 2014/03/13 21:48:58]

This changes the behavior though. If we get a packet with an unknown ssrc it
will blow up in debug mode or default to a video event otherwise. Since this is
browser side I am wary of crashing. So I went with DVLOG + ignoring. What do you
think?

+  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;
+  }
+
+  CastLoggingEvent event = GetLoggingEvent(is_audio, retransmit);
+
+  logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, packet);
+}
+
 }  // namespace transport
 }  // namespace cast
 }  // namespace media