Simplify interface for media/cast: CastTransportSenderImpl

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 39 matching lines @@
 typedef base::Callback<void(CastTransportStatus status)>
     CastTransportStatusCallback;
 
 typedef base::Callback<void(scoped_ptr<std::vector<FrameEvent>>,
                             scoped_ptr<std::vector<PacketEvent>>)>
     BulkRawEventsCallback;
 
 // The application should only trigger this class from the transport thread.
 class CastTransportSender : public base::NonThreadSafe {
  public:
+  // Interface used for receiving status updates, raw events, and out-of-band

[miu, 2016/01/16 02:28:42]

s/out-of-band incoming/RTP/

See comment below...

[xjz, 2016/01/21 19:16:27]

Done.

+  // incomming packets from CastTransportSender.
+  class Client {
+   public:
+    virtual ~Client(){};
+    // Audio and Video transport status change is reported on this callback.
+    virtual void OnStatusChanged(CastTransportStatus status) = 0;
+
+    // Raw events will be invoked on this callback every
+    // |logging_flush_interval| if it is greater than |base::TimeDelta()|.

[miu, 2016/01/16 02:28:42]

Suggest replacing "every |logging_flush_interval| if it is greater than
|base::TimeDelta()|" with "periodically, according to the configured logging
flush interval passed to CastTransportSender::Create()."

[xjz, 2016/01/21 19:16:27]

Done.

+    virtual void OnLoggingEventsReceived(
+        scoped_ptr<std::vector<FrameEvent>> frame_events,
+        scoped_ptr<std::vector<PacketEvent>> packet_events) = 0;
+
+    // Incoming packets that do not match the channels created by
+    // Initialize{Audio,Video} will report to this callback.
+    virtual void OnPacketsReceived(scoped_ptr<Packet> packet) = 0;

[miu, 2016/01/16 02:28:42]

This is how an RTP packet is delivered.  So, this method should probably be
named HandleRtpPacket() or ProcessRtpPacket().

Also, please adjust the comment accordingly (i.e., just say "Called to pass RTP
packets to the Client" or some such).

FYI--This method only applies for a Cast Receiver.  Unfortunately, the
CastTransportSender class is used for the receiver code too, so it is horribly
mis-named.  http://crbug.com/569259

[xjz, 2016/01/21 19:16:27]

Done. Named it ProcessRtpPacket().

+  };
+
+  // Parameters used to create udp transport.
+  struct UdpTransportParams {
+    UdpTransportParams(net::NetLog* log,  // Owned by the caller.
+                       net::IPEndPoint local_addr,
+                       net::IPEndPoint remote_addr)
+        : net_log(log),
+          local_end_point(local_addr),
+          remote_end_point(remote_addr) {}
+
+    net::NetLog* net_log;
+    net::IPEndPoint local_end_point;
+    net::IPEndPoint remote_end_point;
+  };
+
+  // Parameters to create a cast transport sender / receiver.
+  // |options| contains optional settings for the transport, possible
+  // keys are:
+  //   "DSCP" (value ignored)
+  //       - Turns DSCP on (higher IP Precedence and Type of Service).
+  //   "disable_non_blocking_io" (value ignored)
+  //       - Windows only.  Turns off non-blocking IO for the socket.
+  //         Note: Non-blocking IO is, by default, enabled on all platforms.
+  //   "pacer_target_burst_size": int
+  //        - Specifies how many packets to send per 10 ms ideally.
+  //   "pacer_max_burst_size": int
+  //        - Specifies how many pakcets to send per 10 ms, maximum.
+  //   "send_buffer_min_size": int
+  //        - Specifies the minimum socket send buffer size.
+  //   "disable_wifi_scan" (value ignored)
+  //        - Disable wifi scans while streaming.
+  //   "media_streaming_mode" (value ignored)
+  //        - Turn media streaming mode on.
+  // Note, these options may be ignored on some platforms.
   static scoped_ptr<CastTransportSender> Create(
-      net::NetLog* net_log,
-      base::TickClock* clock,
-      const net::IPEndPoint& local_end_point,
-      const net::IPEndPoint& remote_end_point,
+      base::TickClock* clock,  // Owned by the caller.
+      const UdpTransportParams& upd_transport_params,
+      base::TimeDelta logging_flush_interval,
       scoped_ptr<base::DictionaryValue> options,
-      const CastTransportStatusCallback& status_callback,
-      const BulkRawEventsCallback& raw_events_callback,
-      base::TimeDelta raw_events_callback_interval,
-      const PacketReceiverCallback& packet_callback,
+      scoped_ptr<Client> client,
       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 41 matching lines @@
       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_