Source code
Revision control
Copy as Markdown
Other Tools
/*
* 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/sctp_transport.h"
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "api/dtls_transport_interface.h"
#include "api/priority.h"
#include "api/transport/data_channel_transport_interface.h"
#include "media/base/media_channel.h"
#include "p2p/base/fake_dtls_transport.h"
#include "p2p/base/p2p_constants.h"
#include "p2p/base/packet_transport_internal.h"
#include "pc/dtls_transport.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/gunit.h"
#include "test/gmock.h"
#include "test/gtest.h"
constexpr int kDefaultTimeout = 1000; // milliseconds
constexpr int kTestMaxSctpStreams = 1234;
using cricket::FakeDtlsTransport;
using ::testing::ElementsAre;
namespace webrtc {
namespace {
class FakeCricketSctpTransport : public cricket::SctpTransportInternal {
public:
void SetOnConnectedCallback(std::function<void()> callback) override {
on_connected_callback_ = std::move(callback);
}
void SetDataChannelSink(DataChannelSink* sink) override {}
void SetDtlsTransport(rtc::PacketTransportInternal* transport) override {}
bool Start(int local_port, int remote_port, int max_message_size) override {
return true;
}
bool OpenStream(int sid, PriorityValue priority) override { return true; }
bool ResetStream(int sid) override { return true; }
RTCError SendData(int sid,
const SendDataParams& params,
const rtc::CopyOnWriteBuffer& payload) override {
return RTCError::OK();
}
bool ReadyToSendData() override { return true; }
void set_debug_name_for_testing(const char* debug_name) override {}
int max_message_size() const override { return 0; }
absl::optional<int> max_outbound_streams() const override {
return max_outbound_streams_;
}
absl::optional<int> max_inbound_streams() const override {
return max_inbound_streams_;
}
size_t buffered_amount(int sid) const override { return 0; }
size_t buffered_amount_low_threshold(int sid) const override { return 0; }
void SetBufferedAmountLowThreshold(int sid, size_t bytes) override {}
void SendSignalAssociationChangeCommunicationUp() {
ASSERT_TRUE(on_connected_callback_);
on_connected_callback_();
}
void set_max_outbound_streams(int streams) {
max_outbound_streams_ = streams;
}
void set_max_inbound_streams(int streams) { max_inbound_streams_ = streams; }
private:
absl::optional<int> max_outbound_streams_;
absl::optional<int> max_inbound_streams_;
std::function<void()> on_connected_callback_;
};
} // namespace
class TestSctpTransportObserver : public SctpTransportObserverInterface {
public:
TestSctpTransportObserver() : info_(SctpTransportState::kNew) {}
void OnStateChange(SctpTransportInformation info) override {
info_ = info;
states_.push_back(info.state());
}
SctpTransportState State() {
if (states_.size() > 0) {
return states_[states_.size() - 1];
} else {
return SctpTransportState::kNew;
}
}
const std::vector<SctpTransportState>& States() { return states_; }
const SctpTransportInformation LastReceivedInformation() { return info_; }
private:
std::vector<SctpTransportState> states_;
SctpTransportInformation info_;
};
class SctpTransportTest : public ::testing::Test {
public:
SctpTransport* transport() { return transport_.get(); }
SctpTransportObserverInterface* observer() { return &observer_; }
void CreateTransport() {
std::unique_ptr<cricket::DtlsTransportInternal> cricket_transport =
std::make_unique<FakeDtlsTransport>(
"audio", cricket::ICE_CANDIDATE_COMPONENT_RTP);
dtls_transport_ =
rtc::make_ref_counted<DtlsTransport>(std::move(cricket_transport));
auto cricket_sctp_transport =
absl::WrapUnique(new FakeCricketSctpTransport());
transport_ = rtc::make_ref_counted<SctpTransport>(
std::move(cricket_sctp_transport), dtls_transport_);
}
void CompleteSctpHandshake() {
// The computed MaxChannels shall be the minimum of the outgoing
// and incoming # of streams.
CricketSctpTransport()->set_max_outbound_streams(kTestMaxSctpStreams);
CricketSctpTransport()->set_max_inbound_streams(kTestMaxSctpStreams + 1);
CricketSctpTransport()->SendSignalAssociationChangeCommunicationUp();
}
FakeCricketSctpTransport* CricketSctpTransport() {
return static_cast<FakeCricketSctpTransport*>(transport_->internal());
}
rtc::AutoThread main_thread_;
rtc::scoped_refptr<SctpTransport> transport_;
rtc::scoped_refptr<DtlsTransport> dtls_transport_;
TestSctpTransportObserver observer_;
};
TEST(SctpTransportSimpleTest, CreateClearDelete) {
rtc::AutoThread main_thread;
std::unique_ptr<cricket::DtlsTransportInternal> cricket_transport =
std::make_unique<FakeDtlsTransport>("audio",
cricket::ICE_CANDIDATE_COMPONENT_RTP);
rtc::scoped_refptr<DtlsTransport> dtls_transport =
rtc::make_ref_counted<DtlsTransport>(std::move(cricket_transport));
std::unique_ptr<cricket::SctpTransportInternal> fake_cricket_sctp_transport =
absl::WrapUnique(new FakeCricketSctpTransport());
rtc::scoped_refptr<SctpTransport> sctp_transport =
rtc::make_ref_counted<SctpTransport>(
std::move(fake_cricket_sctp_transport), dtls_transport);
ASSERT_TRUE(sctp_transport->internal());
ASSERT_EQ(SctpTransportState::kConnecting,
sctp_transport->Information().state());
sctp_transport->Clear();
ASSERT_FALSE(sctp_transport->internal());
ASSERT_EQ(SctpTransportState::kClosed, sctp_transport->Information().state());
}
TEST_F(SctpTransportTest, EventsObservedWhenConnecting) {
CreateTransport();
transport()->RegisterObserver(observer());
CompleteSctpHandshake();
ASSERT_EQ_WAIT(SctpTransportState::kConnected, observer_.State(),
kDefaultTimeout);
EXPECT_THAT(observer_.States(), ElementsAre(SctpTransportState::kConnected));
}
TEST_F(SctpTransportTest, CloseWhenClearing) {
CreateTransport();
transport()->RegisterObserver(observer());
CompleteSctpHandshake();
ASSERT_EQ_WAIT(SctpTransportState::kConnected, observer_.State(),
kDefaultTimeout);
transport()->Clear();
ASSERT_EQ_WAIT(SctpTransportState::kClosed, observer_.State(),
kDefaultTimeout);
}
TEST_F(SctpTransportTest, MaxChannelsSignalled) {
CreateTransport();
transport()->RegisterObserver(observer());
EXPECT_FALSE(transport()->Information().MaxChannels());
EXPECT_FALSE(observer_.LastReceivedInformation().MaxChannels());
CompleteSctpHandshake();
ASSERT_EQ_WAIT(SctpTransportState::kConnected, observer_.State(),
kDefaultTimeout);
EXPECT_TRUE(transport()->Information().MaxChannels());
EXPECT_EQ(kTestMaxSctpStreams, *(transport()->Information().MaxChannels()));
EXPECT_TRUE(observer_.LastReceivedInformation().MaxChannels());
EXPECT_EQ(kTestMaxSctpStreams,
*(observer_.LastReceivedInformation().MaxChannels()));
}
TEST_F(SctpTransportTest, CloseWhenTransportCloses) {
CreateTransport();
transport()->RegisterObserver(observer());
CompleteSctpHandshake();
ASSERT_EQ_WAIT(SctpTransportState::kConnected, observer_.State(),
kDefaultTimeout);
static_cast<cricket::FakeDtlsTransport*>(dtls_transport_->internal())
->SetDtlsState(DtlsTransportState::kClosed);
ASSERT_EQ_WAIT(SctpTransportState::kClosed, observer_.State(),
kDefaultTimeout);
}
} // namespace webrtc