IPC glue between cast library transport and encoders.

This CL lets the cast library run the packetizing and encryption in the browser and the video and audio encoding in the renderer. The encoded data is sent over IPC to the browser.

BUG=301920

Review URL: https://codereview.chromium.org/138753004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@251592 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 63 insertions, 41 deletions

diff --git a/media/cast/audio_sender/audio_sender.cc b/media/cast/audio_sender/audio_sender.cc
index 66027e4..8da20cb 100644
--- a/media/cast/audio_sender/audio_sender.cc
+++ b/media/cast/audio_sender/audio_sender.cc
@@ -69,7 +69,7 @@ class LocalRtpSenderStatistics : public RtpSenderStatistics {
     sender_info->send_octet_count = sender_info_.send_octet_count;
   }
 
-  void StoreStatistics(transport::RtcpSenderInfo& sender_info,
+  void StoreStatistics(const transport::RtcpSenderInfo& sender_info,
                        base::TimeTicks time_sent,
                        uint32 rtp_timestamp) {
     sender_info_ = sender_info;
diff --git a/media/cast/rtcp/rtcp_defines.h b/media/cast/rtcp/rtcp_defines.h
index 40f4a0d..a8f91d7 100644
--- a/media/cast/rtcp/rtcp_defines.h
+++ b/media/cast/rtcp/rtcp_defines.h
@@ -5,7 +5,6 @@
 #ifndef MEDIA_CAST_RTCP_RTCP_DEFINES_H_
 #define MEDIA_CAST_RTCP_RTCP_DEFINES_H_
 
-#include <list>
 #include <map>
 #include <set>
 
diff --git a/media/cast/transport/cast_transport_config.cc b/media/cast/transport/cast_transport_config.cc
index 99aca57..1ec6be5 100644
--- a/media/cast/transport/cast_transport_config.cc
+++ b/media/cast/transport/cast_transport_config.cc
@@ -69,6 +69,11 @@ RtcpDlrrReportBlock::RtcpDlrrReportBlock()
     : last_rr(0), delay_since_last_rr(0) {}
 RtcpDlrrReportBlock::~RtcpDlrrReportBlock() {}
 
+SendRtcpFromRtpSenderData::SendRtcpFromRtpSenderData()
+    : packet_type_flags(0),
+      sending_ssrc(0) {}
+SendRtcpFromRtpSenderData::~SendRtcpFromRtpSenderData() {}
+
 }  // namespace transport
 }  // namespace cast
 }  // namespace media
diff --git a/media/cast/transport/cast_transport_config.h b/media/cast/transport/cast_transport_config.h
index c59bf1c..d8474f4 100644
--- a/media/cast/transport/cast_transport_config.h
+++ b/media/cast/transport/cast_transport_config.h
@@ -113,7 +113,7 @@ struct RtcpSenderFrameLogMessage {
   uint32 rtp_timestamp;
 };
 
