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

Const-declare some JsepTransport members, and delete always-null members.

Browse Source 
Also delete the CompositeRtpTransport class, since it is never
instantiated.

Locking intentionally left unchanged in this cl, except for removal of
RTC_GUARDED_BY annotations on the now const members.

Bug: None
Change-Id: I99c22ff528ce7a46f71081b98ca83745b8146afc
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/205000
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33165}
This commit is contained in:
Niels Möller 2021-02-01 16:13:42 +01:00 committed by Commit Bot
parent 653d534473
commit c5d4810fbe
6 changed files with 8 additions and 757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pc/BUILD.gn
View File

@ -32,8 +32,6 @@ rtc_library("rtc_pc_base") {
"channel_interface.h",
"channel_manager.cc",
"channel_manager.h",
"composite_rtp_transport.cc",
"composite_rtp_transport.h",
"dtls_srtp_transport.cc",
"dtls_srtp_transport.h",
"dtls_transport.cc",
@ -817,7 +815,6 @@ if (rtc_include_tests && !build_with_chromium) {
sources = [
"channel_manager_unittest.cc",
"channel_unittest.cc",
"composite_rtp_transport_test.cc",
"dtls_srtp_transport_unittest.cc",
"dtls_transport_unittest.cc",
"ice_transport_unittest.cc",

202
pc/composite_rtp_transport.cc
View File

@ -1,202 +0,0 @@
/*
* Copyright 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "pc/composite_rtp_transport.h"
#include <string>
#include <utility>
#include "absl/algorithm/container.h"
#include "p2p/base/packet_transport_internal.h"
#include "rtc_base/checks.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
namespace webrtc {
CompositeRtpTransport::CompositeRtpTransport(
std::vector<RtpTransportInternal*> transports)
: transports_(std::move(transports)) {
RTC_DCHECK(!transports_.empty()) << "Cannot have an empty composite";
std::vector<rtc::PacketTransportInternal*> rtp_transports;
std::vector<rtc::PacketTransportInternal*> rtcp_transports;
for (RtpTransportInternal* transport : transports_) {
RTC_DCHECK_EQ(transport->rtcp_mux_enabled(), rtcp_mux_enabled())
<< "Either all or none of the transports in a composite must enable "
"rtcp mux";
RTC_DCHECK_EQ(transport->transport_name(), transport_name())
<< "All transports in a composite must have the same transport name";
transport->SignalNetworkRouteChanged.connect(
this, &CompositeRtpTransport::OnNetworkRouteChanged);
transport->SignalRtcpPacketReceived.connect(
this, &CompositeRtpTransport::OnRtcpPacketReceived);
}
}
void CompositeRtpTransport::SetSendTransport(
RtpTransportInternal* send_transport) {
if (send_transport_ == send_transport) {
return;
}
RTC_DCHECK(absl::c_linear_search(transports_, send_transport))
<< "Cannot set a send transport that isn't part of the composite";
if (send_transport_) {
send_transport_->SignalReadyToSend.disconnect(this);
send_transport_->SignalWritableState.disconnect(this);
send_transport_->SignalSentPacket.disconnect(this);
}
send_transport_ = send_transport;
send_transport_->SignalReadyToSend.connect(
this, &CompositeRtpTransport::OnReadyToSend);
send_transport_->SignalWritableState.connect(
this, &CompositeRtpTransport::OnWritableState);
send_transport_->SignalSentPacket.connect(
this, &CompositeRtpTransport::OnSentPacket);
SignalWritableState(send_transport_->IsWritable(/*rtcp=*/true) &&
send_transport_->IsWritable(/*rtcp=*/false));
if (send_transport_->IsReadyToSend()) {
SignalReadyToSend(true);
}
}
void CompositeRtpTransport::RemoveTransport(RtpTransportInternal* transport) {
RTC_DCHECK(transport != send_transport_) << "Cannot remove send transport";
auto it = absl::c_find(transports_, transport);
if (it == transports_.end()) {
return;
}
transport->SignalNetworkRouteChanged.disconnect(this);
transport->SignalRtcpPacketReceived.disconnect(this);
for (auto sink : rtp_demuxer_sinks_) {
transport->UnregisterRtpDemuxerSink(sink);
}
transports_.erase(it);
}
const std::string& CompositeRtpTransport::transport_name() const {
return transports_.front()->transport_name();
}
int CompositeRtpTransport::SetRtpOption(rtc::Socket::Option opt, int value) {
int result = 0;
for (auto transport : transports_) {
result |= transport->SetRtpOption(opt, value);
}
return result;
}
int CompositeRtpTransport::SetRtcpOption(rtc::Socket::Option opt, int value) {
int result = 0;
for (auto transport : transports_) {
result |= transport->SetRtcpOption(opt, value);
}
return result;
}
bool CompositeRtpTransport::rtcp_mux_enabled() const {
return transports_.front()->rtcp_mux_enabled();
}
void CompositeRtpTransport::SetRtcpMuxEnabled(bool enabled) {
for (auto transport : transports_) {
transport->SetRtcpMuxEnabled(enabled);
}
}
bool CompositeRtpTransport::IsReadyToSend() const {
return send_transport_ && send_transport_->IsReadyToSend();
}
bool CompositeRtpTransport::IsWritable(bool rtcp) const {
return send_transport_ && send_transport_->IsWritable(rtcp);
}
bool CompositeRtpTransport::SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options,
int flags) {
if (!send_transport_) {
return false;
}
return send_transport_->SendRtpPacket(packet, options, flags);
}
bool CompositeRtpTransport::SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options,
int flags) {
if (!send_transport_) {
return false;
}
return send_transport_->SendRtcpPacket(packet, options, flags);
}
void CompositeRtpTransport::UpdateRtpHeaderExtensionMap(
const cricket::RtpHeaderExtensions& header_extensions) {
for (RtpTransportInternal* transport : transports_) {
transport->UpdateRtpHeaderExtensionMap(header_extensions);
}
}
bool CompositeRtpTransport::IsSrtpActive() const {
bool active = true;
for (RtpTransportInternal* transport : transports_) {
active &= transport->IsSrtpActive();
}
return active;
}
bool CompositeRtpTransport::RegisterRtpDemuxerSink(
const RtpDemuxerCriteria& criteria,
RtpPacketSinkInterface* sink) {
for (RtpTransportInternal* transport : transports_) {
transport->RegisterRtpDemuxerSink(criteria, sink);
}
rtp_demuxer_sinks_.insert(sink);
return true;
}
bool CompositeRtpTransport::UnregisterRtpDemuxerSink(
RtpPacketSinkInterface* sink) {
for (RtpTransportInternal* transport : transports_) {
transport->UnregisterRtpDemuxerSink(sink);
}
rtp_demuxer_sinks_.erase(sink);
return true;
}
void CompositeRtpTransport::OnNetworkRouteChanged(
absl::optional<rtc::NetworkRoute> route) {
SignalNetworkRouteChanged(route);
}
void CompositeRtpTransport::OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
int64_t packet_time_us) {
SignalRtcpPacketReceived(packet, packet_time_us);
}
void CompositeRtpTransport::OnWritableState(bool writable) {
SignalWritableState(writable);
}
void CompositeRtpTransport::OnReadyToSend(bool ready_to_send) {
SignalReadyToSend(ready_to_send);
}
void CompositeRtpTransport::OnSentPacket(const rtc::SentPacket& packet) {
SignalSentPacket(packet);
}
} // namespace webrtc

