Cast: Make receiver use cast_transport

media/cast/net/cast_transport_sender.h

 // 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.
 
 // This is the main interface for the cast transport sender.  It accepts encoded
 // frames (both audio and video), encrypts their encoded data, packetizes them
 // and feeds them into a transport (e.g., UDP).
 
 // Construction of the Cast Sender and the Cast Transport Sender should be done
 // in the following order:
@@ skipping 22 matching lines @@
 namespace base {
 class DictionaryValue;
 }  // namespace base
 
 namespace net {
 class NetLog;
 }  // namespace net
 
 namespace media {
 namespace cast {
+struct RtpReceiverStatistics;
+struct RtcpTimeData;
 
 // Following the initialization of either audio or video an initialization
 // status will be sent via this callback.
 typedef base::Callback<void(CastTransportStatus status)>
     CastTransportStatusCallback;
 
 typedef base::Callback<void(const std::vector<PacketEvent>&,
                             const std::vector<FrameEvent>&)>
     BulkRawEventsCallback;
 
 // The application should only trigger this class from the transport thread.
 class CastTransportSender : public base::NonThreadSafe {
  public:
   static scoped_ptr<CastTransportSender> Create(
       net::NetLog* net_log,
       base::TickClock* clock,
+      const net::IPEndPoint& local_end_point,
       const net::IPEndPoint& remote_end_point,
       scoped_ptr<base::DictionaryValue> options,
       const CastTransportStatusCallback& status_callback,
       const BulkRawEventsCallback& raw_events_callback,
       base::TimeDelta raw_events_callback_interval,
+      const PacketReceiverCallback& packet_callback,
       const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner);
 
   virtual ~CastTransportSender() {}
 
   // Audio/Video initialization.
   // Encoded frames cannot be transmitted until the relevant initialize method
   // is called.
   virtual void InitializeAudio(const CastTransportRtpConfig& config,
                                const RtcpCastMessageCallback& cast_message_cb,
                                const RtcpRttCallback& rtt_cb) = 0;
@@ skipping 19 matching lines @@
   // |frame_ids| contains the IDs of the frames that will be cancelled.
   virtual void CancelSendingFrames(uint32 ssrc,
                                    const std::vector<uint32>& frame_ids) = 0;
 
   // Resends a frame or part of a frame to kickstart. This is used when the
   // stream appears to be stalled.
   virtual void ResendFrameForKickstart(uint32 ssrc, uint32 frame_id) = 0;
 
   // Returns a callback for receiving packets for testing purposes.
   virtual PacketReceiverCallback PacketReceiverForTesting();
+
+  // The following functions are needed for receving.
+

[miu, 2014/12/04 04:18:53]

Were you going to put these methods in a separate CastTransportReceiver
interface?  I think it is important to enforce, for example, that receiver code
doesn't call methods like InitializeAudio/Video(), which are sender-specific.

[hubbe, 2014/12/05 23:57:20]

Originally I was going to, but it seemed to complicate the RPC code quite a bit
which led me to conclude that a common interface was needed.

It's possible to write some interfaces on top of this one that enforces what you
describe, but it would be purely for our own peace of mind.

+  // Add a valid SSRC. This is used to verify that incoming packets
+  // come from the right sender. Without valid SSRCs, the return address cannot
+  // be automatically established.
+  virtual void AddValidSsrc(uint32 ssrc) = 0;
+
+  // Send an RTCP message from receiver to sender.
+  virtual void SendRtcpFromRtpReceiver(
+      uint32 ssrc,
+      uint32 sender_ssrc,
+      const RtcpTimeData& time_data,
+      const RtcpCastMessage* cast_message,
+      base::TimeDelta target_delay,
+      const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
+      const RtpReceiverStatistics* rtp_receiver_statistics) = 0;
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_H_