Cast: IPC glue between cast library transport and encoders.

chrome/renderer/media/cast_transport_sender_ipc.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 "chrome/renderer/media/cast_transport_sender_ipc.h"
+
+#include "base/callback.h"
+#include "base/id_map.h"
+#include "chrome/common/cast_messages.h"
+#include "chrome/renderer/media/cast_ipc_dispatcher.h"
+#include "ipc/ipc_channel_proxy.h"
+#include "media/cast/cast_sender.h"
+#include "media/cast/transport/cast_transport_sender.h"
+

[acolwell GONE FROM CHROMIUM, 2014/02/13 19:28:58]

nit: I believe this should be inside a namespace.

[hubbe, 2014/02/14 00:03:24]

It was, scherkus said not to, see:

https://codereview.chromium.org/138753004/diff/700001/chrome/renderer/media/c...

+CastTransportSenderIPC::CastTransportSenderIPC(
+    const media::cast::transport::CastTransportConfig& config,
+    const media::cast::transport::CastTransportStatusCallback& status_cb)

[acolwell GONE FROM CHROMIUM, 2014/02/13 19:28:58]

Technically this class doesn't need to know about the dispatcher. If you passed
in a channel_id, a callback for Send, a Closure for remove, and used a
WeakPtrFactory in the dispatcher, this code wouldn't need to know any details
about dispatcher lifetime and the dispatcher would not need to expose public
methods. If a factory method was added to the dispatcher to create these
objects, then the rest of the code wouldn't need to know this class even exists.


I'll leave it up to you if you'd like to make this change. It would provide a
better data hiding like you were trying to achieve before.

[hubbe, 2014/02/14 00:03:24]

I think I'll pass. It doesn't seem to add that much I think.

+    : status_callback_(status_cb) {
+  if (CastIPCDispatcher::Get()) {
+    channel_id_ = CastIPCDispatcher::Get()->AddSender(this);
+  }
+  Send(new CastHostMsg_New(channel_id_, config));
+}
+
+CastTransportSenderIPC::~CastTransportSenderIPC() {
+  Send(new CastHostMsg_Delete(channel_id_));
+  if (CastIPCDispatcher::Get()) {
+    CastIPCDispatcher::Get()->RemoveSender(channel_id_);
+  }
+}
+
+void CastTransportSenderIPC::SetPacketReceiver(
+    const media::cast::transport::PacketReceiverCallback& packet_callback) {
+  packet_callback_ = packet_callback;
+}
+
+void CastTransportSenderIPC::InsertCodedAudioFrame(
+    const media::cast::transport::EncodedAudioFrame* audio_frame,
+    const base::TimeTicks& recorded_time) {
+  Send(new CastHostMsg_InsertCodedAudioFrame(channel_id_,
+                                             *audio_frame,
+                                             recorded_time));
+}
+
+void CastTransportSenderIPC::InsertCodedVideoFrame(
+    const media::cast::transport::EncodedVideoFrame* video_frame,
+    const base::TimeTicks& capture_time) {
+  Send(new CastHostMsg_InsertCodedVideoFrame(channel_id_,
+                                             *video_frame,
+                                             capture_time));
+}
+
+void CastTransportSenderIPC::SendRtcpFromRtpSender(
+    uint32 packet_type_flags,
+    const media::cast::transport::RtcpSenderInfo& sender_info,
+    const media::cast::transport::RtcpDlrrReportBlock& dlrr,
+    const media::cast::transport::RtcpSenderLogMessage& sender_log,
+    uint32 sending_ssrc,
+    const std::string& c_name) {
+  struct media::cast::transport::SendRtcpFromRtpSenderData data;
+  data.packet_type_flags = packet_type_flags;
+  data.sending_ssrc = sending_ssrc;
+  data.c_name = c_name;
+  Send(new CastHostMsg_SendRtcpFromRtpSender(
+      channel_id_,
+      data,
+      sender_info,
+      dlrr,
+      sender_log));
+}
+
+void CastTransportSenderIPC::ResendPackets(
+    bool is_audio,
+    const media::cast::MissingFramesAndPacketsMap& missing_packets) {
+  Send(new CastHostMsg_ResendPackets(channel_id_,
+                                     is_audio,
+                                     missing_packets));
+}
+
+void CastTransportSenderIPC::SubscribeAudioRtpStatsCallback(
+    const media::cast::transport::CastTransportRtpStatistics& callback) {
+  audio_rtp_callback_ = callback;
+}
+
+void CastTransportSenderIPC::SubscribeVideoRtpStatsCallback(
+    const media::cast::transport::CastTransportRtpStatistics& callback) {
+  video_rtp_callback_ = callback;
+}
+
+
+void CastTransportSenderIPC::OnReceivedPacket(
+    const media::cast::Packet& packet) {
+  if (!packet_callback_.is_null()) {
+    // TODO(hubbe): Perhaps an non-ownership-transferring cb here?
+    scoped_ptr<media::cast::transport::Packet> packet_copy(
+        new media::cast::transport::Packet(packet));
+    packet_callback_.Run(packet_copy.Pass());
+  } else {
+    LOG(ERROR) << "CastIPCDispatcher::OnReceivedPacket "
+               << "no packet callback yet.";
+  }
+}
+
+void CastTransportSenderIPC::OnNotifyStatusChange(
+    media::cast::transport::CastTransportStatus status) {
+  status_callback_.Run(status);
+}
+
+void CastTransportSenderIPC::OnRtpStatistics(
+    bool audio,
+    const media::cast::transport::RtcpSenderInfo& sender_info,
+    base::TimeTicks time_sent,
+    uint32 rtp_timestamp) {
+  const media::cast::transport::CastTransportRtpStatistics& callback =
+      audio ? audio_rtp_callback_ : video_rtp_callback_;
+  callback.Run(sender_info, time_sent, rtp_timestamp);
+}
+
+void CastTransportSenderIPC::Send(IPC::Message* message) {
+  if (CastIPCDispatcher::Get()) {
+    CastIPCDispatcher::Get()->Send(message);
+  } else {
+    delete message;
+  }
+}