125
pc/composite_rtp_transport.h
View File

@ -1,125 +0,0 @@
/*
* Copyright 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PC_COMPOSITE_RTP_TRANSPORT_H_
#define PC_COMPOSITE_RTP_TRANSPORT_H_
#include <stdint.h>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "call/rtp_demuxer.h"
#include "call/rtp_packet_sink_interface.h"
#include "pc/rtp_transport_internal.h"
#include "pc/session_description.h"
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/network/sent_packet.h"
#include "rtc_base/network_route.h"
#include "rtc_base/socket.h"
namespace webrtc {
// Composite RTP transport capable of receiving from multiple sub-transports.
//
// CompositeRtpTransport is receive-only until the caller explicitly chooses
// which transport will be used to send and calls |SetSendTransport|. This
// choice must be made as part of the SDP negotiation process, based on receipt
// of a provisional answer. |CompositeRtpTransport| does not become writable or
// ready to send until |SetSendTransport| is called.
//
// When a full answer is received, the user should replace the composite
// transport with the single, chosen RTP transport, then delete the composite
// and all non-chosen transports.
class CompositeRtpTransport : public RtpTransportInternal {
public:
// Constructs a composite out of the given |transports|. |transports| must
// not be empty. All |transports| must outlive the composite.
explicit CompositeRtpTransport(std::vector<RtpTransportInternal*> transports);
// Sets which transport will be used for sending packets. Once called,
// |IsReadyToSend|, |IsWritable|, and the associated signals will reflect the
// state of |send_tranpsort|.
void SetSendTransport(RtpTransportInternal* send_transport);
// Removes |transport| from the composite. No-op if |transport| is null or
// not found in the composite. Removing a transport disconnects all signals
// and RTP demux sinks from that transport. The send transport may not be
// removed.
void RemoveTransport(RtpTransportInternal* transport);
// All transports within a composite must have the same name.
const std::string& transport_name() const override;
int SetRtpOption(rtc::Socket::Option opt, int value) override;
int SetRtcpOption(rtc::Socket::Option opt, int value) override;
// All transports within a composite must either enable or disable RTCP mux.
bool rtcp_mux_enabled() const override;
// Enables or disables RTCP mux for all component transports.
void SetRtcpMuxEnabled(bool enabled) override;
// The composite is ready to send if |send_transport_| is set and ready to
// send.
bool IsReadyToSend() const override;
// The composite is writable if |send_transport_| is set and writable.
bool IsWritable(bool rtcp) const override;
// Sends an RTP packet. May only be called after |send_transport_| is set.
bool SendRtpPacket(rtc::CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options,
int flags) override;
// Sends an RTCP packet. May only be called after |send_transport_| is set.
bool SendRtcpPacket(rtc::CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options,
int flags) override;
// Updates the mapping of RTP header extensions for all component transports.
void UpdateRtpHeaderExtensionMap(
const cricket::RtpHeaderExtensions& header_extensions) override;
// SRTP is only active for a composite if it is active for all component
// transports.
bool IsSrtpActive() const override;
// Registers an RTP demux sink with all component transports.
bool RegisterRtpDemuxerSink(const RtpDemuxerCriteria& criteria,
RtpPacketSinkInterface* sink) override;
bool UnregisterRtpDemuxerSink(RtpPacketSinkInterface* sink) override;
private:
// Receive-side signals.
void OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> route);
void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
int64_t packet_time_us);
// Send-side signals.
void OnWritableState(bool writable);
void OnReadyToSend(bool ready_to_send);
void OnSentPacket(const rtc::SentPacket& packet);
std::vector<RtpTransportInternal*> transports_;
RtpTransportInternal* send_transport_ = nullptr;
// Record of registered RTP demuxer sinks. Used to unregister sinks when a
// transport is removed.
std::set<RtpPacketSinkInterface*> rtp_demuxer_sinks_;
};
} // namespace webrtc
#endif // PC_COMPOSITE_RTP_TRANSPORT_H_

389
pc/composite_rtp_transport_test.cc
View File

@ -1,389 +0,0 @@
/*
* Copyright 2019 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "pc/composite_rtp_transport.h"
#include <memory>
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "p2p/base/fake_packet_transport.h"
#include "pc/rtp_transport.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
constexpr char kTransportName[] = "test-transport";
constexpr char kRtcpTransportName[] = "test-transport-rtcp";
constexpr uint8_t kRtpPayloadType = 100;
constexpr uint8_t kRtcpPacket[] = {0x80, 73, 0, 0};
constexpr uint8_t kRtpPacket[] = {0x80, 100, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
class CompositeRtpTransportTest : public ::testing::Test,
public sigslot::has_slots<>,
public RtpPacketSinkInterface {
public:
CompositeRtpTransportTest()
: packet_transport_1_(
std::make_unique<rtc::FakePacketTransport>(kTransportName)),
packet_transport_2_(
std::make_unique<rtc::FakePacketTransport>(kTransportName)),
rtcp_transport_1_(
std::make_unique<rtc::FakePacketTransport>(kRtcpTransportName)),
rtcp_transport_2_(
std::make_unique<rtc::FakePacketTransport>(kRtcpTransportName)) {}
void SetupRtpTransports(bool rtcp_mux) {
transport_1_ = std::make_unique<RtpTransport>(rtcp_mux);
transport_2_ = std::make_unique<RtpTransport>(rtcp_mux);
transport_1_->SetRtpPacketTransport(packet_transport_1_.get());
transport_2_->SetRtpPacketTransport(packet_transport_2_.get());
if (!rtcp_mux) {
transport_1_->SetRtcpPacketTransport(rtcp_transport_1_.get());
transport_2_->SetRtcpPacketTransport(rtcp_transport_2_.get());
}
composite_ = std::make_unique<CompositeRtpTransport>(
std::vector<RtpTransportInternal*>{transport_1_.get(),
transport_2_.get()});
composite_->SignalReadyToSend.connect(
this, &CompositeRtpTransportTest::OnReadyToSend);
composite_->SignalWritableState.connect(
this, &CompositeRtpTransportTest::OnWritableState);
composite_->SignalSentPacket.connect(
this, &CompositeRtpTransportTest::OnSentPacket);
composite_->SignalNetworkRouteChanged.connect(
this, &CompositeRtpTransportTest::OnNetworkRouteChanged);
composite_->SignalRtcpPacketReceived.connect(
this, &CompositeRtpTransportTest::OnRtcpPacketReceived);
RtpDemuxerCriteria criteria;
criteria.payload_types.insert(kRtpPayloadType);
composite_->RegisterRtpDemuxerSink(criteria, this);
}
void TearDown() override { composite_->UnregisterRtpDemuxerSink(this); }
void OnReadyToSend(bool ready) { ++ready_to_send_count_; }
void OnWritableState(bool writable) { ++writable_state_count_; }
void OnSentPacket(const rtc::SentPacket& packet) { ++sent_packet_count_; }
void OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> route) {
++network_route_count_;
last_network_route_ = route;
}
void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* buffer,
int64_t packet_time_us) {
++rtcp_packet_count_;
last_packet_ = *buffer;
}
void OnRtpPacket(const RtpPacketReceived& packet) {
++rtp_packet_count_;
last_packet_ = packet.Buffer();
}
protected:
std::unique_ptr<rtc::FakePacketTransport> packet_transport_1_;
std::unique_ptr<rtc::FakePacketTransport> packet_transport_2_;
std::unique_ptr<rtc::FakePacketTransport> rtcp_transport_1_;
std::unique_ptr<rtc::FakePacketTransport> rtcp_transport_2_;
std::unique_ptr<RtpTransport> transport_1_;
std::unique_ptr<RtpTransport> transport_2_;
std::unique_ptr<CompositeRtpTransport> composite_;
int ready_to_send_count_ = 0;
int writable_state_count_ = 0;
int sent_packet_count_ = 0;
int network_route_count_ = 0;
int rtcp_packet_count_ = 0;
int rtp_packet_count_ = 0;
absl::optional<rtc::NetworkRoute> last_network_route_;
rtc::CopyOnWriteBuffer last_packet_;
};
TEST_F(CompositeRtpTransportTest, EnableRtcpMux) {
SetupRtpTransports(/*rtcp_mux=*/false);
EXPECT_FALSE(composite_->rtcp_mux_enabled());
EXPECT_FALSE(transport_1_->rtcp_mux_enabled());
EXPECT_FALSE(transport_2_->rtcp_mux_enabled());
composite_->SetRtcpMuxEnabled(true);
EXPECT_TRUE(composite_->rtcp_mux_enabled());
EXPECT_TRUE(transport_1_->rtcp_mux_enabled());
EXPECT_TRUE(transport_2_->rtcp_mux_enabled());
}
TEST_F(CompositeRtpTransportTest, DisableRtcpMux) {
SetupRtpTransports(/*rtcp_mux=*/true);
EXPECT_TRUE(composite_->rtcp_mux_enabled());
EXPECT_TRUE(transport_1_->rtcp_mux_enabled());
EXPECT_TRUE(transport_2_->rtcp_mux_enabled());
// If the component transports didn't have an RTCP transport before, they need
// to be set independently before disabling RTCP mux. There's no other sane
// way to do this, as the interface only allows sending a single RTCP
// transport, and we need one for each component.
transport_1_->SetRtcpPacketTransport(rtcp_transport_1_.get());
transport_2_->SetRtcpPacketTransport(rtcp_transport_2_.get());
composite_->SetRtcpMuxEnabled(false);
EXPECT_FALSE(composite_->rtcp_mux_enabled());
EXPECT_FALSE(transport_1_->rtcp_mux_enabled());
EXPECT_FALSE(transport_2_->rtcp_mux_enabled());
}
TEST_F(CompositeRtpTransportTest, SetRtpOption) {
SetupRtpTransports(/*rtcp_mux=*/true);
EXPECT_EQ(0, composite_->SetRtpOption(rtc::Socket::OPT_DSCP, 2));
int value = 0;
EXPECT_TRUE(packet_transport_1_->GetOption(rtc::Socket::OPT_DSCP, &value));
EXPECT_EQ(value, 2);
EXPECT_TRUE(packet_transport_2_->GetOption(rtc::Socket::OPT_DSCP, &value));
EXPECT_EQ(value, 2);
}
TEST_F(CompositeRtpTransportTest, SetRtcpOption) {
SetupRtpTransports(/*rtcp_mux=*/false);
EXPECT_EQ(0, composite_->SetRtcpOption(rtc::Socket::OPT_DSCP, 2));
int value = 0;
EXPECT_TRUE(rtcp_transport_1_->GetOption(rtc::Socket::OPT_DSCP, &value));
EXPECT_EQ(value, 2);
EXPECT_TRUE(rtcp_transport_2_->GetOption(rtc::Socket::OPT_DSCP, &value));
EXPECT_EQ(value, 2);
}
TEST_F(CompositeRtpTransportTest, NeverWritableWithoutSendTransport) {
SetupRtpTransports(/*rtcp_mux=*/true);
packet_transport_1_->SetWritable(true);
packet_transport_2_->SetWritable(true);
EXPECT_FALSE(composite_->IsWritable(false));
EXPECT_FALSE(composite_->IsWritable(true));
EXPECT_FALSE(composite_->IsReadyToSend());
EXPECT_EQ(0, ready_to_send_count_);
EXPECT_EQ(0, writable_state_count_);
}
TEST_F(CompositeRtpTransportTest, WritableWhenSendTransportBecomesWritable) {
SetupRtpTransports(/*rtcp_mux=*/true);
composite_->SetSendTransport(transport_1_.get());
EXPECT_FALSE(composite_->IsWritable(false));
EXPECT_FALSE(composite_->IsWritable(true));
EXPECT_FALSE(composite_->IsReadyToSend());
EXPECT_EQ(0, ready_to_send_count_);
EXPECT_EQ(1, writable_state_count_);
packet_transport_2_->SetWritable(true);
EXPECT_FALSE(composite_->IsWritable(false));
EXPECT_FALSE(composite_->IsWritable(true));
EXPECT_FALSE(composite_->IsReadyToSend());
EXPECT_EQ(0, ready_to_send_count_);
EXPECT_EQ(1, writable_state_count_);
packet_transport_1_->SetWritable(true);
EXPECT_TRUE(composite_->IsWritable(false));
EXPECT_TRUE(composite_->IsWritable(true));
EXPECT_TRUE(composite_->IsReadyToSend());
EXPECT_EQ(1, ready_to_send_count_);
EXPECT_EQ(2, writable_state_count_);
}
TEST_F(CompositeRtpTransportTest, SendTransportAlreadyWritable) {
SetupRtpTransports(/*rtcp_mux=*/true);
packet_transport_1_->SetWritable(true);
composite_->SetSendTransport(transport_1_.get());
EXPECT_TRUE(composite_->IsWritable(false));
EXPECT_TRUE(composite_->IsWritable(true));
EXPECT_TRUE(composite_->IsReadyToSend());
EXPECT_EQ(1, ready_to_send_count_);
EXPECT_EQ(1, writable_state_count_);
}
TEST_F(CompositeRtpTransportTest, IsSrtpActive) {
SetupRtpTransports(/*rtcp_mux=*/true);
EXPECT_FALSE(composite_->IsSrtpActive());
}
TEST_F(CompositeRtpTransportTest, NetworkRouteChange) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::NetworkRoute route;
route.local = rtc::RouteEndpoint::CreateWithNetworkId(7);
packet_transport_1_->SetNetworkRoute(route);
EXPECT_EQ(1, network_route_count_);
EXPECT_EQ(7, last_network_route_->local.network_id());
route.local = rtc::RouteEndpoint::CreateWithNetworkId(8);
packet_transport_2_->SetNetworkRoute(route);
EXPECT_EQ(2, network_route_count_);
EXPECT_EQ(8, last_network_route_->local.network_id());
}
TEST_F(CompositeRtpTransportTest, RemoveTransport) {
SetupRtpTransports(/*rtcp_mux=*/true);
composite_->RemoveTransport(transport_1_.get());
// Check that signals are disconnected.
rtc::NetworkRoute route;
route.local = rtc::RouteEndpoint::CreateWithNetworkId(7);
packet_transport_1_->SetNetworkRoute(route);
EXPECT_EQ(0, network_route_count_);
}
TEST_F(CompositeRtpTransportTest, SendRtcpBeforeSendTransportSet) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_1_.get(), false);
rtc::CopyOnWriteBuffer packet(kRtcpPacket);
EXPECT_FALSE(composite_->SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
EXPECT_EQ(0, sent_packet_count_);
}
TEST_F(CompositeRtpTransportTest, SendRtcpOn1) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_1_.get(), false);
composite_->SetSendTransport(transport_1_.get());
rtc::CopyOnWriteBuffer packet(kRtcpPacket);
EXPECT_TRUE(composite_->SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
EXPECT_EQ(1, sent_packet_count_);
EXPECT_EQ(packet, *packet_transport_1_->last_sent_packet());
}
TEST_F(CompositeRtpTransportTest, SendRtcpOn2) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_2_.get(), false);
composite_->SetSendTransport(transport_2_.get());
rtc::CopyOnWriteBuffer packet(kRtcpPacket);
EXPECT_TRUE(composite_->SendRtcpPacket(&packet, rtc::PacketOptions(), 0));
EXPECT_EQ(1, sent_packet_count_);
EXPECT_EQ(packet, *packet_transport_2_->last_sent_packet());
}
TEST_F(CompositeRtpTransportTest, SendRtpBeforeSendTransportSet) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_1_.get(), false);
rtc::CopyOnWriteBuffer packet(kRtpPacket);
EXPECT_FALSE(composite_->SendRtpPacket(&packet, rtc::PacketOptions(), 0));
EXPECT_EQ(0, sent_packet_count_);
}
TEST_F(CompositeRtpTransportTest, SendRtpOn1) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_1_.get(), false);
composite_->SetSendTransport(transport_1_.get());
rtc::CopyOnWriteBuffer packet(kRtpPacket);
EXPECT_TRUE(composite_->SendRtpPacket(&packet, rtc::PacketOptions(), 0));
EXPECT_EQ(1, sent_packet_count_);
EXPECT_EQ(packet, *packet_transport_1_->last_sent_packet());
}
TEST_F(CompositeRtpTransportTest, SendRtpOn2) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_2_.get(), false);
composite_->SetSendTransport(transport_2_.get());
rtc::CopyOnWriteBuffer packet(kRtpPacket);
EXPECT_TRUE(composite_->SendRtpPacket(&packet, rtc::PacketOptions(), 0));
EXPECT_EQ(1, sent_packet_count_);
EXPECT_EQ(packet, *packet_transport_2_->last_sent_packet());
}
TEST_F(CompositeRtpTransportTest, ReceiveRtcpFrom1) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_1_.get(), false);
rtc::CopyOnWriteBuffer packet(kRtcpPacket);
remote.SendPacket(packet.cdata<char>(), packet.size(), rtc::PacketOptions(),
0);
EXPECT_EQ(1, rtcp_packet_count_);
EXPECT_EQ(packet, last_packet_);
}
TEST_F(CompositeRtpTransportTest, ReceiveRtcpFrom2) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_2_.get(), false);
rtc::CopyOnWriteBuffer packet(kRtcpPacket);
remote.SendPacket(packet.cdata<char>(), packet.size(), rtc::PacketOptions(),
0);
EXPECT_EQ(1, rtcp_packet_count_);
EXPECT_EQ(packet, last_packet_);
}
TEST_F(CompositeRtpTransportTest, ReceiveRtpFrom1) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_1_.get(), false);
rtc::CopyOnWriteBuffer packet(kRtpPacket);
remote.SendPacket(packet.cdata<char>(), packet.size(), rtc::PacketOptions(),
0);
EXPECT_EQ(1, rtp_packet_count_);
EXPECT_EQ(packet, last_packet_);
}
TEST_F(CompositeRtpTransportTest, ReceiveRtpFrom2) {
SetupRtpTransports(/*rtcp_mux=*/true);
rtc::FakePacketTransport remote("remote");
remote.SetDestination(packet_transport_2_.get(), false);
rtc::CopyOnWriteBuffer packet(kRtpPacket);
remote.SendPacket(packet.cdata<char>(), packet.size(), rtc::PacketOptions(),
0);
EXPECT_EQ(1, rtp_packet_count_);
EXPECT_EQ(packet, last_packet_);
}
} // namespace
} // namespace webrtc

