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 c1b700df929ff29a3e9b18a4d9bc53c6c3198cdb..f34fef4a9bcf4d9930bfe7291d59ee1426ab99be 100644
--- a/media/cast/net/cast_transport_sender_impl.cc
+++ b/media/cast/net/cast_transport_sender_impl.cc
@@ -10,71 +10,29 @@
 #include <utility>
 
 #include "base/single_thread_task_runner.h"
-#include "base/values.h"
 #include "build/build_config.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/rtcp/receiver_rtcp_session.h"
 #include "media/cast/net/rtcp/sender_rtcp_session.h"
-#include "media/cast/net/udp_transport.h"
 #include "net/base/net_errors.h"
-#include "net/base/network_interfaces.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
-// See header file for what these mean.
-const char kOptionDscp[] = "DSCP";
-#if defined(OS_WIN)
-const char kOptionDisableNonBlockingIO[] = "disable_non_blocking_io";
-#endif
-const char kOptionPacerTargetBurstSize[] = "pacer_target_burst_size";
-const char kOptionPacerMaxBurstSize[] = "pacer_max_burst_size";
-const char kOptionSendBufferMinSize[] = "send_buffer_min_size";
-const char kOptionWifiDisableScan[] = "disable_wifi_scan";
-const char kOptionWifiMediaStreamingMode[] = "media_streaming_mode";
-
-int LookupOptionWithDefault(const base::DictionaryValue& options,
-                            const std::string& path,
-                            int default_value) {
-  int ret;
-  if (options.GetInteger(path, &ret)) {
-    return ret;
-  } else {
-    return default_value;
-  }
-}
-
-int32_t GetTransportSendBufferSize(const base::DictionaryValue& options) {
-  // Socket send buffer size needs to be at least greater than one burst
-  // size.
-  int32_t max_burst_size =
-      LookupOptionWithDefault(options, kOptionPacerMaxBurstSize,
-                              kMaxBurstSize) *
-      kMaxIpPacketSize;
-  int32_t min_send_buffer_size =
-      LookupOptionWithDefault(options, kOptionSendBufferMinSize, 0);
-  return std::max(max_burst_size, min_send_buffer_size);
-}
 
 }  // 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,
-    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) {
   return scoped_ptr<CastTransportSender>(new CastTransportSenderImpl(
-      net_log, clock, local_end_point, remote_end_point, std::move(options),
-      status_callback, raw_events_callback, raw_events_callback_interval,
-      transport_task_runner.get(), packet_callback, NULL));
+      clock, logging_flush_interval, std::move(client), std::move(transport),
+      transport_task_runner.get()));
 }
 
 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() {
@@ -82,83 +40,38 @@ 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,
-    PacketSender* external_transport)
+    base::TimeDelta logging_flush_interval,
+    scoped_ptr<Client> client,
+    scoped_ptr<PacketSender> transport,
+    const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner)
     : clock_(clock),
-      status_callback_(status_callback),
+      logging_flush_interval_(logging_flush_interval),
+      transport_client_(std::move(client)),
+      transport_(std::move(transport)),
       transport_task_runner_(transport_task_runner),
-      transport_(external_transport
-                     ? nullptr
-                     : new UdpTransport(net_log,
-                                        transport_task_runner,
-                                        local_end_point,
-                                        remote_end_point,
-                                        GetTransportSendBufferSize(*options),
-                                        status_callback)),
-      pacer_(LookupOptionWithDefault(*options,
-                                     kOptionPacerTargetBurstSize,
-                                     kTargetBurstSize),
-             LookupOptionWithDefault(*options,
-                                     kOptionPacerMaxBurstSize,
-                                     kMaxBurstSize),
+      pacer_(kTargetBurstSize,
+             kMaxBurstSize,
              clock,
-             raw_events_callback.is_null() ? nullptr : &recent_packet_events_,
-             external_transport ? external_transport : transport_.get(),
+             logging_flush_interval > base::TimeDelta() ? &recent_packet_events_
+                                                        : nullptr,
+             transport_.get(),
              transport_task_runner),
-      raw_events_callback_(raw_events_callback),
-      raw_events_callback_interval_(raw_events_callback_interval),
       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);
