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:
 // 1. Create CastTransportSender.
 // 2. Create CastSender (accepts CastTransportSender as an input).
 
 // Destruction: The CastTransportSender is assumed to be valid as long as the
 // CastSender is alive. Therefore the CastSender should be destructed before the
 // CastTransportSender.
 
 #ifndef MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_H_
 #define MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_H_
 
 #include <stdint.h>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/tick_clock.h"
+#include "base/values.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/rtcp/receiver_rtcp_event_subscriber.h"
 #include "media/cast/net/rtcp/rtcp_defines.h"
 #include "net/base/ip_endpoint.h"
 
 namespace base {
 class DictionaryValue;
 }  // namespace base
@@ skipping 12 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 RTP packets
+  // from CastTransportSender.
+  class Client {
+   public:
+    virtual ~Client(){};
+    // Audio and Video transport status change is reported on this callback.

[miu, 2016/02/22 22:38:48]

nit: Add newline above this line.

[xjz, 2016/02/23 21:51:46]

Done.

+    virtual void OnStatusChanged(CastTransportStatus status) = 0;
+
+    // Raw events will be invoked on this callback periodically, according to
+    // the configured logging flush interval passed to
+    // CastTransportSender::Create().
+    virtual void OnLoggingEventsReceived(
+        scoped_ptr<std::vector<FrameEvent>> frame_events,
+        scoped_ptr<std::vector<PacketEvent>> packet_events) = 0;
+
+    // Called to pass RTP packets to the Client.
+    virtual void ProcessRtpPacket(scoped_ptr<Packet> packet) = 0;
+  };
+
   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,
+      base::TickClock* clock,  // Owned by the caller.
+      base::TimeDelta logging_flush_interval,
+      scoped_ptr<Client> client,
+      scoped_ptr<PacketSender> transport,
       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 35 matching lines @@
 
   // Send an RTCP message from receiver to sender.
   virtual void SendRtcpFromRtpReceiver(
       uint32_t ssrc,
       uint32_t 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;
+
+  // Set options for the PacedSender and Wifi.
+  // Possible keys are:

[miu, 2016/02/22 22:38:48]

nit: I'd suggest moving lines 142-153 to cast_transport_sender_impl.h (where the
override of the SetOptions() method is declared) since this information is
specific to that implementation.

[xjz, 2016/02/23 21:51:46]

Done.

+  //   "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.
+  virtual void SetOptions(const base::DictionaryValue& options) = 0;
 };
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_NET_CAST_TRANSPORT_SENDER_H_