6
pc/jsep_transport.cc
View File

@ -128,12 +128,6 @@ JsepTransport::JsepTransport(
if (sctp_transport_) {
sctp_transport_->SetDtlsTransport(rtp_dtls_transport_);
}
if (datagram_rtp_transport_ && default_rtp_transport()) {
composite_rtp_transport_ = std::make_unique<webrtc::CompositeRtpTransport>(
std::vector<webrtc::RtpTransportInternal*>{
datagram_rtp_transport_.get(), default_rtp_transport()});
}
}
JsepTransport::~JsepTransport() {

40
pc/jsep_transport.h
View File

@ -31,7 +31,6 @@
#include "p2p/base/p2p_constants.h"
#include "p2p/base/transport_description.h"
#include "p2p/base/transport_info.h"
#include "pc/composite_rtp_transport.h"
#include "pc/dtls_srtp_transport.h"
#include "pc/dtls_transport.h"
#include "pc/rtcp_mux_filter.h"
@ -173,13 +172,7 @@ class JsepTransport : public sigslot::has_slots<> {
webrtc::RtpTransportInternal* rtp_transport() const
RTC_LOCKS_EXCLUDED(accessor_lock_) {
webrtc::MutexLock lock(&accessor_lock_);
if (composite_rtp_transport_) {
return composite_rtp_transport_.get();
} else if (datagram_rtp_transport_) {
return datagram_rtp_transport_.get();
} else {
return default_rtp_transport();
}
return default_rtp_transport();
}
const DtlsTransportInternal* rtp_dtls_transport() const
@ -348,31 +341,17 @@ class JsepTransport : public sigslot::has_slots<> {
// To avoid downcasting and make it type safe, keep three unique pointers for
// different SRTP mode and only one of these is non-nullptr.
std::unique_ptr<webrtc::RtpTransport> unencrypted_rtp_transport_
RTC_GUARDED_BY(accessor_lock_);
std::unique_ptr<webrtc::SrtpTransport> sdes_transport_
RTC_GUARDED_BY(accessor_lock_);
std::unique_ptr<webrtc::DtlsSrtpTransport> dtls_srtp_transport_
RTC_GUARDED_BY(accessor_lock_);
const std::unique_ptr<webrtc::RtpTransport> unencrypted_rtp_transport_;
const std::unique_ptr<webrtc::SrtpTransport> sdes_transport_;
const std::unique_ptr<webrtc::DtlsSrtpTransport> dtls_srtp_transport_;
// If multiple RTP transports are in use, |composite_rtp_transport_| will be
// passed to callers. This is only valid for offer-only, receive-only
// scenarios, as it is not possible for the composite to correctly choose
// which transport to use for sending.
std::unique_ptr<webrtc::CompositeRtpTransport> composite_rtp_transport_
RTC_GUARDED_BY(accessor_lock_);
rtc::scoped_refptr<webrtc::DtlsTransport> rtp_dtls_transport_
RTC_GUARDED_BY(accessor_lock_);
const rtc::scoped_refptr<webrtc::DtlsTransport> rtp_dtls_transport_;
rtc::scoped_refptr<webrtc::DtlsTransport> rtcp_dtls_transport_
RTC_GUARDED_BY(accessor_lock_);
rtc::scoped_refptr<webrtc::DtlsTransport> datagram_dtls_transport_
RTC_GUARDED_BY(accessor_lock_);
std::unique_ptr<webrtc::DataChannelTransportInterface>
sctp_data_channel_transport_ RTC_GUARDED_BY(accessor_lock_);
rtc::scoped_refptr<webrtc::SctpTransport> sctp_transport_
RTC_GUARDED_BY(accessor_lock_);
const std::unique_ptr<webrtc::DataChannelTransportInterface>
sctp_data_channel_transport_;
const rtc::scoped_refptr<webrtc::SctpTransport> sctp_transport_;
SrtpFilter sdes_negotiator_ RTC_GUARDED_BY(network_thread_);
RtcpMuxFilter rtcp_mux_negotiator_ RTC_GUARDED_BY(network_thread_);
@ -383,9 +362,6 @@ class JsepTransport : public sigslot::has_slots<> {
absl::optional<std::vector<int>> recv_extension_ids_
RTC_GUARDED_BY(network_thread_);
std::unique_ptr<webrtc::RtpTransportInternal> datagram_rtp_transport_
RTC_GUARDED_BY(accessor_lock_);
RTC_DISALLOW_COPY_AND_ASSIGN(JsepTransport);
};