-typedef std::list<RtcpSenderFrameLogMessage> RtcpSenderLogMessage;
+typedef std::vector<RtcpSenderFrameLogMessage> RtcpSenderLogMessage;
 
 struct RtcpSenderInfo {
   RtcpSenderInfo();
@@ -147,6 +147,16 @@ struct RtcpDlrrReportBlock {
   uint32 delay_since_last_rr;
 };
 
+// This is only needed because IPC messages don't support more than
+// 5 arguments.
+struct SendRtcpFromRtpSenderData {
+  SendRtcpFromRtpSenderData();
+  ~SendRtcpFromRtpSenderData();
+  uint32 packet_type_flags;
+  uint32 sending_ssrc;
+  std::string c_name;
+};
+
 inline bool operator==(RtcpSenderInfo lhs, RtcpSenderInfo rhs) {
   return lhs.ntp_seconds == rhs.ntp_seconds &&
          lhs.ntp_fraction == rhs.ntp_fraction &&
diff --git a/media/cast/transport/cast_transport_defines.h b/media/cast/transport/cast_transport_defines.h
index eff33b5..75e8d62 100644
--- a/media/cast/transport/cast_transport_defines.h
+++ b/media/cast/transport/cast_transport_defines.h
@@ -5,7 +5,6 @@
 #ifndef MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_DEFINES_H_
 #define MEDIA_CAST_TRANSPORT_CAST_TRANSPORT_DEFINES_H_
 
-#include <list>
 #include <map>
 #include <set>
 #include <string>
diff --git a/media/cast/transport/cast_transport_sender.h b/media/cast/transport/cast_transport_sender.h
index 24bfedb..2e214bf 100644
--- a/media/cast/transport/cast_transport_sender.h
+++ b/media/cast/transport/cast_transport_sender.h
@@ -38,7 +38,7 @@ namespace transport {
 typedef base::Callback<void(CastTransportStatus status)>
     CastTransportStatusCallback;
 
-typedef base::Callback<void(RtcpSenderInfo& sender_info,
+typedef base::Callback<void(const RtcpSenderInfo& sender_info,
                             base::TimeTicks time_sent,
                             uint32 rtp_timestamp)> CastTransportRtpStatistics;
 
diff --git a/media/cast/transport/rtcp/rtcp_builder.cc b/media/cast/transport/rtcp/rtcp_builder.cc
index e891023..6ab8c8b 100644
--- a/media/cast/transport/rtcp/rtcp_builder.cc
+++ b/media/cast/transport/rtcp/rtcp_builder.cc
@@ -55,17 +55,17 @@ void RtcpBuilder::SendRtcpFromRtpSender(
   Packet packet;
   packet.reserve(kMaxIpPacketSize);
   if (packet_type_flags & kRtcpSr) {
-    BuildSR(sender_info, &packet);
-    BuildSdec(&packet);
+    if (!BuildSR(sender_info, &packet)) return;
+    if (!BuildSdec(&packet)) return;
   }
   if (packet_type_flags & kRtcpBye) {
-    BuildBye(&packet);
+    if (!BuildBye(&packet)) return;
   }
   if (packet_type_flags & kRtcpDlrr) {
-    BuildDlrrRb(dlrr, &packet);
+    if (!BuildDlrrRb(dlrr, &packet)) return;
   }
   if (packet_type_flags & kRtcpSenderLog) {
-    BuildSenderLog(sender_log, &packet);
+    if (!BuildSenderLog(sender_log, &packet)) return;
   }
   if (packet.empty())
     return;  // Sanity - don't send empty packets.
@@ -73,12 +73,14 @@ void RtcpBuilder::SendRtcpFromRtpSender(
   transport_->SendRtcpPacket(packet);
 }
 
-void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
+bool RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
                           Packet* packet) const {
   // Sender report.
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 52, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 52 > kMaxIpPacketSize) return;
+  if (start_size + 52 > kMaxIpPacketSize) {
+    DLOG(FATAL) << "Not enough buffer space";
+    return false;
+  }
 
   uint16 number_of_rows = 6;
   packet->resize(start_size + 28);
@@ -93,13 +95,15 @@ void RtcpBuilder::BuildSR(const RtcpSenderInfo& sender_info,
   big_endian_writer.WriteU32(sender_info.rtp_timestamp);
   big_endian_writer.WriteU32(sender_info.send_packet_count);
   big_endian_writer.WriteU32(static_cast<uint32>(sender_info.send_octet_count));
+  return true;
 }
 
-void RtcpBuilder::BuildSdec(Packet* packet) const {
+bool RtcpBuilder::BuildSdec(Packet* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size +  12 + c_name_.length(), kMaxIpPacketSize)
-      << "Not enough buffer space";
-  if (start_size + 12 > kMaxIpPacketSize) return;
+  if (start_size + 12 + c_name_.length() > kMaxIpPacketSize) {
+    DLOG(FATAL) << "Not enough buffer space";
+    return false;
+  }
 
   // SDES Source Description.
   packet->resize(start_size + 10);
@@ -136,12 +140,15 @@ void RtcpBuilder::BuildSdec(Packet* packet) const {
   // In 32-bit words minus one and we don't count the header.
   uint8 buffer_length = static_cast<uint8>((sdes_length / 4) - 1);
   (*packet)[sdes_length_position] = buffer_length;
+  return true;
 }
 
-void RtcpBuilder::BuildBye(Packet* packet) const {
+bool RtcpBuilder::BuildBye(Packet* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 8, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 8 > kMaxIpPacketSize) return;
+  if (start_size + 8 > kMaxIpPacketSize) {
+    DLOG(FATAL) << "Not enough buffer space";
+    return false;
+  }
 
   packet->resize(start_size + 8);
 
@@ -150,6 +157,7 @@ void RtcpBuilder::BuildBye(Packet* packet) const {
   big_endian_writer.WriteU8(kPacketTypeBye);
   big_endian_writer.WriteU16(1);  // Length.
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
+  return true;
 }
 
 /*
@@ -169,11 +177,13 @@ void RtcpBuilder::BuildBye(Packet* packet) const {
   |                   delay since last RR (DLRR)                  |
   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 */
-void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
+bool RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
                               Packet* packet) const {
   size_t start_size = packet->size();
-  DCHECK_LT(start_size + 24, kMaxIpPacketSize) << "Not enough buffer space";
-  if (start_size + 24 > kMaxIpPacketSize) return;
+  if (start_size + 24 > kMaxIpPacketSize) {
+    DLOG(FATAL) << "Not enough buffer space";
+    return false;
+  }
 
   packet->resize(start_size + 24);
 
@@ -188,17 +198,18 @@ void RtcpBuilder::BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
   big_endian_writer.WriteU32(ssrc_);  // Add the media (received RTP) SSRC.
   big_endian_writer.WriteU32(dlrr.last_rr);
   big_endian_writer.WriteU32(dlrr.delay_since_last_rr);
+  return true;
 }
 
-void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
+bool RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
                                  Packet* packet) const {
   DCHECK(packet);
   size_t start_size = packet->size();
   size_t remaining_space = kMaxIpPacketSize - start_size;
-  DCHECK_GE(remaining_space, kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
-       << "Not enough buffer space";
-  if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize)
-    return;
+  if (remaining_space < kRtcpCastLogHeaderSize + kRtcpSenderFrameLogSize) {
+    DLOG(FATAL) << "Not enough buffer space";
+    return false;
+  }
 
   size_t space_for_x_messages =
       (remaining_space - kRtcpCastLogHeaderSize) / kRtcpSenderFrameLogSize;
@@ -216,7 +227,7 @@ void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
   big_endian_writer.WriteU32(ssrc_);  // Add our own SSRC.
   big_endian_writer.WriteU32(kCast);
 
-  std::list<RtcpSenderFrameLogMessage>::const_iterator it =
+  std::vector<RtcpSenderFrameLogMessage>::const_iterator it =
       sender_log_message.begin();
   for (; number_of_messages > 0; --number_of_messages) {
     DCHECK(!sender_log_message.empty());
@@ -228,6 +239,7 @@ void RtcpBuilder::BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
     big_endian_writer.WriteU8(static_cast<uint8>(message.rtp_timestamp));
     ++it;
   }
+  return true;
 }
 
 }  // namespace transport
diff --git a/media/cast/transport/rtcp/rtcp_builder.h b/media/cast/transport/rtcp/rtcp_builder.h
index bcc45df..c56ee61 100644
--- a/media/cast/transport/rtcp/rtcp_builder.h
+++ b/media/cast/transport/rtcp/rtcp_builder.h
@@ -47,16 +47,12 @@ class RtcpBuilder {
   };
 
  private:
-  void BuildSR(const RtcpSenderInfo& sender_info,
-               Packet* packet) const;
-
-  void BuildSdec(Packet* packet) const;
-
-  void BuildBye(Packet* packet) const;
-
-  void BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
+  bool BuildSR(const RtcpSenderInfo& sender_info, Packet* packet) const;
+  bool BuildSdec(Packet* packet) const;
+  bool BuildBye(Packet* packet) const;
+  bool BuildDlrrRb(const RtcpDlrrReportBlock& dlrr,
                    Packet* packet) const;
-  void BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
+  bool BuildSenderLog(const RtcpSenderLogMessage& sender_log_message,
                       Packet* packet) const;
 
   PacedSender* const transport_;  // Not owned by this class.
diff --git a/media/cast/transport/rtp_sender/rtp_sender.cc b/media/cast/transport/rtp_sender/rtp_sender.cc
index 92ad67c..7bcfbca 100644
--- a/media/cast/transport/rtp_sender/rtp_sender.cc
+++ b/media/cast/transport/rtp_sender/rtp_sender.cc
@@ -134,7 +134,7 @@ void RtpSender::SubscribeRtpStatsCallback(
 void RtpSender::ScheduleNextStatsReport() {
   transport_task_runner_->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RtpSender::RtpStatistics, base::Unretained(this)),
+      base::Bind(&RtpSender::RtpStatistics, base::AsWeakPtr(this)),
       base::TimeDelta::FromMilliseconds(kStatsCallbackIntervalMs));
 }
 
diff --git a/media/cast/transport/rtp_sender/rtp_sender.h b/media/cast/transport/rtp_sender/rtp_sender.h
index 54961de..4fc4957 100644
--- a/media/cast/transport/rtp_sender/rtp_sender.h
+++ b/media/cast/transport/rtp_sender/rtp_sender.h
@@ -13,6 +13,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
+#include "base/memory/weak_ptr.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/transport/cast_transport_defines.h"
@@ -29,7 +30,7 @@ namespace transport {
 // This class handles splitting encoded audio and video frames into packets and
 // add an RTP header to each packet. The sent packets are stored until they are
 // acknowledged by the remote peer or timed out.
-class RtpSender {
+class RtpSender : public base::SupportsWeakPtr<RtpSender>{
  public:
   RtpSender(base::TickClock* clock,
             const CastTransportConfig& config,
diff --git a/media/cast/video_sender/video_sender.cc b/media/cast/video_sender/video_sender.cc
index 7a3d55b..f9057c5 100644
--- a/media/cast/video_sender/video_sender.cc
+++ b/media/cast/video_sender/video_sender.cc
@@ -73,7 +73,7 @@ class LocalRtpVideoSenderStatistics : public RtpSenderStatistics {
     sender_info->send_octet_count = sender_info_.send_octet_count;
   }
 
-  void StoreStatistics(transport::RtcpSenderInfo& sender_info,
+  void StoreStatistics(const transport::RtcpSenderInfo& sender_info,
                        base::TimeTicks time_sent,
                        uint32 rtp_timestamp) {
     sender_info_ = sender_info;