Cast: IPC from browser to renderer to send packet events from transport to cast library.

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..5950f33d26966c0d287ce2766a914c07ee669da9 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::InitializeAudio(const CastTransportAudioConfig& config) {
+  audio_ssrc_ = config.base.ssrc;
+}
+
+void PacedSender::InitializeVideo(const CastTransportVideoConfig& config) {
+  video_ssrc_ = config.base.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,11 @@ bool PacedSender::SendPacketsToTransport(const PacketList& packets,
   if (packets_to_send.empty())
     return true;
 
+  // All packets are either audio or video; check first packet only.
+  bool is_audio = IsAudioPacket(packets_to_send.front());
+  CastLoggingEvent event = GetLoggingEvent(is_audio, retransmit);
+  LogPacketEvents(packets_to_send, event);
+
   return TransmitPackets(packets_to_send);
 }
 
@@ -111,6 +142,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(*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 +156,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(*it, true);
+    }
+
     packets_to_resend.insert(packets_to_resend.end(), packet_list_.begin(), it);
     packet_list_.erase(packet_list_.begin(), it);
 
@@ -151,6 +193,35 @@ void PacedSender::UpdateBurstSize(size_t packets_to_send) {
       std::max(packets_to_send / kPacingMaxBurstsPerFrame, burst_size_);
 }
 
+void PacedSender::LogPacketEvents(const PacketList& packet_list,
+                                  CastLoggingEvent event) {
+  logging_->InsertPacketListEvent(clock_->NowTicks(), event, packet_list);
+}
+
+void PacedSender::LogPacketEvent(const Packet& packet, bool retransmit) {
+  CastLoggingEvent event = GetLoggingEvent(IsAudioPacket(packet), retransmit);
+
+  logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, packet);
+}
+
+bool PacedSender::IsAudioPacket(const Packet& packet) {
+  // Get SSRC from packet and compare with the audio_ssrc / video_ssrc to see
+  // if the packet is audio or video.
+  base::BigEndianReader reader(reinterpret_cast<const char*>(packet[0]), 10);
+  reader.Skip(8);
+  uint32 ssrc;
+  bool success = reader.ReadU32(&ssrc);
+  DCHECK(success);
+  if (ssrc == audio_ssrc_) {
+    return true;
+  } else if (ssrc == video_ssrc_) {
+    return false;
+  } else {
+    NOTREACHED() << "Got unknown ssrc " << ssrc << " when logging packet event";
+    return false;
+  }
+}
+
 }  // namespace transport
 }  // namespace cast
 }  // namespace media