Simplify interface for media/cast: CastTransportSenderImpl

media/cast/net/cast_transport_sender_impl.cc

Index: media/cast/net/cast_transport_sender_impl.cc
diff --git a/media/cast/net/cast_transport_sender_impl.cc b/media/cast/net/cast_transport_sender_impl.cc
index f4732193e3e7d694b8ef328d8e83b2d54d31368d..13d8c0b11fde06450f4de4544359876ee9fdec84 100644
--- a/media/cast/net/cast_transport_sender_impl.cc
+++ b/media/cast/net/cast_transport_sender_impl.cc
@@ -51,29 +51,32 @@ int32 GetTransportSendBufferSize(const base::DictionaryValue& options) {
 
 }  // namespace
 
-scoped_ptr<CastTransportSender> CastTransportSender::Create(
-    net::NetLog* net_log,
-    base::TickClock* clock,
-    const net::IPEndPoint& local_end_point,
-    const net::IPEndPoint& remote_end_point,
+CastTransportSender::CreateParams::CreateParams(
+    net::NetLog* log,
+    base::TickClock* input_clock,
+    net::IPEndPoint local_addr,
+    net::IPEndPoint remote_addr,
+    Client* transport_client,
+    base::TimeDelta transport_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,
-    const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
+    : net_log(log),
+      clock(input_clock),
+      local_end_point(local_addr),
+      remote_end_point(remote_addr),
+      client(transport_client),
+      logging_flush_interval(transport_logging_flush_interval),
+      optional_config(options.Pass()),
+      transport_task_runner(task_runner) {}
+
+CastTransportSender::CreateParams::~CreateParams() {}
+
+CastTransportSender::Client::~Client() {}
+
+scoped_ptr<CastTransportSender> CastTransportSender::Create(
+    const CreateParams& params) {
   return scoped_ptr<CastTransportSender>(
-      new CastTransportSenderImpl(net_log,
-                                  clock,
-                                  local_end_point,
-                                  remote_end_point,
-                                  options.Pass(),
-                                  status_callback,
-                                  raw_events_callback,
-                                  raw_events_callback_interval,
-                                  transport_task_runner.get(),
-                                  packet_callback,
-                                  NULL));
+      new CastTransportSenderImpl(params, nullptr));
 }
 
 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() {
@@ -81,60 +84,47 @@ PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() {
 }
 
 CastTransportSenderImpl::CastTransportSenderImpl(
-    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 scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner,
-    const PacketReceiverCallback& packet_callback,
+    const CreateParams& params,
     PacketSender* external_transport)
-    : clock_(clock),
-      status_callback_(status_callback),
-      transport_task_runner_(transport_task_runner),
+    : transport_client_(params.client),
+      clock_(params.clock),
+      transport_task_runner_(params.transport_task_runner),
+      logging_flush_interval_(params.logging_flush_interval),
       transport_(external_transport
                      ? nullptr
-                     : new UdpTransport(net_log,
-                                        transport_task_runner,
-                                        local_end_point,
-                                        remote_end_point,
-                                        GetTransportSendBufferSize(*options),
-                                        status_callback)),
-      pacer_(LookupOptionWithDefault(*options,
+                     : new UdpTransport(params,
+                                        GetTransportSendBufferSize(
+                                            *(params.optional_config)))),
+      pacer_(LookupOptionWithDefault(*(params.optional_config),
                                      kOptionPacerTargetBurstSize,
                                      kTargetBurstSize),
-             LookupOptionWithDefault(*options,
+             LookupOptionWithDefault(*(params.optional_config),
                                      kOptionPacerMaxBurstSize,
                                      kMaxBurstSize),
-             clock,
-             raw_events_callback.is_null() ? nullptr : &recent_packet_events_,
+             params.clock,
+             params.logging_flush_interval > base::TimeDelta()
+                 ? &recent_packet_events_
+                 : nullptr,
              external_transport ? external_transport : transport_.get(),
-             transport_task_runner),
-      raw_events_callback_(raw_events_callback),
-      raw_events_callback_interval_(raw_events_callback_interval),
+             params.transport_task_runner),
       last_byte_acked_for_audio_(0),
-      packet_callback_(packet_callback),
       weak_factory_(this) {
-  DCHECK(clock_);
-  if (!raw_events_callback_.is_null()) {
-    DCHECK(raw_events_callback_interval > base::TimeDelta());
-    transport_task_runner->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&CastTransportSenderImpl::SendRawEvents,
-                   weak_factory_.GetWeakPtr()),
-        raw_events_callback_interval);
+  DCHECK(params.clock);
+
+  if (logging_flush_interval_ > base::TimeDelta()) {
+    transport_task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents,
+                              weak_factory_.GetWeakPtr()),
+        logging_flush_interval_);
   }
   if (transport_) {
-    if (options->HasKey(kOptionDscp)) {
+    if (params.optional_config->HasKey(kOptionDscp)) {
       // The default DSCP value for cast is AF41. Which gives it a higher
       // priority over other traffic.
       transport_->SetDscp(net::DSCP_AF41);
     }
 #if defined(OS_WIN)
-    if (!options->HasKey(kOptionDisableNonBlockingIO)) {
+    if (!params.optional_config->HasKey(kOptionDisableNonBlockingIO)) {
       transport_->UseNonBlockingIO();
     }
 #endif
@@ -142,10 +132,10 @@ CastTransportSenderImpl::CastTransportSenderImpl(
         base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
                    base::Unretained(this)));
     int wifi_options = 0;
-    if (options->HasKey(kOptionWifiDisableScan)) {
+    if (params.optional_config->HasKey(kOptionWifiDisableScan)) {
       wifi_options |= net::WIFI_OPTIONS_DISABLE_SCAN;
     }
-    if (options->HasKey(kOptionWifiMediaStreamingMode)) {
+    if (params.optional_config->HasKey(kOptionWifiMediaStreamingMode)) {
       wifi_options |= net::WIFI_OPTIONS_MEDIA_STREAMING_MODE;
     }
     if (wifi_options) {
@@ -166,8 +156,9 @@ void CastTransportSenderImpl::InitializeAudio(
     const RtcpRttCallback& rtt_cb) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send audio with encryption DISABLED.";
+  DCHECK(transport_client_);
   if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
-    status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
+    transport_client_->OnStatusChange(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
@@ -176,27 +167,22 @@ void CastTransportSenderImpl::InitializeAudio(
     // Audio packets have a higher priority.
     pacer_.RegisterAudioSsrc(config.ssrc);
     pacer_.RegisterPrioritySsrc(config.ssrc);
-    status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
+    transport_client_->OnStatusChange(TRANSPORT_AUDIO_INITIALIZED);
   } else {
     audio_sender_.reset();
-    status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
+    transport_client_->OnStatusChange(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
-  audio_rtcp_session_.reset(
-      new Rtcp(base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
-                          weak_factory_.GetWeakPtr(), config.ssrc,
-                          cast_message_cb),
-               rtt_cb,
-               base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
-                          weak_factory_.GetWeakPtr(), AUDIO_EVENT),
-               clock_,
-               &pacer_,
-               config.ssrc,
-               config.feedback_ssrc));
+  audio_rtcp_session_.reset(new Rtcp(
+      base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
+                 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb),
+      rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
+                         weak_factory_.GetWeakPtr(), AUDIO_EVENT),
+      clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterAudioSsrc(config.ssrc);
   AddValidSsrc(config.feedback_ssrc);
-  status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
+  transport_client_->OnStatusChange(TRANSPORT_AUDIO_INITIALIZED);
 }
 
 void CastTransportSenderImpl::InitializeVideo(
@@ -205,32 +191,28 @@ void CastTransportSenderImpl::InitializeVideo(
     const RtcpRttCallback& rtt_cb) {
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send video with encryption DISABLED.";
+  DCHECK(transport_client_);
   if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
-    status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
+    transport_client_->OnStatusChange(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
   video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_));
   if (!video_sender_->Initialize(config)) {
     video_sender_.reset();
-    status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
+    transport_client_->OnStatusChange(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
-  video_rtcp_session_.reset(
-      new Rtcp(base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
-                          weak_factory_.GetWeakPtr(), config.ssrc,
-                          cast_message_cb),
-               rtt_cb,
-               base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
-                          weak_factory_.GetWeakPtr(), VIDEO_EVENT),
-               clock_,
-               &pacer_,
-               config.ssrc,
-               config.feedback_ssrc));
+  video_rtcp_session_.reset(new Rtcp(
+      base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage,
+                 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb),
+      rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage,
+                         weak_factory_.GetWeakPtr(), VIDEO_EVENT),
+      clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterVideoSsrc(config.ssrc);
   AddValidSsrc(config.feedback_ssrc);
-  status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
+  transport_client_->OnStatusChange(TRANSPORT_VIDEO_INITIALIZED);
 }
 
 namespace {
@@ -336,7 +318,7 @@ PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() {
 }
 
 void CastTransportSenderImpl::SendRawEvents() {
-  DCHECK(!raw_events_callback_.is_null());
+  DCHECK(transport_client_ && logging_flush_interval_ > base::TimeDelta());
 
   if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) {
     scoped_ptr<std::vector<FrameEvent>> frame_events(
@@ -345,14 +327,14 @@ void CastTransportSenderImpl::SendRawEvents() {
     scoped_ptr<std::vector<PacketEvent>> packet_events(
         new std::vector<PacketEvent>());
     packet_events->swap(recent_packet_events_);
-    raw_events_callback_.Run(frame_events.Pass(), packet_events.Pass());
+    transport_client_->OnReceivedLoggingEvents(frame_events.Pass(),
+                                               packet_events.Pass());
   }
 
   transport_task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&CastTransportSenderImpl::SendRawEvents,
-                 weak_factory_.GetWeakPtr()),
-      raw_events_callback_interval_);
+      FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents,
+                            weak_factory_.GetWeakPtr()),
+      logging_flush_interval_);
 }
 
 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
@@ -378,18 +360,18 @@ bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
       video_rtcp_session_->IncomingRtcpPacket(data, length)) {
     return true;
   }
-  if (packet_callback_.is_null()) {
+  DCHECK(transport_client_);
+  if (!transport_client_->OnReceivedPackets(packet.Pass())) {
     VLOG(1) << "Stale packet received.";
     return false;
   }
-  packet_callback_.Run(packet.Pass());
   return true;
 }
 
 void CastTransportSenderImpl::OnReceivedLogMessage(
     EventMediaType media_type,
     const RtcpReceiverLogMessage& log) {
-  if (raw_events_callback_.is_null())
+  if ((!transport_client_) || (logging_flush_interval_ == base::TimeDelta()))
     return;
 
   // Add received log messages into our log system.
@@ -477,13 +459,8 @@ void CastTransportSenderImpl::SendRtcpFromRtpReceiver(
     base::TimeDelta target_delay,
     const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
     const RtpReceiverStatistics* rtp_receiver_statistics) {
-  const Rtcp rtcp(RtcpCastMessageCallback(),
-                  RtcpRttCallback(),
-                  RtcpLogMessageCallback(),
-                  clock_,
-                  &pacer_,
-                  ssrc,
-                  sender_ssrc);
+  const Rtcp rtcp(RtcpCastMessageCallback(), RtcpRttCallback(),
+                  RtcpLogMessageCallback(), clock_, &pacer_, ssrc, sender_ssrc);
   rtcp.SendRtcpFromRtpReceiver(time_data,
                                cast_message,
                                target_delay,