-  }
-  if (transport_) {
-    if (options->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)) {
-      transport_->UseNonBlockingIO();
-    }
-#endif
-    transport_->StartReceiving(
-        base::Bind(&CastTransportSenderImpl::OnReceivedPacket,
-                   base::Unretained(this)));
-    int wifi_options = 0;
-    if (options->HasKey(kOptionWifiDisableScan)) {
-      wifi_options |= net::WIFI_OPTIONS_DISABLE_SCAN;
-    }
-    if (options->HasKey(kOptionWifiMediaStreamingMode)) {
-      wifi_options |= net::WIFI_OPTIONS_MEDIA_STREAMING_MODE;
-    }
-    if (wifi_options) {
-      wifi_options_autoreset_ = net::SetWifiOptions(wifi_options);
-    }
+  DCHECK(clock);

[miu, 2016/01/27 02:18:04]

Since the whole class assumes |transport_client_|, |transport_| and
|transport_task_runner_| are never null, please add null-checking DCHECKs here.

[xjz, 2016/01/30 01:19:26]

Done.

+  if (logging_flush_interval_ > base::TimeDelta()) {
+    transport_task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents,
+                              weak_factory_.GetWeakPtr()),
+        logging_flush_interval_);
   }
+  transport_->StartReceiving(base::Bind(
+      &CastTransportSenderImpl::OnReceivedPacket, base::Unretained(this)));
 }
 
 CastTransportSenderImpl::~CastTransportSenderImpl() {
-  if (transport_) {
-    transport_->StopReceiving();
-  }
+  transport_->StopReceiving();
 }
 
 void CastTransportSenderImpl::InitializeAudio(
@@ -168,7 +81,7 @@ void CastTransportSenderImpl::InitializeAudio(
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send audio with encryption DISABLED.";
   if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
-    status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
+    transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
@@ -177,10 +90,10 @@ 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_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED);
   } else {
     audio_sender_.reset();
-    status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED);
+    transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED);
     return;
   }
 
@@ -192,7 +105,7 @@ void CastTransportSenderImpl::InitializeAudio(
       clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterAudioSsrc(config.ssrc);
   AddValidSsrc(config.feedback_ssrc);
-  status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED);
+  transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED);
 }
 
 void CastTransportSenderImpl::InitializeVideo(
@@ -202,14 +115,14 @@ void CastTransportSenderImpl::InitializeVideo(
   LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty())
       << "Unsafe to send video with encryption DISABLED.";
   if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) {
-    status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED);
+    transport_client_->OnStatusChanged(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_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED);
     return;
   }
 
@@ -221,7 +134,7 @@ void CastTransportSenderImpl::InitializeVideo(
       clock_, &pacer_, config.ssrc, config.feedback_ssrc));
   pacer_.RegisterVideoSsrc(config.ssrc);
   AddValidSsrc(config.feedback_ssrc);
-  status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED);
+  transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED);
 }
 
 namespace {
@@ -327,7 +240,7 @@ PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() {
 }
 
 void CastTransportSenderImpl::SendRawEvents() {
-  DCHECK(!raw_events_callback_.is_null());
+  DCHECK(logging_flush_interval_ > base::TimeDelta());
 
   if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) {
     scoped_ptr<std::vector<FrameEvent>> frame_events(
@@ -336,14 +249,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(std::move(frame_events), std::move(packet_events));
+    transport_client_->OnLoggingEventsReceived(std::move(frame_events),
+                                               std::move(packet_events));
   }
 
   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) {
@@ -369,18 +282,14 @@ bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
       video_rtcp_session_->IncomingRtcpPacket(data, length)) {
     return true;
   }
-  if (packet_callback_.is_null()) {
-    VLOG(1) << "Stale packet received.";
-    return false;
-  }
-  packet_callback_.Run(std::move(packet));
+  transport_client_->ProcessRtpPacket(std::move(packet));
   return true;
 }
 
 void CastTransportSenderImpl::OnReceivedLogMessage(
     EventMediaType media_type,
     const RtcpReceiverLogMessage& log) {
-  if (raw_events_callback_.is_null())
+  if (logging_flush_interval_ <= base::TimeDelta())
     return;
 
   // Add received log messages into our log system.
@@ -460,6 +369,14 @@ void CastTransportSenderImpl::AddValidSsrc(uint32_t ssrc) {
   valid_ssrcs_.insert(ssrc);
 }
 
+PacedSender* CastTransportSenderImpl::GetPacedSender() {
+  return &pacer_;
+}
+
+void CastTransportSenderImpl::SetWifiOptions(int wifi_options) {
+  wifi_options_autoreset_ = net::SetWifiOptions(wifi_options);
+}
+
 // TODO(isheriff): This interface needs clean up.
 // https://crbug.com/569259
 void CastTransportSenderImpl::SendRtcpFromRtpReceiver(