Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(377)

Unified Diff: media/cast/net/cast_transport_sender_impl.cc

Issue 1515023002: Simplify interface for media/cast: CastTransportSenderImpl (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: New interface and impl (no tests). Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
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,

Powered by Google App Engine
This is Rietveld 408576698