admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor RtpSender to take the sender ID as a constructor argument

Browse Source 
This change also standardizes the RtpSender to a single constructor
and moves the |track| and |stream_ids| arguments to setter methods.

Bug: webrtc:8734
Change-Id: I227a84868a80797f6cc2a1af6eec6d76da8ea159
Reviewed-on: https://webrtc-review.googlesource.com/84248
Commit-Queue: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Reviewed-by: Seth Hampson <shampson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23730}
This commit is contained in:
Steve Anton 2018-06-25 13:03:36 -07:00 committed by Commit Bot
parent d5b8ee1e17
commit 111fdfd732
6 changed files with 56 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ortc/ortcrtpsenderadapter.cc
View File

@ -157,7 +157,7 @@ void OrtcRtpSenderAdapter::CreateInternalSender() {
switch (kind_) {
case cricket::MEDIA_TYPE_AUDIO: {
auto* audio_sender = new AudioRtpSender(
rtp_transport_controller_->worker_thread(), nullptr);
rtp_transport_controller_->worker_thread(), /*id=*/"", nullptr);
auto* voice_channel = rtp_transport_controller_->voice_channel();
RTC_DCHECK(voice_channel);
audio_sender->SetVoiceMediaChannel(voice_channel->media_channel());
@ -165,8 +165,8 @@ void OrtcRtpSenderAdapter::CreateInternalSender() {
break;
}
case cricket::MEDIA_TYPE_VIDEO: {
auto* video_sender =
new VideoRtpSender(rtp_transport_controller_->worker_thread());
auto* video_sender = new VideoRtpSender(
rtp_transport_controller_->worker_thread(), /*id=*/"");
auto* video_channel = rtp_transport_controller_->video_channel();
RTC_DCHECK(video_channel);
video_sender->SetVideoMediaChannel(video_channel->media_channel());

45
pc/peerconnection.cc
View File

@ -1204,7 +1204,8 @@ PeerConnection::AddTrackPlanB(
(track->kind() == MediaStreamTrackInterface::kAudioKind
? cricket::MEDIA_TYPE_AUDIO
: cricket::MEDIA_TYPE_VIDEO);
auto new_sender = CreateSender(media_type, track, adjusted_stream_ids);
auto new_sender =
CreateSender(media_type, track->id(), track, adjusted_stream_ids);
if (track->kind() == MediaStreamTrackInterface::kAudioKind) {
new_sender->internal()->SetVoiceMediaChannel(voice_media_channel());
GetAudioTransceiver()->internal()->AddSender(new_sender);
@ -1253,7 +1254,7 @@ PeerConnection::AddTrackUnifiedPlan(
: cricket::MEDIA_TYPE_VIDEO);
RTC_LOG(LS_INFO) << "Adding " << cricket::MediaTypeToString(media_type)
<< " transceiver in response to a call to AddTrack.";
auto sender = CreateSender(media_type, track, stream_ids);
auto sender = CreateSender(media_type, track->id(), track, stream_ids);
auto receiver = CreateReceiver(media_type, rtc::CreateRandomUuid());
transceiver = CreateAndAddTransceiver(sender, receiver);
transceiver->internal()->set_created_by_addtrack(true);
@ -1398,7 +1399,9 @@ PeerConnection::AddTransceiver(
RTC_LOG(LS_INFO) << "Adding " << cricket::MediaTypeToString(media_type)
<< " transceiver in response to a call to AddTransceiver.";
auto sender = CreateSender(media_type, track, init.stream_ids);
auto sender =
CreateSender(media_type, (track ? track->id() : rtc::CreateRandomUuid()),
track, init.stream_ids);
auto receiver = CreateReceiver(media_type, rtc::CreateRandomUuid());
auto transceiver = CreateAndAddTransceiver(sender, receiver);
transceiver->internal()->set_direction(init.direction);
@ -1413,6 +1416,7 @@ PeerConnection::AddTransceiver(
rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
PeerConnection::CreateSender(
cricket::MediaType media_type,
const std::string& id,
rtc::scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids) {
rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender;
@ -1421,21 +1425,19 @@ PeerConnection::CreateSender(
(track->kind() == MediaStreamTrackInterface::kAudioKind));
sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
signaling_thread(),
new AudioRtpSender(worker_thread(),
static_cast<AudioTrackInterface*>(track.get()),
stream_ids, stats_.get()));
new AudioRtpSender(worker_thread(), id, stats_.get()));
NoteUsageEvent(UsageEvent::AUDIO_ADDED);
} else {
RTC_DCHECK_EQ(media_type, cricket::MEDIA_TYPE_VIDEO);
RTC_DCHECK(!track ||
(track->kind() == MediaStreamTrackInterface::kVideoKind));
sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
signaling_thread(),
new VideoRtpSender(worker_thread(),
static_cast<VideoTrackInterface*>(track.get()),
stream_ids));
signaling_thread(), new VideoRtpSender(worker_thread(), id));
NoteUsageEvent(UsageEvent::VIDEO_ADDED);
}
bool set_track_succeeded = sender->SetTrack(track);
RTC_DCHECK(set_track_succeeded);
sender->internal()->set_stream_ids(stream_ids);
return sender;
}
@ -1504,15 +1506,15 @@ rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
// TODO(steveanton): Move construction of the RtpSenders to RtpTransceiver.
rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> new_sender;
if (kind == MediaStreamTrackInterface::kAudioKind) {
auto* audio_sender =
new AudioRtpSender(worker_thread(), nullptr, stream_ids, stats_.get());
auto* audio_sender = new AudioRtpSender(
worker_thread(), rtc::CreateRandomUuid(), stats_.get());
audio_sender->SetVoiceMediaChannel(voice_media_channel());
new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
signaling_thread(), audio_sender);
GetAudioTransceiver()->internal()->AddSender(new_sender);
} else if (kind == MediaStreamTrackInterface::kVideoKind) {
auto* video_sender =
new VideoRtpSender(worker_thread(), nullptr, stream_ids);
new VideoRtpSender(worker_thread(), rtc::CreateRandomUuid());
video_sender->SetVideoMediaChannel(video_media_channel());
new_sender = RtpSenderProxyWithInternal<RtpSenderInternal>::Create(
signaling_thread(), video_sender);
@ -1521,6 +1523,7 @@ rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
RTC_LOG(LS_ERROR) << "CreateSender called with invalid kind: " << kind;
return nullptr;
}
new_sender->internal()->set_stream_ids(stream_ids);
return new_sender;
}
@ -2735,8 +2738,10 @@ PeerConnection::AssociateTransceiver(cricket::ContentSource source,
<< " transceiver for MID=" << content.name
<< " at i=" << mline_index
<< " in response to the remote description.";
std::string sender_id = rtc::CreateRandomUuid();
std::vector<std::string> stream_ids = {rtc::CreateRandomUuid()};
auto sender =
CreateSender(media_desc->type(), nullptr, {rtc::CreateRandomUuid()});
CreateSender(media_desc->type(), sender_id, nullptr, stream_ids);
std::string receiver_id;
if (!media_desc->streams().empty()) {
receiver_id = media_desc->streams()[0].id;
@ -3392,6 +3397,8 @@ rtc::scoped_refptr<RtpReceiverInterface> PeerConnection::RemoveAndStopReceiver(
void PeerConnection::AddAudioTrack(AudioTrackInterface* track,
MediaStreamInterface* stream) {
RTC_DCHECK(!IsClosed());
RTC_DCHECK(track);
RTC_DCHECK(stream);
auto sender = FindSenderForTrack(track);
if (sender) {
// We already have a sender for this track, so just change the stream_id
@ -3401,8 +3408,8 @@ void PeerConnection::AddAudioTrack(AudioTrackInterface* track,
}
// Normal case; we've never seen this track before.
auto new_sender =
CreateSender(cricket::MEDIA_TYPE_AUDIO, track, {stream->id()});
auto new_sender = CreateSender(cricket::MEDIA_TYPE_AUDIO, track->id(), track,
{stream->id()});
new_sender->internal()->SetVoiceMediaChannel(voice_media_channel());
GetAudioTransceiver()->internal()->AddSender(new_sender);
// If the sender has already been configured in SDP, we call SetSsrc,
@ -3435,6 +3442,8 @@ void PeerConnection::RemoveAudioTrack(AudioTrackInterface* track,
void PeerConnection::AddVideoTrack(VideoTrackInterface* track,
MediaStreamInterface* stream) {
RTC_DCHECK(!IsClosed());
RTC_DCHECK(track);
RTC_DCHECK(stream);
auto sender = FindSenderForTrack(track);
if (sender) {
// We already have a sender for this track, so just change the stream_id
@ -3444,8 +3453,8 @@ void PeerConnection::AddVideoTrack(VideoTrackInterface* track,
}
// Normal case; we've never seen this track before.
auto new_sender =
CreateSender(cricket::MEDIA_TYPE_VIDEO, track, {stream->id()});
auto new_sender = CreateSender(cricket::MEDIA_TYPE_VIDEO, track->id(), track,
{stream->id()});
new_sender->internal()->SetVideoMediaChannel(video_media_channel());
GetVideoTransceiver()->internal()->AddSender(new_sender);
const RtpSenderInfo* sender_info =

1
pc/peerconnection.h
View File

@ -364,6 +364,7 @@ class PeerConnection : public PeerConnectionInternal,
rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
CreateSender(cricket::MediaType media_type,
const std::string& id,
rtc::scoped_refptr<MediaStreamTrackInterface> track,
const std::vector<std::string>& stream_ids);

42
pc/rtpsender.cc
View File

@ -114,30 +114,16 @@ void LocalAudioSinkAdapter::SetSink(cricket::AudioSource::Sink* sink) {
}
AudioRtpSender::AudioRtpSender(rtc::Thread* worker_thread,
StatsCollector* stats)
: AudioRtpSender(worker_thread, nullptr, {rtc::CreateRandomUuid()}, stats) {
}
AudioRtpSender::AudioRtpSender(rtc::Thread* worker_thread,
rtc::scoped_refptr<AudioTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::string& id,
StatsCollector* stats)
: worker_thread_(worker_thread),
id_(track ? track->id() : rtc::CreateRandomUuid()),
stream_ids_(stream_ids),
id_(id),
stats_(stats),
track_(track),
dtmf_sender_proxy_(DtmfSenderProxy::Create(
rtc::Thread::Current(),
DtmfSender::Create(rtc::Thread::Current(), this))),
cached_track_enabled_(track ? track->enabled() : false),
sink_adapter_(new LocalAudioSinkAdapter()),
attachment_id_(track ? GenerateUniqueId() : 0) {
sink_adapter_(new LocalAudioSinkAdapter()) {
RTC_DCHECK(worker_thread);
if (track_) {
track_->RegisterObserver(this);
track_->AddSink(sink_adapter_.get());
}
}
AudioRtpSender::~AudioRtpSender() {
@ -238,7 +224,7 @@ bool AudioRtpSender::SetTrack(MediaStreamTrackInterface* track) {
} else if (prev_can_send_track) {
ClearAudioSend();
}
attachment_id_ = GenerateUniqueId();
attachment_id_ = (track_ ? GenerateUniqueId() : 0);
return true;
}
@ -377,24 +363,10 @@ void AudioRtpSender::ClearAudioSend() {
}
}
VideoRtpSender::VideoRtpSender(rtc::Thread* worker_thread)
: VideoRtpSender(worker_thread, nullptr, {rtc::CreateRandomUuid()}) {}
VideoRtpSender::VideoRtpSender(rtc::Thread* worker_thread,
rtc::scoped_refptr<VideoTrackInterface> track,
const std::vector<std::string>& stream_ids)
: worker_thread_(worker_thread),
id_(track ? track->id() : rtc::CreateRandomUuid()),
stream_ids_(stream_ids),
track_(track),
cached_track_content_hint_(track
? track->content_hint()
: VideoTrackInterface::ContentHint::kNone),
attachment_id_(track ? GenerateUniqueId() : 0) {
const std::string& id)
: worker_thread_(worker_thread), id_(id) {
RTC_DCHECK(worker_thread);
if (track_) {
track_->RegisterObserver(this);
}
}
VideoRtpSender::~VideoRtpSender() {
@ -447,7 +419,7 @@ bool VideoRtpSender::SetTrack(MediaStreamTrackInterface* track) {
} else if (prev_can_send_track) {
ClearVideoSend();
}
attachment_id_ = GenerateUniqueId();
attachment_id_ = (track_ ? GenerateUniqueId() : 0);
return true;
}

25
pc/rtpsender.h
View File

@ -90,15 +90,10 @@ class AudioRtpSender : public DtmfProviderInterface,
// StatsCollector provided so that Add/RemoveLocalAudioTrack can be called
// at the appropriate times.
// Construct an AudioRtpSender with a null track, a single, randomly generated
// stream id, and a randomly generated ID.
AudioRtpSender(rtc::Thread* worker_thread, StatsCollector* stats);
// Construct an AudioRtpSender with the given track and stream ids. The
// sender ID will be set to the track's ID.
// Construct an RtpSender for audio with the given sender ID.
// The sender is initialized with no track to send and no associated streams.
AudioRtpSender(rtc::Thread* worker_thread,
rtc::scoped_refptr<AudioTrackInterface> track,
const std::vector<std::string>& stream_ids,
const std::string& id,
StatsCollector* stats);
virtual ~AudioRtpSender();
@ -168,7 +163,7 @@ class AudioRtpSender : public DtmfProviderInterface,
const std::string id_;
std::vector<std::string> stream_ids_;
cricket::VoiceMediaChannel* media_channel_ = nullptr;
StatsCollector* stats_;
StatsCollector* stats_ = nullptr;
rtc::scoped_refptr<AudioTrackInterface> track_;
rtc::scoped_refptr<DtmfSenderInterface> dtmf_sender_proxy_;
absl::optional<std::string> last_transaction_id_;
@ -185,15 +180,9 @@ class AudioRtpSender : public DtmfProviderInterface,
class VideoRtpSender : public ObserverInterface,
public rtc::RefCountedObject<RtpSenderInternal> {
public:
// Construct a VideoRtpSender with a null track, a single, randomly generated
// stream id, and a randomly generated ID.
explicit VideoRtpSender(rtc::Thread* worker_thread);
// Construct a VideoRtpSender with the given track and stream ids. The
// sender ID will be set to the track's ID.
VideoRtpSender(rtc::Thread* worker_thread,
rtc::scoped_refptr<VideoTrackInterface> track,
const std::vector<std::string>& stream_ids);
// Construct an RtpSender for video with the given sender ID.
// The sender is initialized with no track to send and no associated streams.
VideoRtpSender(rtc::Thread* worker_thread, const std::string& id);
virtual ~VideoRtpSender();

21
pc/rtpsenderreceiver_unittest.cc
View File

@ -147,8 +147,9 @@ class RtpSenderReceiverTest : public testing::Test,
audio_track_ = AudioTrack::Create(kAudioTrackId, source);
EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
audio_rtp_sender_ =
new AudioRtpSender(worker_thread_, local_stream_->GetAudioTracks()[0],
{local_stream_->id()}, nullptr);
new AudioRtpSender(worker_thread_, audio_track_->id(), nullptr);
ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_));
audio_rtp_sender_->set_stream_ids({local_stream_->id()});
audio_rtp_sender_->SetVoiceMediaChannel(voice_media_channel_);
audio_rtp_sender_->SetSsrc(kAudioSsrc);
audio_rtp_sender_->GetOnDestroyedSignal()->connect(
@ -157,7 +158,7 @@ class RtpSenderReceiverTest : public testing::Test,
}
void CreateAudioRtpSenderWithNoTrack() {
audio_rtp_sender_ = new AudioRtpSender(worker_thread_, nullptr);
audio_rtp_sender_ = new AudioRtpSender(worker_thread_, /*id=*/"", nullptr);
audio_rtp_sender_->SetVoiceMediaChannel(voice_media_channel_);
}
@ -171,16 +172,16 @@ class RtpSenderReceiverTest : public testing::Test,
void CreateVideoRtpSender(bool is_screencast, uint32_t ssrc = kVideoSsrc) {
AddVideoTrack(is_screencast);
video_rtp_sender_ =
new VideoRtpSender(worker_thread_, local_stream_->GetVideoTracks()[0],
{local_stream_->id()});
video_rtp_sender_ = new VideoRtpSender(worker_thread_, video_track_->id());
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_));
video_rtp_sender_->set_stream_ids({local_stream_->id()});
video_rtp_sender_->SetVideoMediaChannel(video_media_channel_);
video_rtp_sender_->SetSsrc(ssrc);
VerifyVideoChannelInput(ssrc);
}
void CreateVideoRtpSenderWithNoTrack() {
video_rtp_sender_ = new VideoRtpSender(worker_thread_);
video_rtp_sender_ = new VideoRtpSender(worker_thread_, /*id=*/"");
video_rtp_sender_->SetVideoMediaChannel(video_media_channel_);
}
@ -1128,9 +1129,9 @@ TEST_F(RtpSenderReceiverTest,
// Setting detailed overrides the default non-screencast mode. This should be
// applied even if the track is set on construction.
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
video_rtp_sender_ =
new VideoRtpSender(worker_thread_, local_stream_->GetVideoTracks()[0],
{local_stream_->id()});
video_rtp_sender_ = new VideoRtpSender(worker_thread_, video_track_->id());
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_));
video_rtp_sender_->set_stream_ids({local_stream_->id()});
video_rtp_sender_->SetVideoMediaChannel(video_media_channel_);
video_track_->set_enabled(true);