| Index: webrtc/api/webrtcsession_unittest.cc
|
| diff --git a/webrtc/api/webrtcsession_unittest.cc b/webrtc/api/webrtcsession_unittest.cc
|
| deleted file mode 100644
|
| index 1a7a02622c42c0a9ce5da7faaf00801a9f0970c3..0000000000000000000000000000000000000000
|
| --- a/webrtc/api/webrtcsession_unittest.cc
|
| +++ /dev/null
|
| @@ -1,4451 +0,0 @@
|
| -/*
|
| - * Copyright 2012 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 <memory>
|
| -#include <utility>
|
| -#include <vector>
|
| -
|
| -#include "webrtc/api/audiotrack.h"
|
| -#include "webrtc/api/fakemediacontroller.h"
|
| -#include "webrtc/api/fakemetricsobserver.h"
|
| -#include "webrtc/api/jsepicecandidate.h"
|
| -#include "webrtc/api/jsepsessiondescription.h"
|
| -#include "webrtc/api/peerconnection.h"
|
| -#include "webrtc/api/sctputils.h"
|
| -#include "webrtc/api/test/fakertccertificategenerator.h"
|
| -#include "webrtc/api/videotrack.h"
|
| -#include "webrtc/api/webrtcsession.h"
|
| -#include "webrtc/api/webrtcsessiondescriptionfactory.h"
|
| -#include "webrtc/base/checks.h"
|
| -#include "webrtc/base/fakenetwork.h"
|
| -#include "webrtc/base/firewallsocketserver.h"
|
| -#include "webrtc/base/gunit.h"
|
| -#include "webrtc/base/logging.h"
|
| -#include "webrtc/base/network.h"
|
| -#include "webrtc/base/physicalsocketserver.h"
|
| -#include "webrtc/base/ssladapter.h"
|
| -#include "webrtc/base/sslidentity.h"
|
| -#include "webrtc/base/sslstreamadapter.h"
|
| -#include "webrtc/base/stringutils.h"
|
| -#include "webrtc/base/thread.h"
|
| -#include "webrtc/base/virtualsocketserver.h"
|
| -#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
|
| -#include "webrtc/media/base/fakemediaengine.h"
|
| -#include "webrtc/media/base/fakevideorenderer.h"
|
| -#include "webrtc/media/base/mediachannel.h"
|
| -#include "webrtc/media/engine/fakewebrtccall.h"
|
| -#include "webrtc/media/sctp/sctptransportinternal.h"
|
| -#include "webrtc/p2p/base/packettransportinterface.h"
|
| -#include "webrtc/p2p/base/stunserver.h"
|
| -#include "webrtc/p2p/base/teststunserver.h"
|
| -#include "webrtc/p2p/base/testturnserver.h"
|
| -#include "webrtc/p2p/client/basicportallocator.h"
|
| -#include "webrtc/pc/channelmanager.h"
|
| -#include "webrtc/pc/mediasession.h"
|
| -
|
| -#define MAYBE_SKIP_TEST(feature) \
|
| - if (!(feature())) { \
|
| - LOG(LS_INFO) << "Feature disabled... skipping"; \
|
| - return; \
|
| - }
|
| -
|
| -using cricket::FakeVoiceMediaChannel;
|
| -using cricket::TransportInfo;
|
| -using rtc::SocketAddress;
|
| -using rtc::Thread;
|
| -using webrtc::CreateSessionDescription;
|
| -using webrtc::CreateSessionDescriptionObserver;
|
| -using webrtc::CreateSessionDescriptionRequest;
|
| -using webrtc::DataChannel;
|
| -using webrtc::FakeMetricsObserver;
|
| -using webrtc::IceCandidateCollection;
|
| -using webrtc::InternalDataChannelInit;
|
| -using webrtc::JsepIceCandidate;
|
| -using webrtc::JsepSessionDescription;
|
| -using webrtc::PeerConnectionFactoryInterface;
|
| -using webrtc::PeerConnectionInterface;
|
| -using webrtc::SessionDescriptionInterface;
|
| -using webrtc::SessionStats;
|
| -using webrtc::StreamCollection;
|
| -using webrtc::WebRtcSession;
|
| -using webrtc::kBundleWithoutRtcpMux;
|
| -using webrtc::kCreateChannelFailed;
|
| -using webrtc::kInvalidSdp;
|
| -using webrtc::kMlineMismatch;
|
| -using webrtc::kPushDownTDFailed;
|
| -using webrtc::kSdpWithoutIceUfragPwd;
|
| -using webrtc::kSdpWithoutDtlsFingerprint;
|
| -using webrtc::kSdpWithoutSdesCrypto;
|
| -using webrtc::kSessionError;
|
| -using webrtc::kSessionErrorDesc;
|
| -using webrtc::kMaxUnsignalledRecvStreams;
|
| -
|
| -typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
|
| -
|
| -static const int kClientAddrPort = 0;
|
| -static const char kClientAddrHost1[] = "11.11.11.11";
|
| -static const char kClientIPv6AddrHost1[] =
|
| - "2620:0:aaaa:bbbb:cccc:dddd:eeee:ffff";
|
| -static const char kClientAddrHost2[] = "22.22.22.22";
|
| -static const char kStunAddrHost[] = "99.99.99.1";
|
| -static const SocketAddress kTurnUdpIntAddr("99.99.99.4", 3478);
|
| -static const SocketAddress kTurnUdpExtAddr("99.99.99.6", 0);
|
| -static const char kTurnUsername[] = "test";
|
| -static const char kTurnPassword[] = "test";
|
| -
|
| -static const char kSessionVersion[] = "1";
|
| -
|
| -// Media index of candidates belonging to the first media content.
|
| -static const int kMediaContentIndex0 = 0;
|
| -static const char kMediaContentName0[] = "audio";
|
| -
|
| -// Media index of candidates belonging to the second media content.
|
| -static const int kMediaContentIndex1 = 1;
|
| -static const char kMediaContentName1[] = "video";
|
| -
|
| -static const int kDefaultTimeout = 10000; // 10 seconds.
|
| -static const int kIceCandidatesTimeout = 10000;
|
| -// STUN timeout with all retransmissions is a total of 9500ms.
|
| -static const int kStunTimeout = 9500;
|
| -
|
| -static const char kFakeDtlsFingerprint[] =
|
| - "BB:CD:72:F7:2F:D0:BA:43:F3:68:B1:0C:23:72:B6:4A:"
|
| - "0F:DE:34:06:BC:E0:FE:01:BC:73:C8:6D:F4:65:D5:24";
|
| -
|
| -static const char kTooLongIceUfragPwd[] =
|
| - "IceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfrag"
|
| - "IceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfrag"
|
| - "IceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfrag"
|
| - "IceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfragIceUfrag";
|
| -
|
| -static const char kSdpWithRtx[] =
|
| - "v=0\r\n"
|
| - "o=- 4104004319237231850 2 IN IP4 127.0.0.1\r\n"
|
| - "s=-\r\n"
|
| - "t=0 0\r\n"
|
| - "a=msid-semantic: WMS stream1\r\n"
|
| - "m=video 9 RTP/SAVPF 0 96\r\n"
|
| - "c=IN IP4 0.0.0.0\r\n"
|
| - "a=rtcp:9 IN IP4 0.0.0.0\r\n"
|
| - "a=ice-ufrag:CerjGp19G7wpXwl7\r\n"
|
| - "a=ice-pwd:cMvOlFvQ6ochez1ZOoC2uBEC\r\n"
|
| - "a=mid:video\r\n"
|
| - "a=sendrecv\r\n"
|
| - "a=rtcp-mux\r\n"
|
| - "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
|
| - "inline:5/4N5CDvMiyDArHtBByUM71VIkguH17ZNoX60GrA\r\n"
|
| - "a=rtpmap:0 fake_video_codec/90000\r\n"
|
| - "a=rtpmap:96 rtx/90000\r\n"
|
| - "a=fmtp:96 apt=0\r\n";
|
| -
|
| -static const char kStream1[] = "stream1";
|
| -static const char kVideoTrack1[] = "video1";
|
| -static const char kAudioTrack1[] = "audio1";
|
| -
|
| -static const char kStream2[] = "stream2";
|
| -static const char kVideoTrack2[] = "video2";
|
| -static const char kAudioTrack2[] = "audio2";
|
| -
|
| -enum RTCCertificateGenerationMethod { ALREADY_GENERATED, DTLS_IDENTITY_STORE };
|
| -
|
| -class MockIceObserver : public webrtc::IceObserver {
|
| - public:
|
| - MockIceObserver()
|
| - : oncandidatesready_(false),
|
| - ice_connection_state_(PeerConnectionInterface::kIceConnectionNew),
|
| - ice_gathering_state_(PeerConnectionInterface::kIceGatheringNew) {
|
| - }
|
| -
|
| - virtual ~MockIceObserver() = default;
|
| -
|
| - void OnIceConnectionChange(
|
| - PeerConnectionInterface::IceConnectionState new_state) override {
|
| - ice_connection_state_ = new_state;
|
| - ice_connection_state_history_.push_back(new_state);
|
| - }
|
| - void OnIceGatheringChange(
|
| - PeerConnectionInterface::IceGatheringState new_state) override {
|
| - // We can never transition back to "new".
|
| - EXPECT_NE(PeerConnectionInterface::kIceGatheringNew, new_state);
|
| - ice_gathering_state_ = new_state;
|
| - oncandidatesready_ =
|
| - new_state == PeerConnectionInterface::kIceGatheringComplete;
|
| - }
|
| -
|
| - // Found a new candidate.
|
| - void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
|
| - switch (candidate->sdp_mline_index()) {
|
| - case kMediaContentIndex0:
|
| - mline_0_candidates_.push_back(candidate->candidate());
|
| - break;
|
| - case kMediaContentIndex1:
|
| - mline_1_candidates_.push_back(candidate->candidate());
|
| - break;
|
| - default:
|
| - RTC_NOTREACHED();
|
| - }
|
| -
|
| - // The ICE gathering state should always be Gathering when a candidate is
|
| - // received (or possibly Completed in the case of the final candidate).
|
| - EXPECT_NE(PeerConnectionInterface::kIceGatheringNew, ice_gathering_state_);
|
| - }
|
| -
|
| - // Some local candidates are removed.
|
| - void OnIceCandidatesRemoved(
|
| - const std::vector<cricket::Candidate>& candidates) override {
|
| - num_candidates_removed_ += candidates.size();
|
| - }
|
| -
|
| - bool oncandidatesready_;
|
| - std::vector<cricket::Candidate> mline_0_candidates_;
|
| - std::vector<cricket::Candidate> mline_1_candidates_;
|
| - PeerConnectionInterface::IceConnectionState ice_connection_state_;
|
| - PeerConnectionInterface::IceGatheringState ice_gathering_state_;
|
| - std::vector<PeerConnectionInterface::IceConnectionState>
|
| - ice_connection_state_history_;
|
| - size_t num_candidates_removed_ = 0;
|
| -};
|
| -
|
| -// Used for tests in this file to verify that WebRtcSession responds to signals
|
| -// from the SctpTransport correctly, and calls Start with the correct
|
| -// local/remote ports.
|
| -class FakeSctpTransport : public cricket::SctpTransportInternal {
|
| - public:
|
| - void SetTransportChannel(rtc::PacketTransportInterface* channel) override {}
|
| - bool Start(int local_port, int remote_port) override {
|
| - local_port_ = local_port;
|
| - remote_port_ = remote_port;
|
| - return true;
|
| - }
|
| - bool OpenStream(int sid) override { return true; }
|
| - bool ResetStream(int sid) override { return true; }
|
| - bool SendData(const cricket::SendDataParams& params,
|
| - const rtc::CopyOnWriteBuffer& payload,
|
| - cricket::SendDataResult* result = nullptr) override {
|
| - return true;
|
| - }
|
| - bool ReadyToSendData() override { return true; }
|
| - void set_debug_name_for_testing(const char* debug_name) override {}
|
| -
|
| - int local_port() const { return local_port_; }
|
| - int remote_port() const { return remote_port_; }
|
| -
|
| - private:
|
| - int local_port_ = -1;
|
| - int remote_port_ = -1;
|
| -};
|
| -
|
| -class FakeSctpTransportFactory : public cricket::SctpTransportInternalFactory {
|
| - public:
|
| - std::unique_ptr<cricket::SctpTransportInternal> CreateSctpTransport(
|
| - rtc::PacketTransportInterface*) override {
|
| - last_fake_sctp_transport_ = new FakeSctpTransport();
|
| - return std::unique_ptr<cricket::SctpTransportInternal>(
|
| - last_fake_sctp_transport_);
|
| - }
|
| -
|
| - FakeSctpTransport* last_fake_sctp_transport() {
|
| - return last_fake_sctp_transport_;
|
| - }
|
| -
|
| - private:
|
| - FakeSctpTransport* last_fake_sctp_transport_ = nullptr;
|
| -};
|
| -
|
| -class WebRtcSessionForTest : public webrtc::WebRtcSession {
|
| - public:
|
| - WebRtcSessionForTest(
|
| - webrtc::MediaControllerInterface* media_controller,
|
| - rtc::Thread* network_thread,
|
| - rtc::Thread* worker_thread,
|
| - rtc::Thread* signaling_thread,
|
| - cricket::PortAllocator* port_allocator,
|
| - webrtc::IceObserver* ice_observer,
|
| - std::unique_ptr<cricket::TransportController> transport_controller,
|
| - std::unique_ptr<FakeSctpTransportFactory> sctp_factory)
|
| - : WebRtcSession(media_controller,
|
| - network_thread,
|
| - worker_thread,
|
| - signaling_thread,
|
| - port_allocator,
|
| - std::move(transport_controller),
|
| - std::move(sctp_factory)) {
|
| - RegisterIceObserver(ice_observer);
|
| - }
|
| - virtual ~WebRtcSessionForTest() {}
|
| -
|
| - // Note that these methods are only safe to use if the signaling thread
|
| - // is the same as the worker thread
|
| - rtc::PacketTransportInterface* voice_rtp_transport_channel() {
|
| - return rtp_transport_channel(voice_channel());
|
| - }
|
| -
|
| - rtc::PacketTransportInterface* voice_rtcp_transport_channel() {
|
| - return rtcp_transport_channel(voice_channel());
|
| - }
|
| -
|
| - rtc::PacketTransportInterface* video_rtp_transport_channel() {
|
| - return rtp_transport_channel(video_channel());
|
| - }
|
| -
|
| - rtc::PacketTransportInterface* video_rtcp_transport_channel() {
|
| - return rtcp_transport_channel(video_channel());
|
| - }
|
| -
|
| - private:
|
| - rtc::PacketTransportInterface* rtp_transport_channel(
|
| - cricket::BaseChannel* ch) {
|
| - if (!ch) {
|
| - return nullptr;
|
| - }
|
| - return ch->rtp_dtls_transport();
|
| - }
|
| -
|
| - rtc::PacketTransportInterface* rtcp_transport_channel(
|
| - cricket::BaseChannel* ch) {
|
| - if (!ch) {
|
| - return nullptr;
|
| - }
|
| - return ch->rtcp_dtls_transport();
|
| - }
|
| -};
|
| -
|
| -class WebRtcSessionCreateSDPObserverForTest
|
| - : public rtc::RefCountedObject<CreateSessionDescriptionObserver> {
|
| - public:
|
| - enum State {
|
| - kInit,
|
| - kFailed,
|
| - kSucceeded,
|
| - };
|
| - WebRtcSessionCreateSDPObserverForTest() : state_(kInit) {}
|
| -
|
| - // CreateSessionDescriptionObserver implementation.
|
| - virtual void OnSuccess(SessionDescriptionInterface* desc) {
|
| - description_.reset(desc);
|
| - state_ = kSucceeded;
|
| - }
|
| - virtual void OnFailure(const std::string& error) {
|
| - state_ = kFailed;
|
| - }
|
| -
|
| - SessionDescriptionInterface* description() { return description_.get(); }
|
| -
|
| - SessionDescriptionInterface* ReleaseDescription() {
|
| - return description_.release();
|
| - }
|
| -
|
| - State state() const { return state_; }
|
| -
|
| - protected:
|
| - ~WebRtcSessionCreateSDPObserverForTest() {}
|
| -
|
| - private:
|
| - std::unique_ptr<SessionDescriptionInterface> description_;
|
| - State state_;
|
| -};
|
| -
|
| -class FakeAudioSource : public cricket::AudioSource {
|
| - public:
|
| - FakeAudioSource() : sink_(NULL) {}
|
| - virtual ~FakeAudioSource() {
|
| - if (sink_)
|
| - sink_->OnClose();
|
| - }
|
| -
|
| - void SetSink(Sink* sink) override { sink_ = sink; }
|
| -
|
| - const cricket::AudioSource::Sink* sink() const { return sink_; }
|
| -
|
| - private:
|
| - cricket::AudioSource::Sink* sink_;
|
| -};
|
| -
|
| -class WebRtcSessionTest
|
| - : public testing::TestWithParam<RTCCertificateGenerationMethod>,
|
| - public sigslot::has_slots<> {
|
| - protected:
|
| - // TODO Investigate why ChannelManager crashes, if it's created
|
| - // after stun_server.
|
| - WebRtcSessionTest()
|
| - : media_engine_(new cricket::FakeMediaEngine()),
|
| - data_engine_(new cricket::FakeDataEngine()),
|
| - channel_manager_(new cricket::ChannelManager(media_engine_,
|
| - data_engine_,
|
| - rtc::Thread::Current())),
|
| - fake_call_(webrtc::Call::Config(&event_log_)),
|
| - media_controller_(
|
| - webrtc::MediaControllerInterface::Create(cricket::MediaConfig(),
|
| - rtc::Thread::Current(),
|
| - channel_manager_.get(),
|
| - &event_log_)),
|
| - tdesc_factory_(new cricket::TransportDescriptionFactory()),
|
| - desc_factory_(
|
| - new cricket::MediaSessionDescriptionFactory(channel_manager_.get(),
|
| - tdesc_factory_.get())),
|
| - pss_(new rtc::PhysicalSocketServer),
|
| - vss_(new rtc::VirtualSocketServer(pss_.get())),
|
| - fss_(new rtc::FirewallSocketServer(vss_.get())),
|
| - ss_scope_(fss_.get()),
|
| - stun_socket_addr_(
|
| - rtc::SocketAddress(kStunAddrHost, cricket::STUN_SERVER_PORT)),
|
| - stun_server_(cricket::TestStunServer::Create(Thread::Current(),
|
| - stun_socket_addr_)),
|
| - turn_server_(Thread::Current(), kTurnUdpIntAddr, kTurnUdpExtAddr),
|
| - metrics_observer_(new rtc::RefCountedObject<FakeMetricsObserver>()) {
|
| - cricket::ServerAddresses stun_servers;
|
| - stun_servers.insert(stun_socket_addr_);
|
| - allocator_.reset(new cricket::BasicPortAllocator(
|
| - &network_manager_,
|
| - stun_servers,
|
| - SocketAddress(), SocketAddress(), SocketAddress()));
|
| - allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
|
| - cricket::PORTALLOCATOR_DISABLE_RELAY);
|
| - EXPECT_TRUE(channel_manager_->Init());
|
| - desc_factory_->set_add_legacy_streams(false);
|
| - allocator_->set_step_delay(cricket::kMinimumStepDelay);
|
| - }
|
| -
|
| - void AddInterface(const SocketAddress& addr) {
|
| - network_manager_.AddInterface(addr);
|
| - }
|
| - void RemoveInterface(const SocketAddress& addr) {
|
| - network_manager_.RemoveInterface(addr);
|
| - }
|
| -
|
| - // If |cert_generator| != null or |rtc_configuration| contains |certificates|
|
| - // then DTLS will be enabled unless explicitly disabled by |rtc_configuration|
|
| - // options. When DTLS is enabled a certificate will be used if provided,
|
| - // otherwise one will be generated using the |cert_generator|.
|
| - void Init(
|
| - std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
|
| - PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
|
| - ASSERT_TRUE(session_.get() == NULL);
|
| - fake_sctp_transport_factory_ = new FakeSctpTransportFactory();
|
| - session_.reset(new WebRtcSessionForTest(
|
| - media_controller_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
|
| - rtc::Thread::Current(), allocator_.get(), &observer_,
|
| - std::unique_ptr<cricket::TransportController>(
|
| - new cricket::TransportController(rtc::Thread::Current(),
|
| - rtc::Thread::Current(),
|
| - allocator_.get())),
|
| - std::unique_ptr<FakeSctpTransportFactory>(
|
| - fake_sctp_transport_factory_)));
|
| - session_->SignalDataChannelOpenMessage.connect(
|
| - this, &WebRtcSessionTest::OnDataChannelOpenMessage);
|
| - session_->GetOnDestroyedSignal()->connect(
|
| - this, &WebRtcSessionTest::OnSessionDestroyed);
|
| -
|
| - configuration_.rtcp_mux_policy = rtcp_mux_policy;
|
| - EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
|
| - observer_.ice_connection_state_);
|
| - EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
|
| - observer_.ice_gathering_state_);
|
| -
|
| - EXPECT_TRUE(session_->Initialize(options_, std::move(cert_generator),
|
| - configuration_));
|
| - session_->set_metrics_observer(metrics_observer_);
|
| - }
|
| -
|
| - void OnDataChannelOpenMessage(const std::string& label,
|
| - const InternalDataChannelInit& config) {
|
| - last_data_channel_label_ = label;
|
| - last_data_channel_config_ = config;
|
| - }
|
| -
|
| - void OnSessionDestroyed() { session_destroyed_ = true; }
|
| -
|
| - void Init() {
|
| - Init(nullptr, PeerConnectionInterface::kRtcpMuxPolicyNegotiate);
|
| - }
|
| -
|
| - void Init(PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
|
| - Init(nullptr, rtcp_mux_policy);
|
| - }
|
| -
|
| - void InitWithBundlePolicy(
|
| - PeerConnectionInterface::BundlePolicy bundle_policy) {
|
| - configuration_.bundle_policy = bundle_policy;
|
| - Init();
|
| - }
|
| -
|
| - void InitWithRtcpMuxPolicy(
|
| - PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
|
| - PeerConnectionInterface::RTCConfiguration configuration;
|
| - Init(rtcp_mux_policy);
|
| - }
|
| -
|
| - // Successfully init with DTLS; with a certificate generated and supplied or
|
| - // with a store that generates it for us.
|
| - void InitWithDtls(RTCCertificateGenerationMethod cert_gen_method) {
|
| - std::unique_ptr<FakeRTCCertificateGenerator> cert_generator;
|
| - if (cert_gen_method == ALREADY_GENERATED) {
|
| - configuration_.certificates.push_back(
|
| - FakeRTCCertificateGenerator::GenerateCertificate());
|
| - } else if (cert_gen_method == DTLS_IDENTITY_STORE) {
|
| - cert_generator.reset(new FakeRTCCertificateGenerator());
|
| - cert_generator->set_should_fail(false);
|
| - } else {
|
| - RTC_CHECK(false);
|
| - }
|
| - Init(std::move(cert_generator),
|
| - PeerConnectionInterface::kRtcpMuxPolicyNegotiate);
|
| - }
|
| -
|
| - // Init with DTLS with a store that will fail to generate a certificate.
|
| - void InitWithDtlsIdentityGenFail() {
|
| - std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
|
| - new FakeRTCCertificateGenerator());
|
| - cert_generator->set_should_fail(true);
|
| - Init(std::move(cert_generator),
|
| - PeerConnectionInterface::kRtcpMuxPolicyNegotiate);
|
| - }
|
| -
|
| - void InitWithDtmfCodec() {
|
| - // Add kTelephoneEventCodec for dtmf test.
|
| - const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000,
|
| - 0, 1);
|
| - std::vector<cricket::AudioCodec> codecs;
|
| - codecs.push_back(kTelephoneEventCodec);
|
| - media_engine_->SetAudioCodecs(codecs);
|
| - desc_factory_->set_audio_codecs(codecs, codecs);
|
| - Init();
|
| - }
|
| -
|
| - void InitWithGcm() {
|
| - rtc::CryptoOptions crypto_options;
|
| - crypto_options.enable_gcm_crypto_suites = true;
|
| - channel_manager_->SetCryptoOptions(crypto_options);
|
| - with_gcm_ = true;
|
| - Init();
|
| - }
|
| -
|
| - void SendAudioVideoStream1() {
|
| - send_stream_1_ = true;
|
| - send_stream_2_ = false;
|
| - send_audio_ = true;
|
| - send_video_ = true;
|
| - }
|
| -
|
| - void SendAudioVideoStream2() {
|
| - send_stream_1_ = false;
|
| - send_stream_2_ = true;
|
| - send_audio_ = true;
|
| - send_video_ = true;
|
| - }
|
| -
|
| - void SendAudioVideoStream1And2() {
|
| - send_stream_1_ = true;
|
| - send_stream_2_ = true;
|
| - send_audio_ = true;
|
| - send_video_ = true;
|
| - }
|
| -
|
| - void SendNothing() {
|
| - send_stream_1_ = false;
|
| - send_stream_2_ = false;
|
| - send_audio_ = false;
|
| - send_video_ = false;
|
| - }
|
| -
|
| - void SendAudioOnlyStream2() {
|
| - send_stream_1_ = false;
|
| - send_stream_2_ = true;
|
| - send_audio_ = true;
|
| - send_video_ = false;
|
| - }
|
| -
|
| - void SendVideoOnlyStream2() {
|
| - send_stream_1_ = false;
|
| - send_stream_2_ = true;
|
| - send_audio_ = false;
|
| - send_video_ = true;
|
| - }
|
| -
|
| - void AddStreamsToOptions(cricket::MediaSessionOptions* session_options) {
|
| - if (send_stream_1_ && send_audio_) {
|
| - session_options->AddSendStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack1,
|
| - kStream1);
|
| - }
|
| - if (send_stream_1_ && send_video_) {
|
| - session_options->AddSendStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack1,
|
| - kStream1);
|
| - }
|
| - if (send_stream_2_ && send_audio_) {
|
| - session_options->AddSendStream(cricket::MEDIA_TYPE_AUDIO, kAudioTrack2,
|
| - kStream2);
|
| - }
|
| - if (send_stream_2_ && send_video_) {
|
| - session_options->AddSendStream(cricket::MEDIA_TYPE_VIDEO, kVideoTrack2,
|
| - kStream2);
|
| - }
|
| - if (data_channel_ && session_->data_channel_type() == cricket::DCT_RTP) {
|
| - session_options->AddSendStream(cricket::MEDIA_TYPE_DATA,
|
| - data_channel_->label(),
|
| - data_channel_->label());
|
| - }
|
| - }
|
| -
|
| - void GetOptionsForOffer(
|
| - const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
|
| - cricket::MediaSessionOptions* session_options) {
|
| - ASSERT_TRUE(ExtractMediaSessionOptions(rtc_options, true, session_options));
|
| -
|
| - AddStreamsToOptions(session_options);
|
| - if (rtc_options.offer_to_receive_audio ==
|
| - RTCOfferAnswerOptions::kUndefined) {
|
| - session_options->recv_audio =
|
| - session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO);
|
| - }
|
| - if (rtc_options.offer_to_receive_video ==
|
| - RTCOfferAnswerOptions::kUndefined) {
|
| - session_options->recv_video =
|
| - session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO);
|
| - }
|
| - session_options->bundle_enabled =
|
| - session_options->bundle_enabled &&
|
| - (session_options->has_audio() || session_options->has_video() ||
|
| - session_options->has_data());
|
| -
|
| - if (session_->data_channel_type() == cricket::DCT_SCTP && data_channel_) {
|
| - session_options->data_channel_type = cricket::DCT_SCTP;
|
| - } else if (session_->data_channel_type() == cricket::DCT_QUIC) {
|
| - session_options->data_channel_type = cricket::DCT_QUIC;
|
| - }
|
| -
|
| - if (with_gcm_) {
|
| - session_options->crypto_options.enable_gcm_crypto_suites = true;
|
| - }
|
| - }
|
| -
|
| - void GetOptionsForAnswer(cricket::MediaSessionOptions* session_options) {
|
| - // ParseConstraintsForAnswer is used to set some defaults.
|
| - ASSERT_TRUE(webrtc::ParseConstraintsForAnswer(nullptr, session_options));
|
| -
|
| - AddStreamsToOptions(session_options);
|
| - session_options->bundle_enabled =
|
| - session_options->bundle_enabled &&
|
| - (session_options->has_audio() || session_options->has_video() ||
|
| - session_options->has_data());
|
| -
|
| - if (session_->data_channel_type() != cricket::DCT_RTP) {
|
| - session_options->data_channel_type = session_->data_channel_type();
|
| - }
|
| -
|
| - if (with_gcm_) {
|
| - session_options->crypto_options.enable_gcm_crypto_suites = true;
|
| - }
|
| - }
|
| -
|
| - // Creates a local offer and applies it. Starts ICE.
|
| - // Call SendAudioVideoStreamX() before this function
|
| - // to decide which streams to create.
|
| - void InitiateCall() {
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| - EXPECT_TRUE_WAIT(PeerConnectionInterface::kIceGatheringNew !=
|
| - observer_.ice_gathering_state_,
|
| - kIceCandidatesTimeout);
|
| - }
|
| -
|
| - SessionDescriptionInterface* CreateOffer() {
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.offer_to_receive_audio =
|
| - RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
|
| -
|
| - return CreateOffer(options);
|
| - }
|
| -
|
| - SessionDescriptionInterface* CreateOffer(
|
| - const PeerConnectionInterface::RTCOfferAnswerOptions options) {
|
| - rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
|
| - observer = new WebRtcSessionCreateSDPObserverForTest();
|
| - cricket::MediaSessionOptions session_options;
|
| - GetOptionsForOffer(options, &session_options);
|
| - session_->CreateOffer(observer, options, session_options);
|
| - EXPECT_TRUE_WAIT(
|
| - observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
|
| - 2000);
|
| - return observer->ReleaseDescription();
|
| - }
|
| -
|
| - SessionDescriptionInterface* CreateAnswer(
|
| - const cricket::MediaSessionOptions& options) {
|
| - rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observer
|
| - = new WebRtcSessionCreateSDPObserverForTest();
|
| - cricket::MediaSessionOptions session_options = options;
|
| - GetOptionsForAnswer(&session_options);
|
| - // Overwrite recv_audio and recv_video with passed-in values.
|
| - session_options.recv_video = options.recv_video;
|
| - session_options.recv_audio = options.recv_audio;
|
| - session_->CreateAnswer(observer, session_options);
|
| - EXPECT_TRUE_WAIT(
|
| - observer->state() != WebRtcSessionCreateSDPObserverForTest::kInit,
|
| - 2000);
|
| - return observer->ReleaseDescription();
|
| - }
|
| -
|
| - SessionDescriptionInterface* CreateAnswer() {
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - options.recv_audio = true;
|
| - return CreateAnswer(options);
|
| - }
|
| -
|
| - bool ChannelsExist() const {
|
| - return (session_->voice_channel() != NULL &&
|
| - session_->video_channel() != NULL);
|
| - }
|
| -
|
| - void VerifyCryptoParams(const cricket::SessionDescription* sdp,
|
| - bool gcm_enabled = false) {
|
| - ASSERT_TRUE(session_.get() != NULL);
|
| - const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
|
| - ASSERT_TRUE(content != NULL);
|
| - const cricket::AudioContentDescription* audio_content =
|
| - static_cast<const cricket::AudioContentDescription*>(
|
| - content->description);
|
| - ASSERT_TRUE(audio_content != NULL);
|
| - if (!gcm_enabled) {
|
| - ASSERT_EQ(1U, audio_content->cryptos().size());
|
| - ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
|
| - ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
|
| - audio_content->cryptos()[0].cipher_suite);
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
|
| - audio_content->protocol());
|
| - } else {
|
| - // The offer contains 3 possible crypto suites, the answer 1.
|
| - EXPECT_LE(1U, audio_content->cryptos().size());
|
| - EXPECT_NE(2U, audio_content->cryptos().size());
|
| - EXPECT_GE(3U, audio_content->cryptos().size());
|
| - ASSERT_EQ(67U, audio_content->cryptos()[0].key_params.size());
|
| - ASSERT_EQ("AEAD_AES_256_GCM",
|
| - audio_content->cryptos()[0].cipher_suite);
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
|
| - audio_content->protocol());
|
| - }
|
| -
|
| - content = cricket::GetFirstVideoContent(sdp);
|
| - ASSERT_TRUE(content != NULL);
|
| - const cricket::VideoContentDescription* video_content =
|
| - static_cast<const cricket::VideoContentDescription*>(
|
| - content->description);
|
| - ASSERT_TRUE(video_content != NULL);
|
| - if (!gcm_enabled) {
|
| - ASSERT_EQ(1U, video_content->cryptos().size());
|
| - ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
|
| - video_content->cryptos()[0].cipher_suite);
|
| - ASSERT_EQ(47U, video_content->cryptos()[0].key_params.size());
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
|
| - video_content->protocol());
|
| - } else {
|
| - // The offer contains 3 possible crypto suites, the answer 1.
|
| - EXPECT_LE(1U, video_content->cryptos().size());
|
| - EXPECT_NE(2U, video_content->cryptos().size());
|
| - EXPECT_GE(3U, video_content->cryptos().size());
|
| - ASSERT_EQ("AEAD_AES_256_GCM",
|
| - video_content->cryptos()[0].cipher_suite);
|
| - ASSERT_EQ(67U, video_content->cryptos()[0].key_params.size());
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
|
| - video_content->protocol());
|
| - }
|
| - }
|
| -
|
| - void VerifyNoCryptoParams(const cricket::SessionDescription* sdp, bool dtls) {
|
| - const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
|
| - ASSERT_TRUE(content != NULL);
|
| - const cricket::AudioContentDescription* audio_content =
|
| - static_cast<const cricket::AudioContentDescription*>(
|
| - content->description);
|
| - ASSERT_TRUE(audio_content != NULL);
|
| - ASSERT_EQ(0U, audio_content->cryptos().size());
|
| -
|
| - content = cricket::GetFirstVideoContent(sdp);
|
| - ASSERT_TRUE(content != NULL);
|
| - const cricket::VideoContentDescription* video_content =
|
| - static_cast<const cricket::VideoContentDescription*>(
|
| - content->description);
|
| - ASSERT_TRUE(video_content != NULL);
|
| - ASSERT_EQ(0U, video_content->cryptos().size());
|
| -
|
| - if (dtls) {
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
|
| - audio_content->protocol());
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolDtlsSavpf),
|
| - video_content->protocol());
|
| - } else {
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf),
|
| - audio_content->protocol());
|
| - EXPECT_EQ(std::string(cricket::kMediaProtocolAvpf),
|
| - video_content->protocol());
|
| - }
|
| - }
|
| -
|
| - // Set the internal fake description factories to do DTLS-SRTP.
|
| - void SetFactoryDtlsSrtp() {
|
| - desc_factory_->set_secure(cricket::SEC_DISABLED);
|
| - std::string identity_name = "WebRTC" +
|
| - rtc::ToString(rtc::CreateRandomId());
|
| - // Confirmed to work with KT_RSA and KT_ECDSA.
|
| - tdesc_factory_->set_certificate(
|
| - rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
|
| - rtc::SSLIdentity::Generate(identity_name, rtc::KT_DEFAULT))));
|
| - tdesc_factory_->set_secure(cricket::SEC_REQUIRED);
|
| - }
|
| -
|
| - void VerifyFingerprintStatus(const cricket::SessionDescription* sdp,
|
| - bool expected) {
|
| - const TransportInfo* audio = sdp->GetTransportInfoByName("audio");
|
| - ASSERT_TRUE(audio != NULL);
|
| - ASSERT_EQ(expected, audio->description.identity_fingerprint.get() != NULL);
|
| - const TransportInfo* video = sdp->GetTransportInfoByName("video");
|
| - ASSERT_TRUE(video != NULL);
|
| - ASSERT_EQ(expected, video->description.identity_fingerprint.get() != NULL);
|
| - }
|
| -
|
| - void VerifyAnswerFromNonCryptoOffer() {
|
| - // Create an SDP without Crypto.
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - JsepSessionDescription* offer(
|
| - CreateRemoteOffer(options, cricket::SEC_DISABLED));
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyNoCryptoParams(offer->description(), false);
|
| - SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
|
| - offer);
|
| - const webrtc::SessionDescriptionInterface* answer = CreateAnswer();
|
| - // Answer should be NULL as no crypto params in offer.
|
| - ASSERT_TRUE(answer == NULL);
|
| - }
|
| -
|
| - void VerifyAnswerFromCryptoOffer() {
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - options.bundle_enabled = true;
|
| - std::unique_ptr<JsepSessionDescription> offer(
|
| - CreateRemoteOffer(options, cricket::SEC_REQUIRED));
|
| - ASSERT_TRUE(offer.get() != NULL);
|
| - VerifyCryptoParams(offer->description());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - ASSERT_TRUE(answer.get() != NULL);
|
| - VerifyCryptoParams(answer->description());
|
| - }
|
| -
|
| - bool IceUfragPwdEqual(const cricket::SessionDescription* desc1,
|
| - const cricket::SessionDescription* desc2) {
|
| - if (desc1->contents().size() != desc2->contents().size()) {
|
| - return false;
|
| - }
|
| -
|
| - const cricket::ContentInfos& contents = desc1->contents();
|
| - cricket::ContentInfos::const_iterator it = contents.begin();
|
| -
|
| - for (; it != contents.end(); ++it) {
|
| - const cricket::TransportDescription* transport_desc1 =
|
| - desc1->GetTransportDescriptionByName(it->name);
|
| - const cricket::TransportDescription* transport_desc2 =
|
| - desc2->GetTransportDescriptionByName(it->name);
|
| - if (!transport_desc1 || !transport_desc2) {
|
| - return false;
|
| - }
|
| - if (transport_desc1->ice_pwd != transport_desc2->ice_pwd ||
|
| - transport_desc1->ice_ufrag != transport_desc2->ice_ufrag) {
|
| - return false;
|
| - }
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - // Compares ufrag/password only for the specified |media_type|.
|
| - bool IceUfragPwdEqual(const cricket::SessionDescription* desc1,
|
| - const cricket::SessionDescription* desc2,
|
| - cricket::MediaType media_type) {
|
| - if (desc1->contents().size() != desc2->contents().size()) {
|
| - return false;
|
| - }
|
| -
|
| - const cricket::ContentInfo* cinfo =
|
| - cricket::GetFirstMediaContent(desc1->contents(), media_type);
|
| - const cricket::TransportDescription* transport_desc1 =
|
| - desc1->GetTransportDescriptionByName(cinfo->name);
|
| - const cricket::TransportDescription* transport_desc2 =
|
| - desc2->GetTransportDescriptionByName(cinfo->name);
|
| - if (!transport_desc1 || !transport_desc2) {
|
| - return false;
|
| - }
|
| - if (transport_desc1->ice_pwd != transport_desc2->ice_pwd ||
|
| - transport_desc1->ice_ufrag != transport_desc2->ice_ufrag) {
|
| - return false;
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - void RemoveIceUfragPwdLines(const SessionDescriptionInterface* current_desc,
|
| - std::string *sdp) {
|
| - const cricket::SessionDescription* desc = current_desc->description();
|
| - EXPECT_TRUE(current_desc->ToString(sdp));
|
| -
|
| - const cricket::ContentInfos& contents = desc->contents();
|
| - cricket::ContentInfos::const_iterator it = contents.begin();
|
| - // Replace ufrag and pwd lines with empty strings.
|
| - for (; it != contents.end(); ++it) {
|
| - const cricket::TransportDescription* transport_desc =
|
| - desc->GetTransportDescriptionByName(it->name);
|
| - std::string ufrag_line = "a=ice-ufrag:" + transport_desc->ice_ufrag
|
| - + "\r\n";
|
| - std::string pwd_line = "a=ice-pwd:" + transport_desc->ice_pwd
|
| - + "\r\n";
|
| - rtc::replace_substrs(ufrag_line.c_str(), ufrag_line.length(),
|
| - "", 0,
|
| - sdp);
|
| - rtc::replace_substrs(pwd_line.c_str(), pwd_line.length(),
|
| - "", 0,
|
| - sdp);
|
| - }
|
| - }
|
| -
|
| - void SetIceUfragPwd(SessionDescriptionInterface* current_desc,
|
| - const std::string& ufrag,
|
| - const std::string& pwd) {
|
| - cricket::SessionDescription* desc = current_desc->description();
|
| - for (TransportInfo& transport_info : desc->transport_infos()) {
|
| - cricket::TransportDescription& transport_desc =
|
| - transport_info.description;
|
| - transport_desc.ice_ufrag = ufrag;
|
| - transport_desc.ice_pwd = pwd;
|
| - }
|
| - }
|
| -
|
| - // Sets ufrag/pwd for specified |media_type|.
|
| - void SetIceUfragPwd(SessionDescriptionInterface* current_desc,
|
| - cricket::MediaType media_type,
|
| - const std::string& ufrag,
|
| - const std::string& pwd) {
|
| - cricket::SessionDescription* desc = current_desc->description();
|
| - const cricket::ContentInfo* cinfo =
|
| - cricket::GetFirstMediaContent(desc->contents(), media_type);
|
| - TransportInfo* transport_info = desc->GetTransportInfoByName(cinfo->name);
|
| - cricket::TransportDescription* transport_desc =
|
| - &transport_info->description;
|
| - transport_desc->ice_ufrag = ufrag;
|
| - transport_desc->ice_pwd = pwd;
|
| - }
|
| -
|
| - // Creates a remote offer and and applies it as a remote description,
|
| - // creates a local answer and applies is as a local description.
|
| - // Call SendAudioVideoStreamX() before this function
|
| - // to decide which local and remote streams to create.
|
| - void CreateAndSetRemoteOfferAndLocalAnswer() {
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| - }
|
| - void SetLocalDescriptionWithoutError(SessionDescriptionInterface* desc) {
|
| - EXPECT_TRUE(session_->SetLocalDescription(desc, NULL));
|
| - session_->MaybeStartGathering();
|
| - }
|
| - void SetLocalDescriptionExpectState(SessionDescriptionInterface* desc,
|
| - WebRtcSession::State expected_state) {
|
| - SetLocalDescriptionWithoutError(desc);
|
| - EXPECT_EQ(expected_state, session_->state());
|
| - }
|
| - void SetLocalDescriptionExpectError(const std::string& action,
|
| - const std::string& expected_error,
|
| - SessionDescriptionInterface* desc) {
|
| - std::string error;
|
| - EXPECT_FALSE(session_->SetLocalDescription(desc, &error));
|
| - std::string sdp_type = "local ";
|
| - sdp_type.append(action);
|
| - EXPECT_NE(std::string::npos, error.find(sdp_type));
|
| - EXPECT_NE(std::string::npos, error.find(expected_error));
|
| - }
|
| - void SetLocalDescriptionOfferExpectError(const std::string& expected_error,
|
| - SessionDescriptionInterface* desc) {
|
| - SetLocalDescriptionExpectError(SessionDescriptionInterface::kOffer,
|
| - expected_error, desc);
|
| - }
|
| - void SetLocalDescriptionAnswerExpectError(const std::string& expected_error,
|
| - SessionDescriptionInterface* desc) {
|
| - SetLocalDescriptionExpectError(SessionDescriptionInterface::kAnswer,
|
| - expected_error, desc);
|
| - }
|
| - void SetRemoteDescriptionWithoutError(SessionDescriptionInterface* desc) {
|
| - EXPECT_TRUE(session_->SetRemoteDescription(desc, NULL));
|
| - }
|
| - void SetRemoteDescriptionExpectState(SessionDescriptionInterface* desc,
|
| - WebRtcSession::State expected_state) {
|
| - SetRemoteDescriptionWithoutError(desc);
|
| - EXPECT_EQ(expected_state, session_->state());
|
| - }
|
| - void SetRemoteDescriptionExpectError(const std::string& action,
|
| - const std::string& expected_error,
|
| - SessionDescriptionInterface* desc) {
|
| - std::string error;
|
| - EXPECT_FALSE(session_->SetRemoteDescription(desc, &error));
|
| - std::string sdp_type = "remote ";
|
| - sdp_type.append(action);
|
| - EXPECT_NE(std::string::npos, error.find(sdp_type));
|
| - EXPECT_NE(std::string::npos, error.find(expected_error));
|
| - }
|
| - void SetRemoteDescriptionOfferExpectError(
|
| - const std::string& expected_error, SessionDescriptionInterface* desc) {
|
| - SetRemoteDescriptionExpectError(SessionDescriptionInterface::kOffer,
|
| - expected_error, desc);
|
| - }
|
| - void SetRemoteDescriptionPranswerExpectError(
|
| - const std::string& expected_error, SessionDescriptionInterface* desc) {
|
| - SetRemoteDescriptionExpectError(SessionDescriptionInterface::kPrAnswer,
|
| - expected_error, desc);
|
| - }
|
| - void SetRemoteDescriptionAnswerExpectError(
|
| - const std::string& expected_error, SessionDescriptionInterface* desc) {
|
| - SetRemoteDescriptionExpectError(SessionDescriptionInterface::kAnswer,
|
| - expected_error, desc);
|
| - }
|
| -
|
| - void CreateCryptoOfferAndNonCryptoAnswer(SessionDescriptionInterface** offer,
|
| - SessionDescriptionInterface** nocrypto_answer) {
|
| - // Create a SDP without Crypto.
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - options.bundle_enabled = true;
|
| - *offer = CreateRemoteOffer(options, cricket::SEC_ENABLED);
|
| - ASSERT_TRUE(*offer != NULL);
|
| - VerifyCryptoParams((*offer)->description());
|
| -
|
| - *nocrypto_answer = CreateRemoteAnswer(*offer, options,
|
| - cricket::SEC_DISABLED);
|
| - EXPECT_TRUE(*nocrypto_answer != NULL);
|
| - }
|
| -
|
| - void CreateDtlsOfferAndNonDtlsAnswer(SessionDescriptionInterface** offer,
|
| - SessionDescriptionInterface** nodtls_answer) {
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - options.bundle_enabled = true;
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> temp_offer(
|
| - CreateRemoteOffer(options, cricket::SEC_ENABLED));
|
| -
|
| - *nodtls_answer =
|
| - CreateRemoteAnswer(temp_offer.get(), options, cricket::SEC_ENABLED);
|
| - EXPECT_TRUE(*nodtls_answer != NULL);
|
| - VerifyFingerprintStatus((*nodtls_answer)->description(), false);
|
| - VerifyCryptoParams((*nodtls_answer)->description());
|
| -
|
| - SetFactoryDtlsSrtp();
|
| - *offer = CreateRemoteOffer(options, cricket::SEC_ENABLED);
|
| - ASSERT_TRUE(*offer != NULL);
|
| - VerifyFingerprintStatus((*offer)->description(), true);
|
| - VerifyCryptoParams((*offer)->description());
|
| - }
|
| -
|
| - JsepSessionDescription* CreateRemoteOfferWithVersion(
|
| - cricket::MediaSessionOptions options,
|
| - cricket::SecurePolicy secure_policy,
|
| - const std::string& session_version,
|
| - const SessionDescriptionInterface* current_desc) {
|
| - std::string session_id = rtc::ToString(rtc::CreateRandomId64());
|
| - const cricket::SessionDescription* cricket_desc = NULL;
|
| - if (current_desc) {
|
| - cricket_desc = current_desc->description();
|
| - session_id = current_desc->session_id();
|
| - }
|
| -
|
| - desc_factory_->set_secure(secure_policy);
|
| - JsepSessionDescription* offer(
|
| - new JsepSessionDescription(JsepSessionDescription::kOffer));
|
| - if (!offer->Initialize(desc_factory_->CreateOffer(options, cricket_desc),
|
| - session_id, session_version)) {
|
| - delete offer;
|
| - offer = NULL;
|
| - }
|
| - return offer;
|
| - }
|
| - JsepSessionDescription* CreateRemoteOffer(
|
| - cricket::MediaSessionOptions options) {
|
| - return CreateRemoteOfferWithVersion(options, cricket::SEC_ENABLED,
|
| - kSessionVersion, NULL);
|
| - }
|
| - JsepSessionDescription* CreateRemoteOffer(
|
| - cricket::MediaSessionOptions options, cricket::SecurePolicy sdes_policy) {
|
| - return CreateRemoteOfferWithVersion(
|
| - options, sdes_policy, kSessionVersion, NULL);
|
| - }
|
| - JsepSessionDescription* CreateRemoteOffer(
|
| - cricket::MediaSessionOptions options,
|
| - const SessionDescriptionInterface* current_desc) {
|
| - return CreateRemoteOfferWithVersion(options, cricket::SEC_ENABLED,
|
| - kSessionVersion, current_desc);
|
| - }
|
| -
|
| - JsepSessionDescription* CreateRemoteOfferWithSctpPort(
|
| - const char* sctp_stream_name, int new_port,
|
| - cricket::MediaSessionOptions options) {
|
| - options.data_channel_type = cricket::DCT_SCTP;
|
| - options.AddSendStream(cricket::MEDIA_TYPE_DATA, "datachannel",
|
| - sctp_stream_name);
|
| - return ChangeSDPSctpPort(new_port, CreateRemoteOffer(options));
|
| - }
|
| -
|
| - // Takes ownership of offer_basis (and deletes it).
|
| - JsepSessionDescription* ChangeSDPSctpPort(
|
| - int new_port, webrtc::SessionDescriptionInterface *offer_basis) {
|
| - // Stringify the input SDP, swap the 5000 for 'new_port' and create a new
|
| - // SessionDescription from the mutated string.
|
| - const char* default_port_str = "5000";
|
| - char new_port_str[16];
|
| - rtc::sprintfn(new_port_str, sizeof(new_port_str), "%d", new_port);
|
| - std::string offer_str;
|
| - offer_basis->ToString(&offer_str);
|
| - rtc::replace_substrs(default_port_str, strlen(default_port_str),
|
| - new_port_str, strlen(new_port_str),
|
| - &offer_str);
|
| - JsepSessionDescription* offer = new JsepSessionDescription(
|
| - offer_basis->type());
|
| - delete offer_basis;
|
| - offer->Initialize(offer_str, NULL);
|
| - return offer;
|
| - }
|
| -
|
| - // Create a remote offer. Call SendAudioVideoStreamX()
|
| - // before this function to decide which streams to create.
|
| - JsepSessionDescription* CreateRemoteOffer() {
|
| - cricket::MediaSessionOptions options;
|
| - GetOptionsForAnswer(&options);
|
| - return CreateRemoteOffer(options, session_->remote_description());
|
| - }
|
| -
|
| - JsepSessionDescription* CreateRemoteAnswer(
|
| - const SessionDescriptionInterface* offer,
|
| - cricket::MediaSessionOptions options,
|
| - cricket::SecurePolicy policy) {
|
| - desc_factory_->set_secure(policy);
|
| - const std::string session_id =
|
| - rtc::ToString(rtc::CreateRandomId64());
|
| - JsepSessionDescription* answer(
|
| - new JsepSessionDescription(JsepSessionDescription::kAnswer));
|
| - if (!answer->Initialize(desc_factory_->CreateAnswer(offer->description(),
|
| - options, NULL),
|
| - session_id, kSessionVersion)) {
|
| - delete answer;
|
| - answer = NULL;
|
| - }
|
| - return answer;
|
| - }
|
| -
|
| - JsepSessionDescription* CreateRemoteAnswer(
|
| - const SessionDescriptionInterface* offer,
|
| - cricket::MediaSessionOptions options) {
|
| - return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
|
| - }
|
| -
|
| - // Creates an answer session description.
|
| - // Call SendAudioVideoStreamX() before this function
|
| - // to decide which streams to create.
|
| - JsepSessionDescription* CreateRemoteAnswer(
|
| - const SessionDescriptionInterface* offer) {
|
| - cricket::MediaSessionOptions options;
|
| - GetOptionsForAnswer(&options);
|
| - return CreateRemoteAnswer(offer, options, cricket::SEC_REQUIRED);
|
| - }
|
| -
|
| - void TestSessionCandidatesWithBundleRtcpMux(bool bundle, bool rtcp_mux) {
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - Init();
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = bundle;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
|
| - // and answer.
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> answer(
|
| - CreateRemoteAnswer(session_->local_description()));
|
| - std::string sdp;
|
| - EXPECT_TRUE(answer->ToString(&sdp));
|
| -
|
| - size_t expected_candidate_num = 2;
|
| - if (!rtcp_mux) {
|
| - // If rtcp_mux is enabled we should expect 4 candidates - host and srflex
|
| - // for rtp and rtcp.
|
| - expected_candidate_num = 4;
|
| - // Disable rtcp-mux from the answer
|
| - const std::string kRtcpMux = "a=rtcp-mux";
|
| - const std::string kXRtcpMux = "a=xrtcp-mux";
|
| - rtc::replace_substrs(kRtcpMux.c_str(), kRtcpMux.length(),
|
| - kXRtcpMux.c_str(), kXRtcpMux.length(),
|
| - &sdp);
|
| - }
|
| -
|
| - SessionDescriptionInterface* new_answer = CreateSessionDescription(
|
| - JsepSessionDescription::kAnswer, sdp, NULL);
|
| -
|
| - // SetRemoteDescription to enable rtcp mux.
|
| - SetRemoteDescriptionWithoutError(new_answer);
|
| - EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
|
| - EXPECT_EQ(expected_candidate_num, observer_.mline_0_candidates_.size());
|
| - if (bundle) {
|
| - EXPECT_EQ(0, observer_.mline_1_candidates_.size());
|
| - } else {
|
| - EXPECT_EQ(expected_candidate_num, observer_.mline_1_candidates_.size());
|
| - }
|
| - }
|
| - // Tests that we can only send DTMF when the dtmf codec is supported.
|
| - void TestCanInsertDtmf(bool can) {
|
| - if (can) {
|
| - InitWithDtmfCodec();
|
| - } else {
|
| - Init();
|
| - }
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| - EXPECT_FALSE(session_->CanInsertDtmf(""));
|
| - EXPECT_EQ(can, session_->CanInsertDtmf(kAudioTrack1));
|
| - }
|
| -
|
| - bool ContainsVideoCodecWithName(const SessionDescriptionInterface* desc,
|
| - const std::string& codec_name) {
|
| - for (const auto& content : desc->description()->contents()) {
|
| - if (static_cast<cricket::MediaContentDescription*>(content.description)
|
| - ->type() == cricket::MEDIA_TYPE_VIDEO) {
|
| - const auto* mdesc =
|
| - static_cast<cricket::VideoContentDescription*>(content.description);
|
| - for (const auto& codec : mdesc->codecs()) {
|
| - if (codec.name == codec_name) {
|
| - return true;
|
| - }
|
| - }
|
| - }
|
| - }
|
| - return false;
|
| - }
|
| - // Helper class to configure loopback network and verify Best
|
| - // Connection using right IP protocol for TestLoopbackCall
|
| - // method. LoopbackNetworkManager applies firewall rules to block
|
| - // all ping traffic once ICE completed, and remove them to observe
|
| - // ICE reconnected again. This LoopbackNetworkConfiguration struct
|
| - // verifies the best connection is using the right IP protocol after
|
| - // initial ICE convergences.
|
| -
|
| - class LoopbackNetworkConfiguration {
|
| - public:
|
| - LoopbackNetworkConfiguration()
|
| - : test_ipv6_network_(false),
|
| - test_extra_ipv4_network_(false),
|
| - best_connection_after_initial_ice_converged_(1, 0) {}
|
| -
|
| - // Used to track the expected best connection count in each IP protocol.
|
| - struct ExpectedBestConnection {
|
| - ExpectedBestConnection(int ipv4_count, int ipv6_count)
|
| - : ipv4_count_(ipv4_count),
|
| - ipv6_count_(ipv6_count) {}
|
| -
|
| - int ipv4_count_;
|
| - int ipv6_count_;
|
| - };
|
| -
|
| - bool test_ipv6_network_;
|
| - bool test_extra_ipv4_network_;
|
| - ExpectedBestConnection best_connection_after_initial_ice_converged_;
|
| -
|
| - void VerifyBestConnectionAfterIceConverge(
|
| - const rtc::scoped_refptr<FakeMetricsObserver> metrics_observer) const {
|
| - Verify(metrics_observer, best_connection_after_initial_ice_converged_);
|
| - }
|
| -
|
| - private:
|
| - void Verify(const rtc::scoped_refptr<FakeMetricsObserver> metrics_observer,
|
| - const ExpectedBestConnection& expected) const {
|
| - EXPECT_EQ(
|
| - metrics_observer->GetEnumCounter(webrtc::kEnumCounterAddressFamily,
|
| - webrtc::kBestConnections_IPv4),
|
| - expected.ipv4_count_);
|
| - EXPECT_EQ(
|
| - metrics_observer->GetEnumCounter(webrtc::kEnumCounterAddressFamily,
|
| - webrtc::kBestConnections_IPv6),
|
| - expected.ipv6_count_);
|
| - // This is used in the loopback call so there is only single host to host
|
| - // candidate pair.
|
| - EXPECT_EQ(metrics_observer->GetEnumCounter(
|
| - webrtc::kEnumCounterIceCandidatePairTypeUdp,
|
| - webrtc::kIceCandidatePairHostHost),
|
| - 0);
|
| - EXPECT_EQ(metrics_observer->GetEnumCounter(
|
| - webrtc::kEnumCounterIceCandidatePairTypeUdp,
|
| - webrtc::kIceCandidatePairHostPublicHostPublic),
|
| - 1);
|
| - }
|
| - };
|
| -
|
| - class LoopbackNetworkManager {
|
| - public:
|
| - LoopbackNetworkManager(WebRtcSessionTest* session,
|
| - const LoopbackNetworkConfiguration& config)
|
| - : config_(config) {
|
| - session->AddInterface(
|
| - rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - if (config_.test_extra_ipv4_network_) {
|
| - session->AddInterface(
|
| - rtc::SocketAddress(kClientAddrHost2, kClientAddrPort));
|
| - }
|
| - if (config_.test_ipv6_network_) {
|
| - session->AddInterface(
|
| - rtc::SocketAddress(kClientIPv6AddrHost1, kClientAddrPort));
|
| - }
|
| - }
|
| -
|
| - void ApplyFirewallRules(rtc::FirewallSocketServer* fss) {
|
| - fss->AddRule(false, rtc::FP_ANY, rtc::FD_ANY,
|
| - rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - if (config_.test_extra_ipv4_network_) {
|
| - fss->AddRule(false, rtc::FP_ANY, rtc::FD_ANY,
|
| - rtc::SocketAddress(kClientAddrHost2, kClientAddrPort));
|
| - }
|
| - if (config_.test_ipv6_network_) {
|
| - fss->AddRule(false, rtc::FP_ANY, rtc::FD_ANY,
|
| - rtc::SocketAddress(kClientIPv6AddrHost1, kClientAddrPort));
|
| - }
|
| - }
|
| -
|
| - void ClearRules(rtc::FirewallSocketServer* fss) { fss->ClearRules(); }
|
| -
|
| - private:
|
| - LoopbackNetworkConfiguration config_;
|
| - };
|
| -
|
| - // The method sets up a call from the session to itself, in a loopback
|
| - // arrangement. It also uses a firewall rule to create a temporary
|
| - // disconnection, and then a permanent disconnection.
|
| - // This code is placed in a method so that it can be invoked
|
| - // by multiple tests with different allocators (e.g. with and without BUNDLE).
|
| - // While running the call, this method also checks if the session goes through
|
| - // the correct sequence of ICE states when a connection is established,
|
| - // broken, and re-established.
|
| - // The Connection state should go:
|
| - // New -> Checking -> (Connected) -> Completed -> Disconnected -> Completed
|
| - // -> Failed.
|
| - // The Gathering state should go: New -> Gathering -> Completed.
|
| -
|
| - void SetupLoopbackCall() {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| -
|
| - EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
|
| - observer_.ice_gathering_state_);
|
| - SetLocalDescriptionWithoutError(offer);
|
| - EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
|
| - observer_.ice_connection_state_);
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringGathering,
|
| - observer_.ice_gathering_state_, kIceCandidatesTimeout);
|
| - EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
|
| - observer_.ice_gathering_state_, kIceCandidatesTimeout);
|
| -
|
| - std::string sdp;
|
| - offer->ToString(&sdp);
|
| - SessionDescriptionInterface* desc = webrtc::CreateSessionDescription(
|
| - JsepSessionDescription::kAnswer, sdp, nullptr);
|
| - ASSERT_TRUE(desc != NULL);
|
| - SetRemoteDescriptionWithoutError(desc);
|
| -
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
|
| - observer_.ice_connection_state_, kIceCandidatesTimeout);
|
| -
|
| - // The ice connection state is "Connected" too briefly to catch in a test.
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
|
| - observer_.ice_connection_state_, kIceCandidatesTimeout);
|
| - }
|
| -
|
| - void TestLoopbackCall(const LoopbackNetworkConfiguration& config) {
|
| - LoopbackNetworkManager loopback_network_manager(this, config);
|
| - SetupLoopbackCall();
|
| - config.VerifyBestConnectionAfterIceConverge(metrics_observer_);
|
| - // Adding firewall rule to block ping requests, which should cause
|
| - // transport channel failure.
|
| -
|
| - loopback_network_manager.ApplyFirewallRules(fss_.get());
|
| -
|
| - LOG(LS_INFO) << "Firewall Rules applied";
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
|
| - observer_.ice_connection_state_,
|
| - kIceCandidatesTimeout);
|
| -
|
| - metrics_observer_->Reset();
|
| -
|
| - // Clearing the rules, session should move back to completed state.
|
| - loopback_network_manager.ClearRules(fss_.get());
|
| -
|
| - LOG(LS_INFO) << "Firewall Rules cleared";
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
|
| - observer_.ice_connection_state_,
|
| - kIceCandidatesTimeout);
|
| -
|
| - // Now we block ping requests and wait until the ICE connection transitions
|
| - // to the Failed state. This will take at least 30 seconds because it must
|
| - // wait for the Port to timeout.
|
| - int port_timeout = 30000;
|
| -
|
| - loopback_network_manager.ApplyFirewallRules(fss_.get());
|
| - LOG(LS_INFO) << "Firewall Rules applied again";
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
|
| - observer_.ice_connection_state_,
|
| - kIceCandidatesTimeout + port_timeout);
|
| - }
|
| -
|
| - void TestLoopbackCall() {
|
| - LoopbackNetworkConfiguration config;
|
| - TestLoopbackCall(config);
|
| - }
|
| -
|
| - void TestPacketOptions() {
|
| - media_controller_.reset(
|
| - new cricket::FakeMediaController(channel_manager_.get(), &fake_call_));
|
| - LoopbackNetworkConfiguration config;
|
| - LoopbackNetworkManager loopback_network_manager(this, config);
|
| -
|
| - SetupLoopbackCall();
|
| -
|
| - // Wait for channel to be ready for sending.
|
| - EXPECT_TRUE_WAIT(media_engine_->GetVideoChannel(0)->sending(), 100);
|
| - uint8_t test_packet[15] = {0};
|
| - rtc::PacketOptions options;
|
| - options.packet_id = 10;
|
| - media_engine_->GetVideoChannel(0)
|
| - ->SendRtp(test_packet, sizeof(test_packet), options);
|
| -
|
| - const int kPacketTimeout = 2000;
|
| - EXPECT_EQ_WAIT(10, fake_call_.last_sent_nonnegative_packet_id(),
|
| - kPacketTimeout);
|
| - EXPECT_GT(fake_call_.last_sent_packet().send_time_ms, -1);
|
| - }
|
| -
|
| - // Adds CN codecs to FakeMediaEngine and MediaDescriptionFactory.
|
| - void AddCNCodecs() {
|
| - const cricket::AudioCodec kCNCodec1(102, "CN", 8000, 0, 1);
|
| - const cricket::AudioCodec kCNCodec2(103, "CN", 16000, 0, 1);
|
| -
|
| - // Add kCNCodec for dtmf test.
|
| - std::vector<cricket::AudioCodec> codecs =
|
| - media_engine_->audio_send_codecs();
|
| - codecs.push_back(kCNCodec1);
|
| - codecs.push_back(kCNCodec2);
|
| - media_engine_->SetAudioCodecs(codecs);
|
| - desc_factory_->set_audio_codecs(codecs, codecs);
|
| - }
|
| -
|
| - bool VerifyNoCNCodecs(const cricket::ContentInfo* content) {
|
| - const cricket::ContentDescription* description = content->description;
|
| - RTC_CHECK(description != NULL);
|
| - const cricket::AudioContentDescription* audio_content_desc =
|
| - static_cast<const cricket::AudioContentDescription*>(description);
|
| - RTC_CHECK(audio_content_desc != NULL);
|
| - for (size_t i = 0; i < audio_content_desc->codecs().size(); ++i) {
|
| - if (audio_content_desc->codecs()[i].name == "CN")
|
| - return false;
|
| - }
|
| - return true;
|
| - }
|
| -
|
| - void CreateDataChannel() {
|
| - webrtc::InternalDataChannelInit dci;
|
| - RTC_CHECK(session_.get());
|
| - dci.reliable = session_->data_channel_type() == cricket::DCT_SCTP;
|
| - data_channel_ = DataChannel::Create(
|
| - session_.get(), session_->data_channel_type(), "datachannel", dci);
|
| - }
|
| -
|
| - void SetLocalDescriptionWithDataChannel() {
|
| - CreateDataChannel();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| - }
|
| -
|
| - void VerifyMultipleAsyncCreateDescription(
|
| - RTCCertificateGenerationMethod cert_gen_method,
|
| - CreateSessionDescriptionRequest::Type type) {
|
| - InitWithDtls(cert_gen_method);
|
| - VerifyMultipleAsyncCreateDescriptionAfterInit(true, type);
|
| - }
|
| -
|
| - void VerifyMultipleAsyncCreateDescriptionIdentityGenFailure(
|
| - CreateSessionDescriptionRequest::Type type) {
|
| - InitWithDtlsIdentityGenFail();
|
| - VerifyMultipleAsyncCreateDescriptionAfterInit(false, type);
|
| - }
|
| -
|
| - void VerifyMultipleAsyncCreateDescriptionAfterInit(
|
| - bool success, CreateSessionDescriptionRequest::Type type) {
|
| - RTC_CHECK(session_);
|
| - SetFactoryDtlsSrtp();
|
| - if (type == CreateSessionDescriptionRequest::kAnswer) {
|
| - cricket::MediaSessionOptions options;
|
| - std::unique_ptr<JsepSessionDescription> offer(
|
| - CreateRemoteOffer(options, cricket::SEC_DISABLED));
|
| - ASSERT_TRUE(offer.get() != NULL);
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - }
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - cricket::MediaSessionOptions session_options;
|
| - const int kNumber = 3;
|
| - rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest>
|
| - observers[kNumber];
|
| - for (int i = 0; i < kNumber; ++i) {
|
| - observers[i] = new WebRtcSessionCreateSDPObserverForTest();
|
| - if (type == CreateSessionDescriptionRequest::kOffer) {
|
| - session_->CreateOffer(observers[i], options, session_options);
|
| - } else {
|
| - session_->CreateAnswer(observers[i], session_options);
|
| - }
|
| - }
|
| -
|
| - WebRtcSessionCreateSDPObserverForTest::State expected_state =
|
| - success ? WebRtcSessionCreateSDPObserverForTest::kSucceeded :
|
| - WebRtcSessionCreateSDPObserverForTest::kFailed;
|
| -
|
| - for (int i = 0; i < kNumber; ++i) {
|
| - EXPECT_EQ_WAIT(expected_state, observers[i]->state(), 1000);
|
| - if (success) {
|
| - EXPECT_TRUE(observers[i]->description() != NULL);
|
| - } else {
|
| - EXPECT_TRUE(observers[i]->description() == NULL);
|
| - }
|
| - }
|
| - }
|
| -
|
| - void ConfigureAllocatorWithTurn() {
|
| - cricket::RelayServerConfig turn_server(cricket::RELAY_TURN);
|
| - cricket::RelayCredentials credentials(kTurnUsername, kTurnPassword);
|
| - turn_server.credentials = credentials;
|
| - turn_server.ports.push_back(
|
| - cricket::ProtocolAddress(kTurnUdpIntAddr, cricket::PROTO_UDP));
|
| - allocator_->AddTurnServer(turn_server);
|
| - allocator_->set_step_delay(cricket::kMinimumStepDelay);
|
| - allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP);
|
| - }
|
| -
|
| - webrtc::RtcEventLogNullImpl event_log_;
|
| - cricket::FakeMediaEngine* media_engine_;
|
| - cricket::FakeDataEngine* data_engine_;
|
| - // Actually owned by session_.
|
| - FakeSctpTransportFactory* fake_sctp_transport_factory_ = nullptr;
|
| - std::unique_ptr<cricket::ChannelManager> channel_manager_;
|
| - cricket::FakeCall fake_call_;
|
| - std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
|
| - std::unique_ptr<cricket::TransportDescriptionFactory> tdesc_factory_;
|
| - std::unique_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
|
| - std::unique_ptr<rtc::PhysicalSocketServer> pss_;
|
| - std::unique_ptr<rtc::VirtualSocketServer> vss_;
|
| - std::unique_ptr<rtc::FirewallSocketServer> fss_;
|
| - rtc::SocketServerScope ss_scope_;
|
| - rtc::SocketAddress stun_socket_addr_;
|
| - std::unique_ptr<cricket::TestStunServer> stun_server_;
|
| - cricket::TestTurnServer turn_server_;
|
| - rtc::FakeNetworkManager network_manager_;
|
| - std::unique_ptr<cricket::BasicPortAllocator> allocator_;
|
| - PeerConnectionFactoryInterface::Options options_;
|
| - PeerConnectionInterface::RTCConfiguration configuration_;
|
| - std::unique_ptr<WebRtcSessionForTest> session_;
|
| - MockIceObserver observer_;
|
| - cricket::FakeVideoMediaChannel* video_channel_;
|
| - cricket::FakeVoiceMediaChannel* voice_channel_;
|
| - rtc::scoped_refptr<FakeMetricsObserver> metrics_observer_;
|
| - // The following flags affect options created for CreateOffer/CreateAnswer.
|
| - bool send_stream_1_ = false;
|
| - bool send_stream_2_ = false;
|
| - bool send_audio_ = false;
|
| - bool send_video_ = false;
|
| - rtc::scoped_refptr<DataChannel> data_channel_;
|
| - // Last values received from data channel creation signal.
|
| - std::string last_data_channel_label_;
|
| - InternalDataChannelInit last_data_channel_config_;
|
| - bool session_destroyed_ = false;
|
| - bool with_gcm_ = false;
|
| -};
|
| -
|
| -TEST_P(WebRtcSessionTest, TestInitializeWithDtls) {
|
| - InitWithDtls(GetParam());
|
| - // SDES is disabled when DTLS is on.
|
| - EXPECT_EQ(cricket::SEC_DISABLED, session_->SdesPolicy());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestInitializeWithoutDtls) {
|
| - Init();
|
| - // SDES is required if DTLS is off.
|
| - EXPECT_EQ(cricket::SEC_REQUIRED, session_->SdesPolicy());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSessionCandidates) {
|
| - TestSessionCandidatesWithBundleRtcpMux(false, false);
|
| -}
|
| -
|
| -// Below test cases (TestSessionCandidatesWith*) verify the candidates gathered
|
| -// with rtcp-mux and/or bundle.
|
| -TEST_F(WebRtcSessionTest, TestSessionCandidatesWithRtcpMux) {
|
| - TestSessionCandidatesWithBundleRtcpMux(false, true);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSessionCandidatesWithBundleRtcpMux) {
|
| - TestSessionCandidatesWithBundleRtcpMux(true, true);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestMultihomeCandidates) {
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost2, kClientAddrPort));
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - InitiateCall();
|
| - EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
|
| - EXPECT_EQ(8u, observer_.mline_0_candidates_.size());
|
| - EXPECT_EQ(8u, observer_.mline_1_candidates_.size());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestStunError) {
|
| - rtc::ScopedFakeClock clock;
|
| -
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost2, kClientAddrPort));
|
| - fss_->AddRule(false,
|
| - rtc::FP_UDP,
|
| - rtc::FD_ANY,
|
| - rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - InitiateCall();
|
| - // Since kClientAddrHost1 is blocked, not expecting stun candidates for it.
|
| - EXPECT_TRUE_SIMULATED_WAIT(observer_.oncandidatesready_, kStunTimeout, clock);
|
| - EXPECT_EQ(6u, observer_.mline_0_candidates_.size());
|
| - EXPECT_EQ(6u, observer_.mline_1_candidates_.size());
|
| - // Destroy session before scoped fake clock goes out of scope to avoid TSan
|
| - // warning.
|
| - session_->Close();
|
| - session_.reset(nullptr);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, SetSdpFailedOnInvalidSdp) {
|
| - Init();
|
| - SessionDescriptionInterface* offer = NULL;
|
| - // Since |offer| is NULL, there's no way to tell if it's an offer or answer.
|
| - std::string unknown_action;
|
| - SetLocalDescriptionExpectError(unknown_action, kInvalidSdp, offer);
|
| - SetRemoteDescriptionExpectError(unknown_action, kInvalidSdp, offer);
|
| -}
|
| -
|
| -// Test creating offers and receive answers and make sure the
|
| -// media engine creates the expected send and receive streams.
|
| -TEST_F(WebRtcSessionTest, TestCreateSdesOfferReceiveSdesAnswer) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - const std::string session_id_orig = offer->session_id();
|
| - const std::string session_version_orig = offer->session_version();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_EQ(1u, video_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[0].id);
|
| -
|
| - ASSERT_EQ(1u, voice_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[0].id);
|
| -
|
| - ASSERT_EQ(1u, video_channel_->send_streams().size());
|
| - EXPECT_TRUE(kVideoTrack1 == video_channel_->send_streams()[0].id);
|
| - ASSERT_EQ(1u, voice_channel_->send_streams().size());
|
| - EXPECT_TRUE(kAudioTrack1 == voice_channel_->send_streams()[0].id);
|
| -
|
| - // Create new offer without send streams.
|
| - SendNothing();
|
| - offer = CreateOffer();
|
| -
|
| - // Verify the session id is the same and the session version is
|
| - // increased.
|
| - EXPECT_EQ(session_id_orig, offer->session_id());
|
| - EXPECT_LT(rtc::FromString<uint64_t>(session_version_orig),
|
| - rtc::FromString<uint64_t>(offer->session_version()));
|
| -
|
| - SetLocalDescriptionWithoutError(offer);
|
| - EXPECT_EQ(0u, video_channel_->send_streams().size());
|
| - EXPECT_EQ(0u, voice_channel_->send_streams().size());
|
| -
|
| - SendAudioVideoStream2();
|
| - answer = CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - // Make sure the receive streams have not changed.
|
| - ASSERT_EQ(1u, video_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[0].id);
|
| - ASSERT_EQ(1u, voice_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[0].id);
|
| -}
|
| -
|
| -// Test receiving offers and creating answers and make sure the
|
| -// media engine creates the expected send and receive streams.
|
| -TEST_F(WebRtcSessionTest, TestReceiveSdesOfferCreateSdesAnswer) {
|
| - Init();
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - VerifyCryptoParams(offer->description());
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - VerifyCryptoParams(answer->description());
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - const std::string session_id_orig = answer->session_id();
|
| - const std::string session_version_orig = answer->session_version();
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_TRUE(video_channel_);
|
| - ASSERT_TRUE(voice_channel_);
|
| - ASSERT_EQ(1u, video_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[0].id);
|
| -
|
| - ASSERT_EQ(1u, voice_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[0].id);
|
| -
|
| - ASSERT_EQ(1u, video_channel_->send_streams().size());
|
| - EXPECT_TRUE(kVideoTrack1 == video_channel_->send_streams()[0].id);
|
| - ASSERT_EQ(1u, voice_channel_->send_streams().size());
|
| - EXPECT_TRUE(kAudioTrack1 == voice_channel_->send_streams()[0].id);
|
| -
|
| - SendAudioVideoStream1And2();
|
| - offer = CreateOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - // Answer by turning off all send streams.
|
| - SendNothing();
|
| - answer = CreateAnswer();
|
| -
|
| - // Verify the session id is the same and the session version is
|
| - // increased.
|
| - EXPECT_EQ(session_id_orig, answer->session_id());
|
| - EXPECT_LT(rtc::FromString<uint64_t>(session_version_orig),
|
| - rtc::FromString<uint64_t>(answer->session_version()));
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - ASSERT_EQ(2u, video_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kVideoTrack1 == video_channel_->recv_streams()[0].id);
|
| - EXPECT_TRUE(kVideoTrack2 == video_channel_->recv_streams()[1].id);
|
| - ASSERT_EQ(2u, voice_channel_->recv_streams().size());
|
| - EXPECT_TRUE(kAudioTrack1 == voice_channel_->recv_streams()[0].id);
|
| - EXPECT_TRUE(kAudioTrack2 == voice_channel_->recv_streams()[1].id);
|
| -
|
| - // Make sure we have no send streams.
|
| - EXPECT_EQ(0u, video_channel_->send_streams().size());
|
| - EXPECT_EQ(0u, voice_channel_->send_streams().size());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, SetLocalSdpFailedOnCreateChannel) {
|
| - Init();
|
| - media_engine_->set_fail_create_channel(true);
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - ASSERT_TRUE(offer != NULL);
|
| - // SetRemoteDescription and SetLocalDescription will take the ownership of
|
| - // the offer.
|
| - SetRemoteDescriptionOfferExpectError(kCreateChannelFailed, offer);
|
| - offer = CreateOffer();
|
| - ASSERT_TRUE(offer != NULL);
|
| - SetLocalDescriptionOfferExpectError(kCreateChannelFailed, offer);
|
| -}
|
| -
|
| -//
|
| -// Tests for creating/setting SDP under different SDES/DTLS polices:
|
| -//
|
| -// --DTLS off and SDES on
|
| -// TestCreateSdesOfferReceiveSdesAnswer/TestReceiveSdesOfferCreateSdesAnswer:
|
| -// set local/remote offer/answer with crypto --> success
|
| -// TestSetNonSdesOfferWhenSdesOn: set local/remote offer without crypto --->
|
| -// failure
|
| -// TestSetLocalNonSdesAnswerWhenSdesOn: set local answer without crypto -->
|
| -// failure
|
| -// TestSetRemoteNonSdesAnswerWhenSdesOn: set remote answer without crypto -->
|
| -// failure
|
| -//
|
| -// --DTLS on and SDES off
|
| -// TestCreateDtlsOfferReceiveDtlsAnswer/TestReceiveDtlsOfferCreateDtlsAnswer:
|
| -// set local/remote offer/answer with DTLS fingerprint --> success
|
| -// TestReceiveNonDtlsOfferWhenDtlsOn: set local/remote offer without DTLS
|
| -// fingerprint --> failure
|
| -// TestSetLocalNonDtlsAnswerWhenDtlsOn: set local answer without fingerprint
|
| -// --> failure
|
| -// TestSetRemoteNonDtlsAnswerWhenDtlsOn: set remote answer without fingerprint
|
| -// --> failure
|
| -//
|
| -// --Encryption disabled: DTLS off and SDES off
|
| -// TestCreateOfferReceiveAnswerWithoutEncryption: set local offer and remote
|
| -// answer without SDES or DTLS --> success
|
| -// TestCreateAnswerReceiveOfferWithoutEncryption: set remote offer and local
|
| -// answer without SDES or DTLS --> success
|
| -//
|
| -
|
| -// Test that we return a failure when applying a remote/local offer that doesn't
|
| -// have cryptos enabled when DTLS is off.
|
| -TEST_F(WebRtcSessionTest, TestSetNonSdesOfferWhenSdesOn) {
|
| - Init();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - JsepSessionDescription* offer = CreateRemoteOffer(
|
| - options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyNoCryptoParams(offer->description(), false);
|
| - // SetRemoteDescription and SetLocalDescription will take the ownership of
|
| - // the offer.
|
| - SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto, offer);
|
| - offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(offer != NULL);
|
| - SetLocalDescriptionOfferExpectError(kSdpWithoutSdesCrypto, offer);
|
| -}
|
| -
|
| -// Test that we return a failure when applying a local answer that doesn't have
|
| -// cryptos enabled when DTLS is off.
|
| -TEST_F(WebRtcSessionTest, TestSetLocalNonSdesAnswerWhenSdesOn) {
|
| - Init();
|
| - SessionDescriptionInterface* offer = NULL;
|
| - SessionDescriptionInterface* answer = NULL;
|
| - CreateCryptoOfferAndNonCryptoAnswer(&offer, &answer);
|
| - // SetRemoteDescription and SetLocalDescription will take the ownership of
|
| - // the offer.
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - SetLocalDescriptionAnswerExpectError(kSdpWithoutSdesCrypto, answer);
|
| -}
|
| -
|
| -// Test we will return fail when apply an remote answer that doesn't have
|
| -// crypto enabled when DTLS is off.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteNonSdesAnswerWhenSdesOn) {
|
| - Init();
|
| - SessionDescriptionInterface* offer = NULL;
|
| - SessionDescriptionInterface* answer = NULL;
|
| - CreateCryptoOfferAndNonCryptoAnswer(&offer, &answer);
|
| - // SetRemoteDescription and SetLocalDescription will take the ownership of
|
| - // the offer.
|
| - SetLocalDescriptionWithoutError(offer);
|
| - SetRemoteDescriptionAnswerExpectError(kSdpWithoutSdesCrypto, answer);
|
| -}
|
| -
|
| -// Test that we accept an offer with a DTLS fingerprint when DTLS is on
|
| -// and that we return an answer with a DTLS fingerprint.
|
| -TEST_P(WebRtcSessionTest, TestReceiveDtlsOfferCreateDtlsAnswer) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - SendAudioVideoStream1();
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - JsepSessionDescription* offer =
|
| - CreateRemoteOffer(options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyFingerprintStatus(offer->description(), true);
|
| - VerifyNoCryptoParams(offer->description(), true);
|
| -
|
| - // SetRemoteDescription will take the ownership of the offer.
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - // Verify that we get a crypto fingerprint in the answer.
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - ASSERT_TRUE(answer != NULL);
|
| - VerifyFingerprintStatus(answer->description(), true);
|
| - // Check that we don't have an a=crypto line in the answer.
|
| - VerifyNoCryptoParams(answer->description(), true);
|
| -
|
| - // Now set the local description, which should work, even without a=crypto.
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Test that we set a local offer with a DTLS fingerprint when DTLS is on
|
| -// and then we accept a remote answer with a DTLS fingerprint successfully.
|
| -TEST_P(WebRtcSessionTest, TestCreateDtlsOfferReceiveDtlsAnswer) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - SendAudioVideoStream1();
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| -
|
| - // Verify that we get a crypto fingerprint in the answer.
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyFingerprintStatus(offer->description(), true);
|
| - // Check that we don't have an a=crypto line in the offer.
|
| - VerifyNoCryptoParams(offer->description(), true);
|
| -
|
| - // Now set the local description, which should work, even without a=crypto.
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - JsepSessionDescription* answer =
|
| - CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(answer != NULL);
|
| - VerifyFingerprintStatus(answer->description(), true);
|
| - VerifyNoCryptoParams(answer->description(), true);
|
| -
|
| - // SetRemoteDescription will take the ownership of the answer.
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Test that if we support DTLS and the other side didn't offer a fingerprint,
|
| -// we will fail to set the remote description.
|
| -TEST_P(WebRtcSessionTest, TestReceiveNonDtlsOfferWhenDtlsOn) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - options.bundle_enabled = true;
|
| - JsepSessionDescription* offer = CreateRemoteOffer(
|
| - options, cricket::SEC_REQUIRED);
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyFingerprintStatus(offer->description(), false);
|
| - VerifyCryptoParams(offer->description());
|
| -
|
| - // SetRemoteDescription will take the ownership of the offer.
|
| - SetRemoteDescriptionOfferExpectError(
|
| - kSdpWithoutDtlsFingerprint, offer);
|
| -
|
| - offer = CreateRemoteOffer(options, cricket::SEC_REQUIRED);
|
| - // SetLocalDescription will take the ownership of the offer.
|
| - SetLocalDescriptionOfferExpectError(
|
| - kSdpWithoutDtlsFingerprint, offer);
|
| -}
|
| -
|
| -// Test that we return a failure when applying a local answer that doesn't have
|
| -// a DTLS fingerprint when DTLS is required.
|
| -TEST_P(WebRtcSessionTest, TestSetLocalNonDtlsAnswerWhenDtlsOn) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| - SessionDescriptionInterface* offer = NULL;
|
| - SessionDescriptionInterface* answer = NULL;
|
| - CreateDtlsOfferAndNonDtlsAnswer(&offer, &answer);
|
| -
|
| - // SetRemoteDescription and SetLocalDescription will take the ownership of
|
| - // the offer and answer.
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - SetLocalDescriptionAnswerExpectError(
|
| - kSdpWithoutDtlsFingerprint, answer);
|
| -}
|
| -
|
| -// Test that we return a failure when applying a remote answer that doesn't have
|
| -// a DTLS fingerprint when DTLS is required.
|
| -TEST_P(WebRtcSessionTest, TestSetRemoteNonDtlsAnswerWhenDtlsOn) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - std::unique_ptr<SessionDescriptionInterface> temp_offer(
|
| - CreateRemoteOffer(options, cricket::SEC_ENABLED));
|
| - JsepSessionDescription* answer =
|
| - CreateRemoteAnswer(temp_offer.get(), options, cricket::SEC_ENABLED);
|
| -
|
| - // SetRemoteDescription and SetLocalDescription will take the ownership of
|
| - // the offer and answer.
|
| - SetLocalDescriptionWithoutError(offer);
|
| - SetRemoteDescriptionAnswerExpectError(
|
| - kSdpWithoutDtlsFingerprint, answer);
|
| -}
|
| -
|
| -// Test that we create a local offer without SDES or DTLS and accept a remote
|
| -// answer without SDES or DTLS when encryption is disabled.
|
| -TEST_P(WebRtcSessionTest, TestCreateOfferReceiveAnswerWithoutEncryption) {
|
| - SendAudioVideoStream1();
|
| - options_.disable_encryption = true;
|
| - InitWithDtls(GetParam());
|
| -
|
| - // Verify that we get a crypto fingerprint in the answer.
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyFingerprintStatus(offer->description(), false);
|
| - // Check that we don't have an a=crypto line in the offer.
|
| - VerifyNoCryptoParams(offer->description(), false);
|
| -
|
| - // Now set the local description, which should work, even without a=crypto.
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - JsepSessionDescription* answer =
|
| - CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(answer != NULL);
|
| - VerifyFingerprintStatus(answer->description(), false);
|
| - VerifyNoCryptoParams(answer->description(), false);
|
| -
|
| - // SetRemoteDescription will take the ownership of the answer.
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Test that we create a local answer without SDES or DTLS and accept a remote
|
| -// offer without SDES or DTLS when encryption is disabled.
|
| -TEST_P(WebRtcSessionTest, TestCreateAnswerReceiveOfferWithoutEncryption) {
|
| - options_.disable_encryption = true;
|
| - InitWithDtls(GetParam());
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - JsepSessionDescription* offer =
|
| - CreateRemoteOffer(options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(offer != NULL);
|
| - VerifyFingerprintStatus(offer->description(), false);
|
| - VerifyNoCryptoParams(offer->description(), false);
|
| -
|
| - // SetRemoteDescription will take the ownership of the offer.
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - // Verify that we get a crypto fingerprint in the answer.
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - ASSERT_TRUE(answer != NULL);
|
| - VerifyFingerprintStatus(answer->description(), false);
|
| - // Check that we don't have an a=crypto line in the answer.
|
| - VerifyNoCryptoParams(answer->description(), false);
|
| -
|
| - // Now set the local description, which should work, even without a=crypto.
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Test that we can create and set an answer correctly when different
|
| -// SSL roles have been negotiated for different transports.
|
| -// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4525
|
| -TEST_P(WebRtcSessionTest, TestCreateAnswerWithDifferentSslRoles) {
|
| - SendAudioVideoStream1();
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| -
|
| - // First, negotiate different SSL roles.
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
|
| - TransportInfo* audio_transport_info =
|
| - answer->description()->GetTransportInfoByName("audio");
|
| - audio_transport_info->description.connection_role =
|
| - cricket::CONNECTIONROLE_ACTIVE;
|
| - TransportInfo* video_transport_info =
|
| - answer->description()->GetTransportInfoByName("video");
|
| - video_transport_info->description.connection_role =
|
| - cricket::CONNECTIONROLE_PASSIVE;
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - // Now create an offer in the reverse direction, and ensure the initial
|
| - // offerer responds with an answer with correct SSL roles.
|
| - offer = CreateRemoteOfferWithVersion(options, cricket::SEC_DISABLED,
|
| - kSessionVersion,
|
| - session_->remote_description());
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - answer = CreateAnswer();
|
| - audio_transport_info = answer->description()->GetTransportInfoByName("audio");
|
| - EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
|
| - audio_transport_info->description.connection_role);
|
| - video_transport_info = answer->description()->GetTransportInfoByName("video");
|
| - EXPECT_EQ(cricket::CONNECTIONROLE_ACTIVE,
|
| - video_transport_info->description.connection_role);
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - // Lastly, start BUNDLE-ing on "audio", expecting that the "passive" role of
|
| - // audio is transferred over to video in the answer that completes the BUNDLE
|
| - // negotiation.
|
| - options.bundle_enabled = true;
|
| - offer = CreateRemoteOfferWithVersion(options, cricket::SEC_DISABLED,
|
| - kSessionVersion,
|
| - session_->remote_description());
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - answer = CreateAnswer();
|
| - audio_transport_info = answer->description()->GetTransportInfoByName("audio");
|
| - EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
|
| - audio_transport_info->description.connection_role);
|
| - video_transport_info = answer->description()->GetTransportInfoByName("video");
|
| - EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
|
| - video_transport_info->description.connection_role);
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetLocalOfferTwice) {
|
| - Init();
|
| - SendNothing();
|
| - // SetLocalDescription take ownership of offer.
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - // SetLocalDescription take ownership of offer.
|
| - SessionDescriptionInterface* offer2 = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer2);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteOfferTwice) {
|
| - Init();
|
| - SendNothing();
|
| - // SetLocalDescription take ownership of offer.
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - SessionDescriptionInterface* offer2 = CreateOffer();
|
| - SetRemoteDescriptionWithoutError(offer2);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteOffer) {
|
| - Init();
|
| - SendNothing();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| - offer = CreateOffer();
|
| - SetRemoteDescriptionOfferExpectError("Called in wrong state: STATE_SENTOFFER",
|
| - offer);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteAndLocalOffer) {
|
| - Init();
|
| - SendNothing();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - offer = CreateOffer();
|
| - SetLocalDescriptionOfferExpectError(
|
| - "Called in wrong state: STATE_RECEIVEDOFFER", offer);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetLocalPrAnswer) {
|
| - Init();
|
| - SendNothing();
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - SetRemoteDescriptionExpectState(offer, WebRtcSession::STATE_RECEIVEDOFFER);
|
| -
|
| - JsepSessionDescription* pranswer =
|
| - static_cast<JsepSessionDescription*>(CreateAnswer());
|
| - pranswer->set_type(SessionDescriptionInterface::kPrAnswer);
|
| - SetLocalDescriptionExpectState(pranswer, WebRtcSession::STATE_SENTPRANSWER);
|
| -
|
| - SendAudioVideoStream1();
|
| - JsepSessionDescription* pranswer2 =
|
| - static_cast<JsepSessionDescription*>(CreateAnswer());
|
| - pranswer2->set_type(SessionDescriptionInterface::kPrAnswer);
|
| -
|
| - SetLocalDescriptionExpectState(pranswer2, WebRtcSession::STATE_SENTPRANSWER);
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionExpectState(answer, WebRtcSession::STATE_INPROGRESS);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetRemotePrAnswer) {
|
| - Init();
|
| - SendNothing();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionExpectState(offer, WebRtcSession::STATE_SENTOFFER);
|
| -
|
| - JsepSessionDescription* pranswer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - pranswer->set_type(SessionDescriptionInterface::kPrAnswer);
|
| -
|
| - SetRemoteDescriptionExpectState(pranswer,
|
| - WebRtcSession::STATE_RECEIVEDPRANSWER);
|
| -
|
| - SendAudioVideoStream1();
|
| - JsepSessionDescription* pranswer2 =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - pranswer2->set_type(SessionDescriptionInterface::kPrAnswer);
|
| -
|
| - SetRemoteDescriptionExpectState(pranswer2,
|
| - WebRtcSession::STATE_RECEIVEDPRANSWER);
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionExpectState(answer, WebRtcSession::STATE_INPROGRESS);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetLocalAnswerWithoutOffer) {
|
| - Init();
|
| - SendNothing();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(offer.get());
|
| - SetLocalDescriptionAnswerExpectError("Called in wrong state: STATE_INIT",
|
| - answer);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteAnswerWithoutOffer) {
|
| - Init();
|
| - SendNothing();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(offer.get());
|
| - SetRemoteDescriptionAnswerExpectError(
|
| - "Called in wrong state: STATE_INIT", answer);
|
| -}
|
| -
|
| -// Tests that the remote candidates are added and removed successfully.
|
| -TEST_F(WebRtcSessionTest, TestAddAndRemoveRemoteCandidates) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| -
|
| - cricket::Candidate candidate(1, "udp", rtc::SocketAddress("1.1.1.1", 5000), 0,
|
| - "", "", "host", 0, "");
|
| - candidate.set_transport_name("audio");
|
| - JsepIceCandidate ice_candidate1(kMediaContentName0, 0, candidate);
|
| -
|
| - // Fail since we have not set a remote description.
|
| - EXPECT_FALSE(session_->ProcessIceMessage(&ice_candidate1));
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - // Fail since we have not set a remote description.
|
| - EXPECT_FALSE(session_->ProcessIceMessage(&ice_candidate1));
|
| -
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(
|
| - session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate1));
|
| - candidate.set_component(2);
|
| - candidate.set_address(rtc::SocketAddress("2.2.2.2", 6000));
|
| - JsepIceCandidate ice_candidate2(kMediaContentName0, 0, candidate);
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate2));
|
| -
|
| - // Verifying the candidates are copied properly from internal vector.
|
| - const SessionDescriptionInterface* remote_desc =
|
| - session_->remote_description();
|
| - ASSERT_TRUE(remote_desc != NULL);
|
| - ASSERT_EQ(2u, remote_desc->number_of_mediasections());
|
| - const IceCandidateCollection* candidates =
|
| - remote_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_EQ(2u, candidates->count());
|
| - EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
|
| - EXPECT_EQ(kMediaContentName0, candidates->at(0)->sdp_mid());
|
| - EXPECT_EQ(1, candidates->at(0)->candidate().component());
|
| - EXPECT_EQ(2, candidates->at(1)->candidate().component());
|
| -
|
| - // |ice_candidate3| is identical to |ice_candidate2|. It can be added
|
| - // successfully, but the total count of candidates will not increase.
|
| - candidate.set_component(2);
|
| - JsepIceCandidate ice_candidate3(kMediaContentName0, 0, candidate);
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate3));
|
| - ASSERT_EQ(2u, candidates->count());
|
| -
|
| - JsepIceCandidate bad_ice_candidate("bad content name", 99, candidate);
|
| - EXPECT_FALSE(session_->ProcessIceMessage(&bad_ice_candidate));
|
| -
|
| - // Remove candidate1 and candidate2
|
| - std::vector<cricket::Candidate> remote_candidates;
|
| - remote_candidates.push_back(ice_candidate1.candidate());
|
| - remote_candidates.push_back(ice_candidate2.candidate());
|
| - EXPECT_TRUE(session_->RemoveRemoteIceCandidates(remote_candidates));
|
| - EXPECT_EQ(0u, candidates->count());
|
| -}
|
| -
|
| -// Tests that a remote candidate is added to the remote session description and
|
| -// that it is retained if the remote session description is changed.
|
| -TEST_F(WebRtcSessionTest, TestRemoteCandidatesAddedToSessionDescription) {
|
| - Init();
|
| - cricket::Candidate candidate1;
|
| - candidate1.set_component(1);
|
| - JsepIceCandidate ice_candidate1(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate1));
|
| - const SessionDescriptionInterface* remote_desc =
|
| - session_->remote_description();
|
| - ASSERT_TRUE(remote_desc != NULL);
|
| - ASSERT_EQ(2u, remote_desc->number_of_mediasections());
|
| - const IceCandidateCollection* candidates =
|
| - remote_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_EQ(1u, candidates->count());
|
| - EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
|
| -
|
| - // Update the RemoteSessionDescription with a new session description and
|
| - // a candidate and check that the new remote session description contains both
|
| - // candidates.
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - cricket::Candidate candidate2;
|
| - JsepIceCandidate ice_candidate2(kMediaContentName0, kMediaContentIndex0,
|
| - candidate2);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate2));
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - remote_desc = session_->remote_description();
|
| - ASSERT_TRUE(remote_desc != NULL);
|
| - ASSERT_EQ(2u, remote_desc->number_of_mediasections());
|
| - candidates = remote_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_EQ(2u, candidates->count());
|
| - EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
|
| - // Username and password have be updated with the TransportInfo of the
|
| - // SessionDescription, won't be equal to the original one.
|
| - candidate2.set_username(candidates->at(0)->candidate().username());
|
| - candidate2.set_password(candidates->at(0)->candidate().password());
|
| - EXPECT_TRUE(candidate2.IsEquivalent(candidates->at(0)->candidate()));
|
| - EXPECT_EQ(kMediaContentIndex0, candidates->at(1)->sdp_mline_index());
|
| - // No need to verify the username and password.
|
| - candidate1.set_username(candidates->at(1)->candidate().username());
|
| - candidate1.set_password(candidates->at(1)->candidate().password());
|
| - EXPECT_TRUE(candidate1.IsEquivalent(candidates->at(1)->candidate()));
|
| -
|
| - // Test that the candidate is ignored if we can add the same candidate again.
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate2));
|
| -}
|
| -
|
| -// Test that local candidates are added to the local session description and
|
| -// that they are retained if the local session description is changed. And if
|
| -// continual gathering is enabled, they are removed from the local session
|
| -// description when the network is down.
|
| -TEST_F(WebRtcSessionTest,
|
| - TestLocalCandidatesAddedAndRemovedIfGatherContinually) {
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - Init();
|
| - // Enable Continual Gathering.
|
| - cricket::IceConfig config;
|
| - config.continual_gathering_policy = cricket::GATHER_CONTINUALLY;
|
| - session_->SetIceConfig(config);
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - const SessionDescriptionInterface* local_desc = session_->local_description();
|
| - const IceCandidateCollection* candidates =
|
| - local_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_TRUE(candidates != NULL);
|
| - EXPECT_EQ(0u, candidates->count());
|
| -
|
| - // Since we're using continual gathering, we won't get "gathering done".
|
| - EXPECT_EQ_WAIT(2u, candidates->count(), kIceCandidatesTimeout);
|
| -
|
| - local_desc = session_->local_description();
|
| - candidates = local_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_TRUE(candidates != NULL);
|
| - EXPECT_LT(0u, candidates->count());
|
| - candidates = local_desc->candidates(1);
|
| - ASSERT_TRUE(candidates != NULL);
|
| - EXPECT_EQ(0u, candidates->count());
|
| -
|
| - // Update the session descriptions.
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - local_desc = session_->local_description();
|
| - candidates = local_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_TRUE(candidates != NULL);
|
| - EXPECT_LT(0u, candidates->count());
|
| - candidates = local_desc->candidates(1);
|
| - ASSERT_TRUE(candidates != NULL);
|
| - EXPECT_EQ(0u, candidates->count());
|
| -
|
| - candidates = local_desc->candidates(kMediaContentIndex0);
|
| - size_t num_local_candidates = candidates->count();
|
| - // Bring down the network interface to trigger candidate removals.
|
| - RemoveInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - // Verify that all local candidates are removed.
|
| - EXPECT_EQ(0, observer_.num_candidates_removed_);
|
| - EXPECT_EQ_WAIT(num_local_candidates, observer_.num_candidates_removed_,
|
| - kIceCandidatesTimeout);
|
| - EXPECT_EQ_WAIT(0u, candidates->count(), kIceCandidatesTimeout);
|
| -}
|
| -
|
| -// Tests that if continual gathering is disabled, local candidates won't be
|
| -// removed when the interface is turned down.
|
| -TEST_F(WebRtcSessionTest, TestLocalCandidatesNotRemovedIfNotGatherContinually) {
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - const SessionDescriptionInterface* local_desc = session_->local_description();
|
| - const IceCandidateCollection* candidates =
|
| - local_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_TRUE(candidates != NULL);
|
| - EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
|
| -
|
| - size_t num_local_candidates = candidates->count();
|
| - EXPECT_LT(0u, num_local_candidates);
|
| - // By default, Continual Gathering is disabled.
|
| - // Bring down the network interface.
|
| - RemoveInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - // Verify that the local candidates are not removed.
|
| - rtc::Thread::Current()->ProcessMessages(1000);
|
| - EXPECT_EQ(0, observer_.num_candidates_removed_);
|
| - EXPECT_EQ(num_local_candidates, candidates->count());
|
| -}
|
| -
|
| -// Test that we can set a remote session description with remote candidates.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteSessionDescriptionWithCandidates) {
|
| - Init();
|
| -
|
| - cricket::Candidate candidate1;
|
| - candidate1.set_component(1);
|
| - JsepIceCandidate ice_candidate(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| -
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - const SessionDescriptionInterface* remote_desc =
|
| - session_->remote_description();
|
| - ASSERT_TRUE(remote_desc != NULL);
|
| - ASSERT_EQ(2u, remote_desc->number_of_mediasections());
|
| - const IceCandidateCollection* candidates =
|
| - remote_desc->candidates(kMediaContentIndex0);
|
| - ASSERT_EQ(1u, candidates->count());
|
| - EXPECT_EQ(kMediaContentIndex0, candidates->at(0)->sdp_mline_index());
|
| -
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Test that offers and answers contains ice candidates when Ice candidates have
|
| -// been gathered.
|
| -TEST_F(WebRtcSessionTest, TestSetLocalAndRemoteDescriptionWithCandidates) {
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - // Ice is started but candidates are not provided until SetLocalDescription
|
| - // is called.
|
| - EXPECT_EQ(0u, observer_.mline_0_candidates_.size());
|
| - EXPECT_EQ(0u, observer_.mline_1_candidates_.size());
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| - // Wait until at least one local candidate has been collected.
|
| - EXPECT_TRUE_WAIT(0u < observer_.mline_0_candidates_.size(),
|
| - kIceCandidatesTimeout);
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> local_offer(CreateOffer());
|
| -
|
| - ASSERT_TRUE(local_offer->candidates(kMediaContentIndex0) != NULL);
|
| - EXPECT_LT(0u, local_offer->candidates(kMediaContentIndex0)->count());
|
| -
|
| - SessionDescriptionInterface* remote_offer(CreateRemoteOffer());
|
| - SetRemoteDescriptionWithoutError(remote_offer);
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - ASSERT_TRUE(answer->candidates(kMediaContentIndex0) != NULL);
|
| - EXPECT_LT(0u, answer->candidates(kMediaContentIndex0)->count());
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Verifies TransportProxy and media channels are created with content names
|
| -// present in the SessionDescription.
|
| -TEST_F(WebRtcSessionTest, TestChannelCreationsWithContentNames) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - // CreateOffer creates session description with the content names "audio" and
|
| - // "video". Goal is to modify these content names and verify transport
|
| - // channels
|
| - // in the WebRtcSession, as channels are created with the content names
|
| - // present in SDP.
|
| - std::string sdp;
|
| - EXPECT_TRUE(offer->ToString(&sdp));
|
| - const std::string kAudioMid = "a=mid:audio";
|
| - const std::string kAudioMidReplaceStr = "a=mid:audio_content_name";
|
| - const std::string kVideoMid = "a=mid:video";
|
| - const std::string kVideoMidReplaceStr = "a=mid:video_content_name";
|
| -
|
| - // Replacing |audio| with |audio_content_name|.
|
| - rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
|
| - kAudioMidReplaceStr.c_str(),
|
| - kAudioMidReplaceStr.length(),
|
| - &sdp);
|
| - // Replacing |video| with |video_content_name|.
|
| - rtc::replace_substrs(kVideoMid.c_str(), kVideoMid.length(),
|
| - kVideoMidReplaceStr.c_str(),
|
| - kVideoMidReplaceStr.length(),
|
| - &sdp);
|
| -
|
| - SessionDescriptionInterface* modified_offer =
|
| - CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
|
| -
|
| - SetRemoteDescriptionWithoutError(modified_offer);
|
| -
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - rtc::PacketTransportInterface* voice_transport_channel =
|
| - session_->voice_rtp_transport_channel();
|
| - EXPECT_TRUE(voice_transport_channel != NULL);
|
| - EXPECT_EQ(voice_transport_channel->debug_name(),
|
| - "audio_content_name " +
|
| - std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
|
| - rtc::PacketTransportInterface* video_transport_channel =
|
| - session_->video_rtp_transport_channel();
|
| - ASSERT_TRUE(video_transport_channel != NULL);
|
| - EXPECT_EQ(video_transport_channel->debug_name(),
|
| - "video_content_name " +
|
| - std::to_string(cricket::ICE_CANDIDATE_COMPONENT_RTP));
|
| - EXPECT_TRUE((video_channel_ = media_engine_->GetVideoChannel(0)) != NULL);
|
| - EXPECT_TRUE((voice_channel_ = media_engine_->GetVoiceChannel(0)) != NULL);
|
| -}
|
| -
|
| -// Test that an offer contains the correct media content descriptions based on
|
| -// the send streams when no constraints have been set.
|
| -TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraintsOrStreams) {
|
| - Init();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - ASSERT_TRUE(offer != NULL);
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| -}
|
| -
|
| -// Test that an offer contains the correct media content descriptions based on
|
| -// the send streams when no constraints have been set.
|
| -TEST_F(WebRtcSessionTest, CreateOfferWithoutConstraints) {
|
| - Init();
|
| - // Test Audio only offer.
|
| - SendAudioOnlyStream2();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| -
|
| - // Test Audio / Video offer.
|
| - SendAudioVideoStream1();
|
| - offer.reset(CreateOffer());
|
| - content = cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| -}
|
| -
|
| -// Test that an offer contains no media content descriptions if
|
| -// kOfferToReceiveVideo and kOfferToReceiveAudio constraints are set to false.
|
| -TEST_F(WebRtcSessionTest, CreateOfferWithConstraintsWithoutStreams) {
|
| - Init();
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.offer_to_receive_audio = 0;
|
| - options.offer_to_receive_video = 0;
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
|
| -
|
| - ASSERT_TRUE(offer != NULL);
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| -}
|
| -
|
| -// Test that an offer contains only audio media content descriptions if
|
| -// kOfferToReceiveAudio constraints are set to true.
|
| -TEST_F(WebRtcSessionTest, CreateAudioOnlyOfferWithConstraints) {
|
| - Init();
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.offer_to_receive_audio =
|
| - RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
|
| -
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| -}
|
| -
|
| -// Test that an offer contains audio and video media content descriptions if
|
| -// kOfferToReceiveAudio and kOfferToReceiveVideo constraints are set to true.
|
| -TEST_F(WebRtcSessionTest, CreateOfferWithConstraints) {
|
| - Init();
|
| - // Test Audio / Video offer.
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.offer_to_receive_audio =
|
| - RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
|
| - options.offer_to_receive_video =
|
| - RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
|
| -
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| -
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| -
|
| - // Sets constraints to false and verifies that audio/video contents are
|
| - // removed.
|
| - options.offer_to_receive_audio = 0;
|
| - options.offer_to_receive_video = 0;
|
| - offer.reset(CreateOffer(options));
|
| -
|
| - content = cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| - content = cricket::GetFirstVideoContent(offer->description());
|
| - EXPECT_TRUE(content == NULL);
|
| -}
|
| -
|
| -// Test that an answer can not be created if the last remote description is not
|
| -// an offer.
|
| -TEST_F(WebRtcSessionTest, CreateAnswerWithoutAnOffer) {
|
| - Init();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| - EXPECT_TRUE(CreateAnswer() == NULL);
|
| -}
|
| -
|
| -// Test that an answer contains the correct media content descriptions when no
|
| -// constraints have been set.
|
| -TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraintsOrStreams) {
|
| - Init();
|
| - // Create a remote offer with audio and video content.
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -
|
| - content = cricket::GetFirstVideoContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -}
|
| -
|
| -// Test that an answer contains the correct media content descriptions when no
|
| -// constraints have been set and the offer only contain audio.
|
| -TEST_F(WebRtcSessionTest, CreateAudioAnswerWithoutConstraintsOrStreams) {
|
| - Init();
|
| - // Create a remote offer with audio only.
|
| - cricket::MediaSessionOptions options;
|
| -
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
|
| - ASSERT_TRUE(cricket::GetFirstVideoContent(offer->description()) == NULL);
|
| - ASSERT_TRUE(cricket::GetFirstAudioContent(offer->description()) != NULL);
|
| -
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -
|
| - EXPECT_TRUE(cricket::GetFirstVideoContent(answer->description()) == NULL);
|
| -}
|
| -
|
| -// Test that an answer contains the correct media content descriptions when no
|
| -// constraints have been set.
|
| -TEST_F(WebRtcSessionTest, CreateAnswerWithoutConstraints) {
|
| - Init();
|
| - // Create a remote offer with audio and video content.
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - // Test with a stream with tracks.
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -
|
| - content = cricket::GetFirstVideoContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -}
|
| -
|
| -// Test that an answer contains the correct media content descriptions when
|
| -// constraints have been set but no stream is sent.
|
| -TEST_F(WebRtcSessionTest, CreateAnswerWithConstraintsWithoutStreams) {
|
| - Init();
|
| - // Create a remote offer with audio and video content.
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - cricket::MediaSessionOptions session_options;
|
| - session_options.recv_audio = false;
|
| - session_options.recv_video = false;
|
| - std::unique_ptr<SessionDescriptionInterface> answer(
|
| - CreateAnswer(session_options));
|
| -
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_TRUE(content->rejected);
|
| -
|
| - content = cricket::GetFirstVideoContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_TRUE(content->rejected);
|
| -}
|
| -
|
| -// Test that an answer contains the correct media content descriptions when
|
| -// constraints have been set and streams are sent.
|
| -TEST_F(WebRtcSessionTest, CreateAnswerWithConstraints) {
|
| - Init();
|
| - // Create a remote offer with audio and video content.
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_audio = false;
|
| - options.recv_video = false;
|
| -
|
| - // Test with a stream with tracks.
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer(options));
|
| -
|
| - // TODO(perkj): Should the direction be set to SEND_ONLY?
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -
|
| - // TODO(perkj): Should the direction be set to SEND_ONLY?
|
| - content = cricket::GetFirstVideoContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_FALSE(content->rejected);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, CreateOfferWithoutCNCodecs) {
|
| - AddCNCodecs();
|
| - Init();
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.offer_to_receive_audio =
|
| - RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
|
| - options.voice_activity_detection = false;
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer(options));
|
| -
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(offer->description());
|
| - EXPECT_TRUE(content != NULL);
|
| - EXPECT_TRUE(VerifyNoCNCodecs(content));
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, CreateAnswerWithoutCNCodecs) {
|
| - AddCNCodecs();
|
| - Init();
|
| - // Create a remote offer with audio and video content.
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.vad_enabled = false;
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer(options));
|
| - const cricket::ContentInfo* content =
|
| - cricket::GetFirstAudioContent(answer->description());
|
| - ASSERT_TRUE(content != NULL);
|
| - EXPECT_TRUE(VerifyNoCNCodecs(content));
|
| -}
|
| -
|
| -// This test verifies the call setup when remote answer with audio only and
|
| -// later updates with video.
|
| -TEST_F(WebRtcSessionTest, TestAVOfferWithAudioOnlyAnswer) {
|
| - Init();
|
| - EXPECT_TRUE(media_engine_->GetVideoChannel(0) == NULL);
|
| - EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == NULL);
|
| -
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(offer, options);
|
| -
|
| - // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
|
| - // and answer;
|
| - SetLocalDescriptionWithoutError(offer);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_TRUE(video_channel_ == NULL);
|
| -
|
| - ASSERT_EQ(0u, voice_channel_->recv_streams().size());
|
| - ASSERT_EQ(1u, voice_channel_->send_streams().size());
|
| - EXPECT_EQ(kAudioTrack1, voice_channel_->send_streams()[0].id);
|
| -
|
| - // Let the remote end update the session descriptions, with Audio and Video.
|
| - SendAudioVideoStream2();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_TRUE(video_channel_ != NULL);
|
| - ASSERT_TRUE(voice_channel_ != NULL);
|
| -
|
| - ASSERT_EQ(1u, video_channel_->recv_streams().size());
|
| - ASSERT_EQ(1u, video_channel_->send_streams().size());
|
| - EXPECT_EQ(kVideoTrack2, video_channel_->recv_streams()[0].id);
|
| - EXPECT_EQ(kVideoTrack2, video_channel_->send_streams()[0].id);
|
| - ASSERT_EQ(1u, voice_channel_->recv_streams().size());
|
| - ASSERT_EQ(1u, voice_channel_->send_streams().size());
|
| - EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
|
| - EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
|
| -
|
| - // Change session back to audio only.
|
| - SendAudioOnlyStream2();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - EXPECT_EQ(0u, video_channel_->recv_streams().size());
|
| - ASSERT_EQ(1u, voice_channel_->recv_streams().size());
|
| - EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
|
| - ASSERT_EQ(1u, voice_channel_->send_streams().size());
|
| - EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
|
| -}
|
| -
|
| -// This test verifies the call setup when remote answer with video only and
|
| -// later updates with audio.
|
| -TEST_F(WebRtcSessionTest, TestAVOfferWithVideoOnlyAnswer) {
|
| - Init();
|
| - EXPECT_TRUE(media_engine_->GetVideoChannel(0) == NULL);
|
| - EXPECT_TRUE(media_engine_->GetVoiceChannel(0) == NULL);
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_audio = false;
|
| - options.recv_video = true;
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(
|
| - offer, options, cricket::SEC_ENABLED);
|
| -
|
| - // SetLocalDescription and SetRemoteDescriptions takes ownership of offer
|
| - // and answer.
|
| - SetLocalDescriptionWithoutError(offer);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_TRUE(voice_channel_ == NULL);
|
| - ASSERT_TRUE(video_channel_ != NULL);
|
| -
|
| - EXPECT_EQ(0u, video_channel_->recv_streams().size());
|
| - ASSERT_EQ(1u, video_channel_->send_streams().size());
|
| - EXPECT_EQ(kVideoTrack1, video_channel_->send_streams()[0].id);
|
| -
|
| - // Update the session descriptions, with Audio and Video.
|
| - SendAudioVideoStream2();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| - ASSERT_TRUE(voice_channel_ != NULL);
|
| -
|
| - ASSERT_EQ(1u, voice_channel_->recv_streams().size());
|
| - ASSERT_EQ(1u, voice_channel_->send_streams().size());
|
| - EXPECT_EQ(kAudioTrack2, voice_channel_->recv_streams()[0].id);
|
| - EXPECT_EQ(kAudioTrack2, voice_channel_->send_streams()[0].id);
|
| -
|
| - // Change session back to video only.
|
| - SendVideoOnlyStream2();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_EQ(1u, video_channel_->recv_streams().size());
|
| - EXPECT_EQ(kVideoTrack2, video_channel_->recv_streams()[0].id);
|
| - ASSERT_EQ(1u, video_channel_->send_streams().size());
|
| - EXPECT_EQ(kVideoTrack2, video_channel_->send_streams()[0].id);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDP) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - VerifyCryptoParams(offer->description());
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - VerifyCryptoParams(answer->description());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDPGcm) {
|
| - InitWithGcm();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - VerifyCryptoParams(offer->description(), true);
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - VerifyCryptoParams(answer->description(), true);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, VerifyNoCryptoParamsInSDP) {
|
| - options_.disable_encryption = true;
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - VerifyNoCryptoParams(offer->description(), false);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, VerifyAnswerFromNonCryptoOffer) {
|
| - Init();
|
| - VerifyAnswerFromNonCryptoOffer();
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, VerifyAnswerFromCryptoOffer) {
|
| - Init();
|
| - VerifyAnswerFromCryptoOffer();
|
| -}
|
| -
|
| -// This test verifies that setLocalDescription fails if
|
| -// no a=ice-ufrag and a=ice-pwd lines are present in the SDP.
|
| -TEST_F(WebRtcSessionTest, TestSetLocalDescriptionWithoutIce) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - std::string sdp;
|
| - RemoveIceUfragPwdLines(offer.get(), &sdp);
|
| - SessionDescriptionInterface* modified_offer =
|
| - CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
|
| - SetLocalDescriptionOfferExpectError(kSdpWithoutIceUfragPwd, modified_offer);
|
| -}
|
| -
|
| -// This test verifies that setRemoteDescription fails if
|
| -// no a=ice-ufrag and a=ice-pwd lines are present in the SDP.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteDescriptionWithoutIce) {
|
| - Init();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
|
| - std::string sdp;
|
| - RemoveIceUfragPwdLines(offer.get(), &sdp);
|
| - SessionDescriptionInterface* modified_offer =
|
| - CreateSessionDescription(JsepSessionDescription::kOffer, sdp, NULL);
|
| - SetRemoteDescriptionOfferExpectError(kSdpWithoutIceUfragPwd, modified_offer);
|
| -}
|
| -
|
| -// This test verifies that setLocalDescription fails if local offer has
|
| -// too short ice ufrag and pwd strings.
|
| -TEST_F(WebRtcSessionTest, TestSetLocalDescriptionInvalidIceCredentials) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - // Modifying ice ufrag and pwd in local offer with strings smaller than the
|
| - // recommended values of 4 and 22 bytes respectively.
|
| - SetIceUfragPwd(offer.get(), "ice", "icepwd");
|
| - std::string error;
|
| - EXPECT_FALSE(session_->SetLocalDescription(offer.release(), &error));
|
| -
|
| - // Test with string greater than 256.
|
| - offer.reset(CreateOffer());
|
| - SetIceUfragPwd(offer.get(), kTooLongIceUfragPwd, kTooLongIceUfragPwd);
|
| - EXPECT_FALSE(session_->SetLocalDescription(offer.release(), &error));
|
| -}
|
| -
|
| -// This test verifies that setRemoteDescription fails if remote offer has
|
| -// too short ice ufrag and pwd strings.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteDescriptionInvalidIceCredentials) {
|
| - Init();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
|
| - // Modifying ice ufrag and pwd in remote offer with strings smaller than the
|
| - // recommended values of 4 and 22 bytes respectively.
|
| - SetIceUfragPwd(offer.get(), "ice", "icepwd");
|
| - std::string error;
|
| - EXPECT_FALSE(session_->SetRemoteDescription(offer.release(), &error));
|
| -
|
| - offer.reset(CreateRemoteOffer());
|
| - SetIceUfragPwd(offer.get(), kTooLongIceUfragPwd, kTooLongIceUfragPwd);
|
| - EXPECT_FALSE(session_->SetRemoteDescription(offer.release(), &error));
|
| -}
|
| -
|
| -// Test that if the remote offer indicates the peer requested ICE restart (via
|
| -// a new ufrag or pwd), the old ICE candidates are not copied, and vice versa.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteOfferWithIceRestart) {
|
| - Init();
|
| -
|
| - // Create the first offer.
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
|
| - SetIceUfragPwd(offer.get(), "0123456789012345", "abcdefghijklmnopqrstuvwx");
|
| - cricket::Candidate candidate1(1, "udp", rtc::SocketAddress("1.1.1.1", 5000),
|
| - 0, "", "", "relay", 0, "");
|
| - JsepIceCandidate ice_candidate1(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate1));
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - EXPECT_EQ(1, session_->remote_description()->candidates(0)->count());
|
| -
|
| - // The second offer has the same ufrag and pwd but different address.
|
| - offer.reset(CreateRemoteOffer());
|
| - SetIceUfragPwd(offer.get(), "0123456789012345", "abcdefghijklmnopqrstuvwx");
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 6000));
|
| - JsepIceCandidate ice_candidate2(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate2));
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - EXPECT_EQ(2, session_->remote_description()->candidates(0)->count());
|
| -
|
| - // The third offer has a different ufrag and different address.
|
| - offer.reset(CreateRemoteOffer());
|
| - SetIceUfragPwd(offer.get(), "0123456789012333", "abcdefghijklmnopqrstuvwx");
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 7000));
|
| - JsepIceCandidate ice_candidate3(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate3));
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - EXPECT_EQ(1, session_->remote_description()->candidates(0)->count());
|
| -
|
| - // The fourth offer has no candidate but a different ufrag/pwd.
|
| - offer.reset(CreateRemoteOffer());
|
| - SetIceUfragPwd(offer.get(), "0123456789012444", "abcdefghijklmnopqrstuvyz");
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| - EXPECT_EQ(0, session_->remote_description()->candidates(0)->count());
|
| -}
|
| -
|
| -// Test that if the remote answer indicates the peer requested ICE restart (via
|
| -// a new ufrag or pwd), the old ICE candidates are not copied, and vice versa.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteAnswerWithIceRestart) {
|
| - Init();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - // Create the first answer.
|
| - std::unique_ptr<JsepSessionDescription> answer(CreateRemoteAnswer(offer));
|
| - answer->set_type(JsepSessionDescription::kPrAnswer);
|
| - SetIceUfragPwd(answer.get(), "0123456789012345", "abcdefghijklmnopqrstuvwx");
|
| - cricket::Candidate candidate1(1, "udp", rtc::SocketAddress("1.1.1.1", 5000),
|
| - 0, "", "", "relay", 0, "");
|
| - JsepIceCandidate ice_candidate1(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - EXPECT_TRUE(answer->AddCandidate(&ice_candidate1));
|
| - SetRemoteDescriptionWithoutError(answer.release());
|
| - EXPECT_EQ(1, session_->remote_description()->candidates(0)->count());
|
| -
|
| - // The second answer has the same ufrag and pwd but different address.
|
| - answer.reset(CreateRemoteAnswer(offer));
|
| - answer->set_type(JsepSessionDescription::kPrAnswer);
|
| - SetIceUfragPwd(answer.get(), "0123456789012345", "abcdefghijklmnopqrstuvwx");
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 6000));
|
| - JsepIceCandidate ice_candidate2(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - EXPECT_TRUE(answer->AddCandidate(&ice_candidate2));
|
| - SetRemoteDescriptionWithoutError(answer.release());
|
| - EXPECT_EQ(2, session_->remote_description()->candidates(0)->count());
|
| -
|
| - // The third answer has a different ufrag and different address.
|
| - answer.reset(CreateRemoteAnswer(offer));
|
| - answer->set_type(JsepSessionDescription::kPrAnswer);
|
| - SetIceUfragPwd(answer.get(), "0123456789012333", "abcdefghijklmnopqrstuvwx");
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 7000));
|
| - JsepIceCandidate ice_candidate3(kMediaContentName0, kMediaContentIndex0,
|
| - candidate1);
|
| - EXPECT_TRUE(answer->AddCandidate(&ice_candidate3));
|
| - SetRemoteDescriptionWithoutError(answer.release());
|
| - EXPECT_EQ(1, session_->remote_description()->candidates(0)->count());
|
| -
|
| - // The fourth answer has no candidate but a different ufrag/pwd.
|
| - answer.reset(CreateRemoteAnswer(offer));
|
| - answer->set_type(JsepSessionDescription::kPrAnswer);
|
| - SetIceUfragPwd(answer.get(), "0123456789012444", "abcdefghijklmnopqrstuvyz");
|
| - SetRemoteDescriptionWithoutError(answer.release());
|
| - EXPECT_EQ(0, session_->remote_description()->candidates(0)->count());
|
| -}
|
| -
|
| -// Test that candidates sent to the "video" transport do not get pushed down to
|
| -// the "audio" transport channel when bundling.
|
| -TEST_F(WebRtcSessionTest, TestIgnoreCandidatesForUnusedTransportWhenBundling) {
|
| - AddInterface(rtc::SocketAddress(kClientAddrHost1, kClientAddrPort));
|
| -
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - cricket::BaseChannel* voice_channel = session_->voice_channel();
|
| - ASSERT_TRUE(voice_channel != NULL);
|
| -
|
| - // Checks if one of the transport channels contains a connection using a given
|
| - // port.
|
| - auto connection_with_remote_port = [this, voice_channel](int port) {
|
| - std::unique_ptr<webrtc::SessionStats> stats = session_->GetStats_s();
|
| - for (auto& kv : stats->transport_stats) {
|
| - for (auto& chan_stat : kv.second.channel_stats) {
|
| - for (auto& conn_info : chan_stat.connection_infos) {
|
| - if (conn_info.remote_candidate.address().port() == port) {
|
| - return true;
|
| - }
|
| - }
|
| - }
|
| - }
|
| - return false;
|
| - };
|
| -
|
| - EXPECT_FALSE(connection_with_remote_port(5000));
|
| - EXPECT_FALSE(connection_with_remote_port(5001));
|
| - EXPECT_FALSE(connection_with_remote_port(6000));
|
| -
|
| - // The way the *_WAIT checks work is they only wait if the condition fails,
|
| - // which does not help in the case where state is not changing. This is
|
| - // problematic in this test since we want to verify that adding a video
|
| - // candidate does _not_ change state. So we interleave candidates and assume
|
| - // that messages are executed in the order they were posted.
|
| -
|
| - // First audio candidate.
|
| - cricket::Candidate candidate0;
|
| - candidate0.set_address(rtc::SocketAddress("1.1.1.1", 5000));
|
| - candidate0.set_component(1);
|
| - candidate0.set_protocol("udp");
|
| - JsepIceCandidate ice_candidate0(kMediaContentName0, kMediaContentIndex0,
|
| - candidate0);
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate0));
|
| -
|
| - // Video candidate.
|
| - cricket::Candidate candidate1;
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 6000));
|
| - candidate1.set_component(1);
|
| - candidate1.set_protocol("udp");
|
| - JsepIceCandidate ice_candidate1(kMediaContentName1, kMediaContentIndex1,
|
| - candidate1);
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate1));
|
| -
|
| - // Second audio candidate.
|
| - cricket::Candidate candidate2;
|
| - candidate2.set_address(rtc::SocketAddress("1.1.1.1", 5001));
|
| - candidate2.set_component(1);
|
| - candidate2.set_protocol("udp");
|
| - JsepIceCandidate ice_candidate2(kMediaContentName0, kMediaContentIndex0,
|
| - candidate2);
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate2));
|
| -
|
| - EXPECT_TRUE_WAIT(connection_with_remote_port(5000), 1000);
|
| - EXPECT_TRUE_WAIT(connection_with_remote_port(5001), 1000);
|
| -
|
| - // No need here for a _WAIT check since we are checking that state hasn't
|
| - // changed: if this is false we would be doing waits for nothing and if this
|
| - // is true then there will be no messages processed anyways.
|
| - EXPECT_FALSE(connection_with_remote_port(6000));
|
| -}
|
| -
|
| -// kBundlePolicyBalanced BUNDLE policy and answer contains BUNDLE.
|
| -TEST_F(WebRtcSessionTest, TestBalancedBundleInAnswer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyBalanced BUNDLE policy but no BUNDLE in the answer.
|
| -TEST_F(WebRtcSessionTest, TestBalancedNoBundleInAnswer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| -
|
| - // Remove BUNDLE from the answer.
|
| - std::unique_ptr<SessionDescriptionInterface> answer(
|
| - CreateRemoteAnswer(session_->local_description()));
|
| - cricket::SessionDescription* answer_copy = answer->description()->Copy();
|
| - answer_copy->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
|
| - JsepSessionDescription* modified_answer =
|
| - new JsepSessionDescription(JsepSessionDescription::kAnswer);
|
| - modified_answer->Initialize(answer_copy, "1", "1");
|
| - SetRemoteDescriptionWithoutError(modified_answer); //
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxBundle policy with BUNDLE in the answer.
|
| -TEST_F(WebRtcSessionTest, TestMaxBundleBundleInAnswer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxBundle policy with BUNDLE in the answer, but no
|
| -// audio content in the answer.
|
| -TEST_F(WebRtcSessionTest, TestMaxBundleRejectAudio) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| - cricket::MediaSessionOptions recv_options;
|
| - recv_options.recv_audio = false;
|
| - recv_options.recv_video = true;
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description(), recv_options);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_TRUE(nullptr == session_->voice_channel());
|
| - EXPECT_TRUE(nullptr != session_->video_rtp_transport_channel());
|
| -
|
| - session_->Close();
|
| - EXPECT_TRUE(nullptr == session_->voice_rtp_transport_channel());
|
| - EXPECT_TRUE(nullptr == session_->voice_rtcp_transport_channel());
|
| - EXPECT_TRUE(nullptr == session_->video_rtp_transport_channel());
|
| - EXPECT_TRUE(nullptr == session_->video_rtcp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxBundle policy but no BUNDLE in the answer.
|
| -TEST_F(WebRtcSessionTest, TestMaxBundleNoBundleInAnswer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| -
|
| - // Remove BUNDLE from the answer.
|
| - std::unique_ptr<SessionDescriptionInterface> answer(
|
| - CreateRemoteAnswer(session_->local_description()));
|
| - cricket::SessionDescription* answer_copy = answer->description()->Copy();
|
| - answer_copy->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
|
| - JsepSessionDescription* modified_answer =
|
| - new JsepSessionDescription(JsepSessionDescription::kAnswer);
|
| - modified_answer->Initialize(answer_copy, "1", "1");
|
| - SetRemoteDescriptionWithoutError(modified_answer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxBundle policy with BUNDLE in the remote offer.
|
| -TEST_F(WebRtcSessionTest, TestMaxBundleBundleInRemoteOffer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
|
| - SendAudioVideoStream1();
|
| -
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxBundle policy but no BUNDLE in the remote offer.
|
| -TEST_F(WebRtcSessionTest, TestMaxBundleNoBundleInRemoteOffer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
|
| - SendAudioVideoStream1();
|
| -
|
| - // Remove BUNDLE from the offer.
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateRemoteOffer());
|
| - cricket::SessionDescription* offer_copy = offer->description()->Copy();
|
| - offer_copy->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
|
| - JsepSessionDescription* modified_offer =
|
| - new JsepSessionDescription(JsepSessionDescription::kOffer);
|
| - modified_offer->Initialize(offer_copy, "1", "1");
|
| -
|
| - // Expect an error when applying the remote description
|
| - SetRemoteDescriptionExpectError(JsepSessionDescription::kOffer,
|
| - kCreateChannelFailed, modified_offer);
|
| -}
|
| -
|
| -// kBundlePolicyMaxCompat bundle policy and answer contains BUNDLE.
|
| -TEST_F(WebRtcSessionTest, TestMaxCompatBundleInAnswer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxCompat);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - // This should lead to an audio-only call but isn't implemented
|
| - // correctly yet.
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxCompat BUNDLE policy but no BUNDLE in the answer.
|
| -TEST_F(WebRtcSessionTest, TestMaxCompatNoBundleInAnswer) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxCompat);
|
| - SendAudioVideoStream1();
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| -
|
| - // Remove BUNDLE from the answer.
|
| - std::unique_ptr<SessionDescriptionInterface> answer(
|
| - CreateRemoteAnswer(session_->local_description()));
|
| - cricket::SessionDescription* answer_copy = answer->description()->Copy();
|
| - answer_copy->RemoveGroupByName(cricket::GROUP_TYPE_BUNDLE);
|
| - JsepSessionDescription* modified_answer =
|
| - new JsepSessionDescription(JsepSessionDescription::kAnswer);
|
| - modified_answer->Initialize(answer_copy, "1", "1");
|
| - SetRemoteDescriptionWithoutError(modified_answer); //
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// kBundlePolicyMaxbundle and then we call SetRemoteDescription first.
|
| -TEST_F(WebRtcSessionTest, TestMaxBundleWithSetRemoteDescriptionFirst) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyMaxBundle);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_EQ(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -}
|
| -
|
| -// Adding a new channel to a BUNDLE which is already connected should directly
|
| -// assign the bundle transport to the channel, without first setting a
|
| -// disconnected non-bundle transport and then replacing it. The application
|
| -// should not receive any changes in the ICE state.
|
| -TEST_F(WebRtcSessionTest, TestAddChannelToConnectedBundle) {
|
| - LoopbackNetworkConfiguration config;
|
| - LoopbackNetworkManager loopback_network_manager(this, config);
|
| - // Both BUNDLE and RTCP-mux need to be enabled for the ICE state to remain
|
| - // connected. Disabling either of these two means that we need to wait for the
|
| - // answer to find out if more transports are needed.
|
| - configuration_.bundle_policy =
|
| - PeerConnectionInterface::kBundlePolicyMaxBundle;
|
| - options_.disable_encryption = true;
|
| - Init(PeerConnectionInterface::kRtcpMuxPolicyRequire);
|
| -
|
| - // Negotiate an audio channel with MAX_BUNDLE enabled.
|
| - SendAudioOnlyStream2();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
|
| - observer_.ice_gathering_state_, kIceCandidatesTimeout);
|
| - std::string sdp;
|
| - offer->ToString(&sdp);
|
| - SessionDescriptionInterface* answer = webrtc::CreateSessionDescription(
|
| - JsepSessionDescription::kAnswer, sdp, nullptr);
|
| - ASSERT_TRUE(answer != NULL);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - // Wait for the ICE state to stabilize.
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
|
| - observer_.ice_connection_state_, kIceCandidatesTimeout);
|
| - observer_.ice_connection_state_history_.clear();
|
| -
|
| - // Now add a video channel which should be using the same bundle transport.
|
| - SendAudioVideoStream2();
|
| - offer = CreateOffer();
|
| - offer->ToString(&sdp);
|
| - SetLocalDescriptionWithoutError(offer);
|
| - answer = webrtc::CreateSessionDescription(JsepSessionDescription::kAnswer,
|
| - sdp, nullptr);
|
| - ASSERT_TRUE(answer != NULL);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - // Wait for ICE state to stabilize
|
| - rtc::Thread::Current()->ProcessMessages(0);
|
| - EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
|
| - observer_.ice_connection_state_, kIceCandidatesTimeout);
|
| -
|
| - // No ICE state changes are expected to happen.
|
| - EXPECT_EQ(0, observer_.ice_connection_state_history_.size());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestRequireRtcpMux) {
|
| - InitWithRtcpMuxPolicy(PeerConnectionInterface::kRtcpMuxPolicyRequire);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_TRUE(session_->voice_rtcp_transport_channel() == NULL);
|
| - EXPECT_TRUE(session_->video_rtcp_transport_channel() == NULL);
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_TRUE(session_->voice_rtcp_transport_channel() == NULL);
|
| - EXPECT_TRUE(session_->video_rtcp_transport_channel() == NULL);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestNegotiateRtcpMux) {
|
| - InitWithRtcpMuxPolicy(PeerConnectionInterface::kRtcpMuxPolicyNegotiate);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - EXPECT_TRUE(session_->voice_rtcp_transport_channel() != NULL);
|
| - EXPECT_TRUE(session_->video_rtcp_transport_channel() != NULL);
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_TRUE(session_->voice_rtcp_transport_channel() == NULL);
|
| - EXPECT_TRUE(session_->video_rtcp_transport_channel() == NULL);
|
| -}
|
| -
|
| -// This test verifies that SetLocalDescription and SetRemoteDescription fails
|
| -// if BUNDLE is enabled but rtcp-mux is disabled in m-lines.
|
| -TEST_F(WebRtcSessionTest, TestDisabledRtcpMuxWithBundleEnabled) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - std::string offer_str;
|
| - offer->ToString(&offer_str);
|
| - // Disable rtcp-mux
|
| - const std::string rtcp_mux = "rtcp-mux";
|
| - const std::string xrtcp_mux = "xrtcp-mux";
|
| - rtc::replace_substrs(rtcp_mux.c_str(), rtcp_mux.length(),
|
| - xrtcp_mux.c_str(), xrtcp_mux.length(),
|
| - &offer_str);
|
| - JsepSessionDescription* local_offer =
|
| - new JsepSessionDescription(JsepSessionDescription::kOffer);
|
| - EXPECT_TRUE((local_offer)->Initialize(offer_str, NULL));
|
| - SetLocalDescriptionOfferExpectError(kBundleWithoutRtcpMux, local_offer);
|
| - JsepSessionDescription* remote_offer =
|
| - new JsepSessionDescription(JsepSessionDescription::kOffer);
|
| - EXPECT_TRUE((remote_offer)->Initialize(offer_str, NULL));
|
| - SetRemoteDescriptionOfferExpectError(kBundleWithoutRtcpMux, remote_offer);
|
| - // Trying unmodified SDP.
|
| - SetLocalDescriptionWithoutError(offer);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, SetSetupGcm) {
|
| - InitWithGcm();
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, CanNotInsertDtmf) {
|
| - TestCanInsertDtmf(false);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, CanInsertDtmf) {
|
| - TestCanInsertDtmf(true);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, InsertDtmf) {
|
| - // Setup
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - CreateAndSetRemoteOfferAndLocalAnswer();
|
| - FakeVoiceMediaChannel* channel = media_engine_->GetVoiceChannel(0);
|
| - EXPECT_EQ(0U, channel->dtmf_info_queue().size());
|
| -
|
| - // Insert DTMF
|
| - const int expected_duration = 90;
|
| - session_->InsertDtmf(kAudioTrack1, 0, expected_duration);
|
| - session_->InsertDtmf(kAudioTrack1, 1, expected_duration);
|
| - session_->InsertDtmf(kAudioTrack1, 2, expected_duration);
|
| -
|
| - // Verify
|
| - ASSERT_EQ(3U, channel->dtmf_info_queue().size());
|
| - const uint32_t send_ssrc = channel->send_streams()[0].first_ssrc();
|
| - EXPECT_TRUE(CompareDtmfInfo(channel->dtmf_info_queue()[0], send_ssrc, 0,
|
| - expected_duration));
|
| - EXPECT_TRUE(CompareDtmfInfo(channel->dtmf_info_queue()[1], send_ssrc, 1,
|
| - expected_duration));
|
| - EXPECT_TRUE(CompareDtmfInfo(channel->dtmf_info_queue()[2], send_ssrc, 2,
|
| - expected_duration));
|
| -}
|
| -
|
| -// This test verifies the |initial_offerer| flag when session initiates the
|
| -// call.
|
| -TEST_F(WebRtcSessionTest, TestInitiatorFlagAsOriginator) {
|
| - Init();
|
| - EXPECT_FALSE(session_->initial_offerer());
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
|
| - SetLocalDescriptionWithoutError(offer);
|
| - EXPECT_TRUE(session_->initial_offerer());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| - EXPECT_TRUE(session_->initial_offerer());
|
| -}
|
| -
|
| -// This test verifies the |initial_offerer| flag when session receives the call.
|
| -TEST_F(WebRtcSessionTest, TestInitiatorFlagAsReceiver) {
|
| - Init();
|
| - EXPECT_FALSE(session_->initial_offerer());
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| -
|
| - EXPECT_FALSE(session_->initial_offerer());
|
| - SetLocalDescriptionWithoutError(answer);
|
| - EXPECT_FALSE(session_->initial_offerer());
|
| -}
|
| -
|
| -// Verifing local offer and remote answer have matching m-lines as per RFC 3264.
|
| -TEST_F(WebRtcSessionTest, TestIncorrectMLinesInRemoteAnswer) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| - std::unique_ptr<SessionDescriptionInterface> answer(
|
| - CreateRemoteAnswer(session_->local_description()));
|
| -
|
| - cricket::SessionDescription* answer_copy = answer->description()->Copy();
|
| - answer_copy->RemoveContentByName("video");
|
| - JsepSessionDescription* modified_answer =
|
| - new JsepSessionDescription(JsepSessionDescription::kAnswer);
|
| -
|
| - EXPECT_TRUE(modified_answer->Initialize(answer_copy,
|
| - answer->session_id(),
|
| - answer->session_version()));
|
| - SetRemoteDescriptionAnswerExpectError(kMlineMismatch, modified_answer);
|
| -
|
| - // Different content names.
|
| - std::string sdp;
|
| - EXPECT_TRUE(answer->ToString(&sdp));
|
| - const std::string kAudioMid = "a=mid:audio";
|
| - const std::string kAudioMidReplaceStr = "a=mid:audio_content_name";
|
| - rtc::replace_substrs(kAudioMid.c_str(), kAudioMid.length(),
|
| - kAudioMidReplaceStr.c_str(),
|
| - kAudioMidReplaceStr.length(),
|
| - &sdp);
|
| - SessionDescriptionInterface* modified_answer1 =
|
| - CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, NULL);
|
| - SetRemoteDescriptionAnswerExpectError(kMlineMismatch, modified_answer1);
|
| -
|
| - // Different media types.
|
| - EXPECT_TRUE(answer->ToString(&sdp));
|
| - const std::string kAudioMline = "m=audio";
|
| - const std::string kAudioMlineReplaceStr = "m=video";
|
| - rtc::replace_substrs(kAudioMline.c_str(), kAudioMline.length(),
|
| - kAudioMlineReplaceStr.c_str(),
|
| - kAudioMlineReplaceStr.length(),
|
| - &sdp);
|
| - SessionDescriptionInterface* modified_answer2 =
|
| - CreateSessionDescription(JsepSessionDescription::kAnswer, sdp, NULL);
|
| - SetRemoteDescriptionAnswerExpectError(kMlineMismatch, modified_answer2);
|
| -
|
| - SetRemoteDescriptionWithoutError(answer.release());
|
| -}
|
| -
|
| -// Verifying remote offer and local answer have matching m-lines as per
|
| -// RFC 3264.
|
| -TEST_F(WebRtcSessionTest, TestIncorrectMLinesInLocalAnswer) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| -
|
| - cricket::SessionDescription* answer_copy = answer->description()->Copy();
|
| - answer_copy->RemoveContentByName("video");
|
| - JsepSessionDescription* modified_answer =
|
| - new JsepSessionDescription(JsepSessionDescription::kAnswer);
|
| -
|
| - EXPECT_TRUE(modified_answer->Initialize(answer_copy,
|
| - answer->session_id(),
|
| - answer->session_version()));
|
| - SetLocalDescriptionAnswerExpectError(kMlineMismatch, modified_answer);
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// This test verifies that WebRtcSession does not start candidate allocation
|
| -// before SetLocalDescription is called.
|
| -TEST_F(WebRtcSessionTest, TestIceStartAfterSetLocalDescriptionOnly) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateRemoteOffer();
|
| - cricket::Candidate candidate;
|
| - candidate.set_component(1);
|
| - JsepIceCandidate ice_candidate(kMediaContentName0, kMediaContentIndex0,
|
| - candidate);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
|
| - cricket::Candidate candidate1;
|
| - candidate1.set_component(1);
|
| - JsepIceCandidate ice_candidate1(kMediaContentName1, kMediaContentIndex1,
|
| - candidate1);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate1));
|
| - SetRemoteDescriptionWithoutError(offer);
|
| - ASSERT_TRUE(session_->voice_rtp_transport_channel() != NULL);
|
| - ASSERT_TRUE(session_->video_rtp_transport_channel() != NULL);
|
| -
|
| - // Pump for 1 second and verify that no candidates are generated.
|
| - rtc::Thread::Current()->ProcessMessages(1000);
|
| - EXPECT_TRUE(observer_.mline_0_candidates_.empty());
|
| - EXPECT_TRUE(observer_.mline_1_candidates_.empty());
|
| -
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| - EXPECT_TRUE_WAIT(observer_.oncandidatesready_, kIceCandidatesTimeout);
|
| -}
|
| -
|
| -// This test verifies that crypto parameter is updated in local session
|
| -// description as per security policy set in MediaSessionDescriptionFactory.
|
| -TEST_F(WebRtcSessionTest, TestCryptoAfterSetLocalDescription) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - // Making sure SetLocalDescription correctly sets crypto value in
|
| - // SessionDescription object after de-serialization of sdp string. The value
|
| - // will be set as per MediaSessionDescriptionFactory.
|
| - std::string offer_str;
|
| - offer->ToString(&offer_str);
|
| - SessionDescriptionInterface* jsep_offer_str =
|
| - CreateSessionDescription(JsepSessionDescription::kOffer, offer_str, NULL);
|
| - SetLocalDescriptionWithoutError(jsep_offer_str);
|
| - EXPECT_TRUE(session_->voice_channel()->srtp_required_for_testing());
|
| - EXPECT_TRUE(session_->video_channel()->srtp_required_for_testing());
|
| -}
|
| -
|
| -// This test verifies the crypto parameter when security is disabled.
|
| -TEST_F(WebRtcSessionTest, TestCryptoAfterSetLocalDescriptionWithDisabled) {
|
| - options_.disable_encryption = true;
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - // Making sure SetLocalDescription correctly sets crypto value in
|
| - // SessionDescription object after de-serialization of sdp string. The value
|
| - // will be set as per MediaSessionDescriptionFactory.
|
| - std::string offer_str;
|
| - offer->ToString(&offer_str);
|
| - SessionDescriptionInterface* jsep_offer_str =
|
| - CreateSessionDescription(JsepSessionDescription::kOffer, offer_str, NULL);
|
| - SetLocalDescriptionWithoutError(jsep_offer_str);
|
| - EXPECT_FALSE(session_->voice_channel()->srtp_required_for_testing());
|
| - EXPECT_FALSE(session_->video_channel()->srtp_required_for_testing());
|
| -}
|
| -
|
| -// This test verifies that an answer contains new ufrag and password if an offer
|
| -// with new ufrag and password is received.
|
| -TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewUfragAndPassword) {
|
| - Init();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - SetLocalDescriptionWithoutError(answer.release());
|
| -
|
| - // Receive an offer with new ufrag and password.
|
| - for (const cricket::ContentInfo& content :
|
| - session_->local_description()->description()->contents()) {
|
| - options.transport_options[content.name].ice_restart = true;
|
| - }
|
| - std::unique_ptr<JsepSessionDescription> updated_offer1(
|
| - CreateRemoteOffer(options, session_->remote_description()));
|
| - SetRemoteDescriptionWithoutError(updated_offer1.release());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> updated_answer1(CreateAnswer());
|
| -
|
| - EXPECT_FALSE(IceUfragPwdEqual(updated_answer1->description(),
|
| - session_->local_description()->description()));
|
| -
|
| - // Even a second answer (created before the description is set) should have
|
| - // a new ufrag/password.
|
| - std::unique_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
|
| -
|
| - EXPECT_FALSE(IceUfragPwdEqual(updated_answer2->description(),
|
| - session_->local_description()->description()));
|
| -
|
| - SetLocalDescriptionWithoutError(updated_answer2.release());
|
| -}
|
| -
|
| -// This test verifies that an answer contains new ufrag and password if an offer
|
| -// that changes either the ufrag or password (but not both) is received.
|
| -// RFC 5245 says: "If the offer contained a change in the a=ice-ufrag or
|
| -// a=ice-pwd attributes compared to the previous SDP from the peer, it
|
| -// indicates that ICE is restarting for this media stream."
|
| -TEST_F(WebRtcSessionTest, TestOfferChangingOnlyUfragOrPassword) {
|
| - Init();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_audio = true;
|
| - options.recv_video = true;
|
| - // Create an offer with audio and video.
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
|
| - SetIceUfragPwd(offer.get(), "original_ufrag", "original_password12345");
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - SetLocalDescriptionWithoutError(answer.release());
|
| -
|
| - // Receive an offer with a new ufrag but stale password.
|
| - std::unique_ptr<JsepSessionDescription> ufrag_changed_offer(
|
| - CreateRemoteOffer(options, session_->remote_description()));
|
| - SetIceUfragPwd(ufrag_changed_offer.get(), "modified_ufrag",
|
| - "original_password12345");
|
| - SetRemoteDescriptionWithoutError(ufrag_changed_offer.release());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> updated_answer1(CreateAnswer());
|
| - EXPECT_FALSE(IceUfragPwdEqual(updated_answer1->description(),
|
| - session_->local_description()->description()));
|
| - SetLocalDescriptionWithoutError(updated_answer1.release());
|
| -
|
| - // Receive an offer with a new password but stale ufrag.
|
| - std::unique_ptr<JsepSessionDescription> password_changed_offer(
|
| - CreateRemoteOffer(options, session_->remote_description()));
|
| - SetIceUfragPwd(password_changed_offer.get(), "modified_ufrag",
|
| - "modified_password12345");
|
| - SetRemoteDescriptionWithoutError(password_changed_offer.release());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
|
| - EXPECT_FALSE(IceUfragPwdEqual(updated_answer2->description(),
|
| - session_->local_description()->description()));
|
| - SetLocalDescriptionWithoutError(updated_answer2.release());
|
| -}
|
| -
|
| -// This test verifies that an answer contains old ufrag and password if an offer
|
| -// with old ufrag and password is received.
|
| -TEST_F(WebRtcSessionTest, TestCreateAnswerWithOldUfragAndPassword) {
|
| - Init();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - SetLocalDescriptionWithoutError(answer.release());
|
| -
|
| - // Receive an offer without changed ufrag or password.
|
| - std::unique_ptr<JsepSessionDescription> updated_offer2(
|
| - CreateRemoteOffer(options, session_->remote_description()));
|
| - SetRemoteDescriptionWithoutError(updated_offer2.release());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> updated_answer2(CreateAnswer());
|
| -
|
| - EXPECT_TRUE(IceUfragPwdEqual(updated_answer2->description(),
|
| - session_->local_description()->description()));
|
| -
|
| - SetLocalDescriptionWithoutError(updated_answer2.release());
|
| -}
|
| -
|
| -// This test verifies that if an offer does an ICE restart on some, but not all
|
| -// media sections, the answer will change the ufrag/password in the correct
|
| -// media sections.
|
| -TEST_F(WebRtcSessionTest, TestCreateAnswerWithNewAndOldUfragAndPassword) {
|
| - Init();
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - options.recv_audio = true;
|
| - options.bundle_enabled = false;
|
| - std::unique_ptr<JsepSessionDescription> offer(CreateRemoteOffer(options));
|
| -
|
| - SetIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_AUDIO, "aaaa",
|
| - "aaaaaaaaaaaaaaaaaaaaaa");
|
| - SetIceUfragPwd(offer.get(), cricket::MEDIA_TYPE_VIDEO, "bbbb",
|
| - "bbbbbbbbbbbbbbbbbbbbbb");
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - SetLocalDescriptionWithoutError(answer.release());
|
| -
|
| - // Receive an offer with new ufrag and password, but only for the video media
|
| - // section.
|
| - std::unique_ptr<JsepSessionDescription> updated_offer(
|
| - CreateRemoteOffer(options, session_->remote_description()));
|
| - SetIceUfragPwd(updated_offer.get(), cricket::MEDIA_TYPE_VIDEO, "cccc",
|
| - "cccccccccccccccccccccc");
|
| - SetRemoteDescriptionWithoutError(updated_offer.release());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> updated_answer(CreateAnswer());
|
| -
|
| - EXPECT_TRUE(IceUfragPwdEqual(updated_answer->description(),
|
| - session_->local_description()->description(),
|
| - cricket::MEDIA_TYPE_AUDIO));
|
| -
|
| - EXPECT_FALSE(IceUfragPwdEqual(updated_answer->description(),
|
| - session_->local_description()->description(),
|
| - cricket::MEDIA_TYPE_VIDEO));
|
| -
|
| - SetLocalDescriptionWithoutError(updated_answer.release());
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestSessionContentError) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - const std::string session_id_orig = offer->session_id();
|
| - const std::string session_version_orig = offer->session_version();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - video_channel_ = media_engine_->GetVideoChannel(0);
|
| - video_channel_->set_fail_set_send_codecs(true);
|
| -
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionAnswerExpectError("ERROR_CONTENT", answer);
|
| -
|
| - // Test that after a content error, setting any description will
|
| - // result in an error.
|
| - video_channel_->set_fail_set_send_codecs(false);
|
| - answer = CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionExpectError("", "ERROR_CONTENT", answer);
|
| - offer = CreateRemoteOffer();
|
| - SetLocalDescriptionExpectError("", "ERROR_CONTENT", offer);
|
| -}
|
| -
|
| -// Runs the loopback call test with BUNDLE and STUN disabled.
|
| -TEST_F(WebRtcSessionTest, TestIceStatesBasic) {
|
| - // Lets try with only UDP ports.
|
| - allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
|
| - cricket::PORTALLOCATOR_DISABLE_STUN |
|
| - cricket::PORTALLOCATOR_DISABLE_RELAY);
|
| - TestLoopbackCall();
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestIceStatesBasicIPv6) {
|
| - allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
|
| - cricket::PORTALLOCATOR_DISABLE_STUN |
|
| - cricket::PORTALLOCATOR_ENABLE_IPV6 |
|
| - cricket::PORTALLOCATOR_DISABLE_RELAY);
|
| -
|
| - // best connection is IPv6 since it has higher network preference.
|
| - LoopbackNetworkConfiguration config;
|
| - config.test_ipv6_network_ = true;
|
| - config.best_connection_after_initial_ice_converged_ =
|
| - LoopbackNetworkConfiguration::ExpectedBestConnection(0, 1);
|
| -
|
| - TestLoopbackCall(config);
|
| -}
|
| -
|
| -// Runs the loopback call test with BUNDLE and STUN enabled.
|
| -TEST_F(WebRtcSessionTest, TestIceStatesBundle) {
|
| - allocator_->set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
|
| - cricket::PORTALLOCATOR_DISABLE_RELAY);
|
| - TestLoopbackCall();
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestRtpDataChannel) {
|
| - configuration_.enable_rtp_data_channel = true;
|
| - Init();
|
| - SetLocalDescriptionWithDataChannel();
|
| - ASSERT_TRUE(data_engine_);
|
| - EXPECT_NE(nullptr, data_engine_->GetChannel(0));
|
| -}
|
| -
|
| -TEST_P(WebRtcSessionTest, TestRtpDataChannelConstraintTakesPrecedence) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| -
|
| - configuration_.enable_rtp_data_channel = true;
|
| - options_.disable_sctp_data_channels = false;
|
| -
|
| - InitWithDtls(GetParam());
|
| -
|
| - SetLocalDescriptionWithDataChannel();
|
| - EXPECT_NE(nullptr, data_engine_->GetChannel(0));
|
| -}
|
| -
|
| -// Test that sctp_content_name/sctp_transport_name (used for stats) are correct
|
| -// before and after BUNDLE is negotiated.
|
| -TEST_P(WebRtcSessionTest, SctpContentAndTransportName) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - SetFactoryDtlsSrtp();
|
| - InitWithDtls(GetParam());
|
| -
|
| - // Initially these fields should be empty.
|
| - EXPECT_FALSE(session_->sctp_content_name());
|
| - EXPECT_FALSE(session_->sctp_transport_name());
|
| -
|
| - // Create offer with audio/video/data.
|
| - // Default bundle policy is "balanced", so data should be using its own
|
| - // transport.
|
| - SendAudioVideoStream1();
|
| - CreateDataChannel();
|
| - InitiateCall();
|
| - ASSERT_TRUE(session_->sctp_content_name());
|
| - ASSERT_TRUE(session_->sctp_transport_name());
|
| - EXPECT_EQ("data", *session_->sctp_content_name());
|
| - EXPECT_EQ("data", *session_->sctp_transport_name());
|
| -
|
| - // Create answer that finishes BUNDLE negotiation, which means everything
|
| - // should be bundled on the first transport (audio).
|
| - cricket::MediaSessionOptions answer_options;
|
| - answer_options.recv_video = true;
|
| - answer_options.bundle_enabled = true;
|
| - answer_options.data_channel_type = cricket::DCT_SCTP;
|
| - SetRemoteDescriptionWithoutError(CreateRemoteAnswer(
|
| - session_->local_description(), answer_options, cricket::SEC_DISABLED));
|
| - ASSERT_TRUE(session_->sctp_content_name());
|
| - ASSERT_TRUE(session_->sctp_transport_name());
|
| - EXPECT_EQ("data", *session_->sctp_content_name());
|
| - EXPECT_EQ("audio", *session_->sctp_transport_name());
|
| -}
|
| -
|
| -TEST_P(WebRtcSessionTest, TestCreateOfferWithSctpEnabledWithoutStreams) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| -
|
| - InitWithDtls(GetParam());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - EXPECT_TRUE(offer->description()->GetContentByName("data") == NULL);
|
| - EXPECT_TRUE(offer->description()->GetTransportInfoByName("data") == NULL);
|
| -}
|
| -
|
| -TEST_P(WebRtcSessionTest, TestCreateAnswerWithSctpInOfferAndNoStreams) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - SetFactoryDtlsSrtp();
|
| - InitWithDtls(GetParam());
|
| -
|
| - // Create remote offer with SCTP.
|
| - cricket::MediaSessionOptions options;
|
| - options.data_channel_type = cricket::DCT_SCTP;
|
| - JsepSessionDescription* offer =
|
| - CreateRemoteOffer(options, cricket::SEC_DISABLED);
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - // Verifies the answer contains SCTP.
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - EXPECT_TRUE(answer != NULL);
|
| - EXPECT_TRUE(answer->description()->GetContentByName("data") != NULL);
|
| - EXPECT_TRUE(answer->description()->GetTransportInfoByName("data") != NULL);
|
| -}
|
| -
|
| -// Test that if DTLS is disabled, we don't end up with an SctpTransport
|
| -// created (or an RtpDataChannel).
|
| -TEST_P(WebRtcSessionTest, TestSctpDataChannelWithoutDtls) {
|
| - configuration_.enable_dtls_srtp = rtc::Optional<bool>(false);
|
| - InitWithDtls(GetParam());
|
| -
|
| - SetLocalDescriptionWithDataChannel();
|
| - EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
|
| - EXPECT_EQ(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
|
| -}
|
| -
|
| -// Test that if DTLS is enabled, we end up with an SctpTransport created
|
| -// (and not an RtpDataChannel).
|
| -TEST_P(WebRtcSessionTest, TestSctpDataChannelWithDtls) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| -
|
| - InitWithDtls(GetParam());
|
| -
|
| - SetLocalDescriptionWithDataChannel();
|
| - EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
|
| - EXPECT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
|
| -}
|
| -
|
| -// Test that if SCTP is disabled, we don't end up with an SctpTransport
|
| -// created (or an RtpDataChannel).
|
| -TEST_P(WebRtcSessionTest, TestDisableSctpDataChannels) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - options_.disable_sctp_data_channels = true;
|
| - InitWithDtls(GetParam());
|
| -
|
| - SetLocalDescriptionWithDataChannel();
|
| - EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
|
| - EXPECT_EQ(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
|
| -}
|
| -
|
| -TEST_P(WebRtcSessionTest, TestSctpDataChannelSendPortParsing) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - const int new_send_port = 9998;
|
| - const int new_recv_port = 7775;
|
| -
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| -
|
| - // By default, don't actually add the codecs to desc_factory_; they don't
|
| - // actually get serialized for SCTP in BuildMediaDescription(). Instead,
|
| - // let the session description get parsed. That'll get the proper codecs
|
| - // into the stream.
|
| - cricket::MediaSessionOptions options;
|
| - JsepSessionDescription* offer = CreateRemoteOfferWithSctpPort(
|
| - "stream1", new_send_port, options);
|
| -
|
| - // SetRemoteDescription will take the ownership of the offer.
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - SessionDescriptionInterface* answer =
|
| - ChangeSDPSctpPort(new_recv_port, CreateAnswer());
|
| - ASSERT_TRUE(answer != NULL);
|
| -
|
| - // Now set the local description, which'll take ownership of the answer.
|
| - SetLocalDescriptionWithoutError(answer);
|
| -
|
| - // TEST PLAN: Set the port number to something new, set it in the SDP,
|
| - // and pass it all the way down.
|
| - EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
|
| - CreateDataChannel();
|
| - ASSERT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
|
| - EXPECT_EQ(
|
| - new_recv_port,
|
| - fake_sctp_transport_factory_->last_fake_sctp_transport()->local_port());
|
| - EXPECT_EQ(
|
| - new_send_port,
|
| - fake_sctp_transport_factory_->last_fake_sctp_transport()->remote_port());
|
| -}
|
| -
|
| -// Verifies that when a session's SctpTransport receives an OPEN message,
|
| -// WebRtcSession signals the SctpTransport creation request with the expected
|
| -// config.
|
| -TEST_P(WebRtcSessionTest, TestSctpDataChannelOpenMessage) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| -
|
| - InitWithDtls(GetParam());
|
| -
|
| - SetLocalDescriptionWithDataChannel();
|
| - EXPECT_EQ(nullptr, data_engine_->GetChannel(0));
|
| - ASSERT_NE(nullptr, fake_sctp_transport_factory_->last_fake_sctp_transport());
|
| -
|
| - // Make the fake SCTP transport pretend it received an OPEN message.
|
| - webrtc::DataChannelInit config;
|
| - config.id = 1;
|
| - rtc::CopyOnWriteBuffer payload;
|
| - webrtc::WriteDataChannelOpenMessage("a", config, &payload);
|
| - cricket::ReceiveDataParams params;
|
| - params.ssrc = config.id;
|
| - params.type = cricket::DMT_CONTROL;
|
| - fake_sctp_transport_factory_->last_fake_sctp_transport()->SignalDataReceived(
|
| - params, payload);
|
| -
|
| - EXPECT_EQ_WAIT("a", last_data_channel_label_, kDefaultTimeout);
|
| - EXPECT_EQ(config.id, last_data_channel_config_.id);
|
| - EXPECT_FALSE(last_data_channel_config_.negotiated);
|
| - EXPECT_EQ(webrtc::InternalDataChannelInit::kAcker,
|
| - last_data_channel_config_.open_handshake_role);
|
| -}
|
| -
|
| -TEST_P(WebRtcSessionTest, TestUsesProvidedCertificate) {
|
| - rtc::scoped_refptr<rtc::RTCCertificate> certificate =
|
| - FakeRTCCertificateGenerator::GenerateCertificate();
|
| -
|
| - configuration_.certificates.push_back(certificate);
|
| - Init();
|
| - EXPECT_TRUE_WAIT(!session_->waiting_for_certificate_for_testing(), 1000);
|
| -
|
| - EXPECT_EQ(session_->certificate_for_testing(), certificate);
|
| -}
|
| -
|
| -// Verifies that CreateOffer succeeds when CreateOffer is called before async
|
| -// identity generation is finished (even if a certificate is provided this is
|
| -// an async op).
|
| -TEST_P(WebRtcSessionTest, TestCreateOfferBeforeIdentityRequestReturnSuccess) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| -
|
| - EXPECT_TRUE(session_->waiting_for_certificate_for_testing());
|
| - SendAudioVideoStream1();
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| -
|
| - EXPECT_TRUE(offer != NULL);
|
| - VerifyNoCryptoParams(offer->description(), true);
|
| - VerifyFingerprintStatus(offer->description(), true);
|
| -}
|
| -
|
| -// Verifies that CreateAnswer succeeds when CreateOffer is called before async
|
| -// identity generation is finished (even if a certificate is provided this is
|
| -// an async op).
|
| -TEST_P(WebRtcSessionTest, TestCreateAnswerBeforeIdentityRequestReturnSuccess) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - std::unique_ptr<JsepSessionDescription> offer(
|
| - CreateRemoteOffer(options, cricket::SEC_DISABLED));
|
| - ASSERT_TRUE(offer.get() != NULL);
|
| - SetRemoteDescriptionWithoutError(offer.release());
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
|
| - EXPECT_TRUE(answer != NULL);
|
| - VerifyNoCryptoParams(answer->description(), true);
|
| - VerifyFingerprintStatus(answer->description(), true);
|
| -}
|
| -
|
| -// Verifies that CreateOffer succeeds when CreateOffer is called after async
|
| -// identity generation is finished (even if a certificate is provided this is
|
| -// an async op).
|
| -TEST_P(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnSuccess) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| -
|
| - EXPECT_TRUE_WAIT(!session_->waiting_for_certificate_for_testing(), 1000);
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - EXPECT_TRUE(offer != NULL);
|
| -}
|
| -
|
| -// Verifies that CreateOffer fails when CreateOffer is called after async
|
| -// identity generation fails.
|
| -TEST_F(WebRtcSessionTest, TestCreateOfferAfterIdentityRequestReturnFailure) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtlsIdentityGenFail();
|
| -
|
| - EXPECT_TRUE_WAIT(!session_->waiting_for_certificate_for_testing(), 1000);
|
| -
|
| - std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
|
| - EXPECT_TRUE(offer == NULL);
|
| -}
|
| -
|
| -// Verifies that CreateOffer succeeds when Multiple CreateOffer calls are made
|
| -// before async identity generation is finished.
|
| -TEST_P(WebRtcSessionTest,
|
| - TestMultipleCreateOfferBeforeIdentityRequestReturnSuccess) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - VerifyMultipleAsyncCreateDescription(GetParam(),
|
| - CreateSessionDescriptionRequest::kOffer);
|
| -}
|
| -
|
| -// Verifies that CreateOffer fails when Multiple CreateOffer calls are made
|
| -// before async identity generation fails.
|
| -TEST_F(WebRtcSessionTest,
|
| - TestMultipleCreateOfferBeforeIdentityRequestReturnFailure) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - VerifyMultipleAsyncCreateDescriptionIdentityGenFailure(
|
| - CreateSessionDescriptionRequest::kOffer);
|
| -}
|
| -
|
| -// Verifies that CreateAnswer succeeds when Multiple CreateAnswer calls are made
|
| -// before async identity generation is finished.
|
| -TEST_P(WebRtcSessionTest,
|
| - TestMultipleCreateAnswerBeforeIdentityRequestReturnSuccess) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - VerifyMultipleAsyncCreateDescription(
|
| - GetParam(), CreateSessionDescriptionRequest::kAnswer);
|
| -}
|
| -
|
| -// Verifies that CreateAnswer fails when Multiple CreateAnswer calls are made
|
| -// before async identity generation fails.
|
| -TEST_F(WebRtcSessionTest,
|
| - TestMultipleCreateAnswerBeforeIdentityRequestReturnFailure) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - VerifyMultipleAsyncCreateDescriptionIdentityGenFailure(
|
| - CreateSessionDescriptionRequest::kAnswer);
|
| -}
|
| -
|
| -// Verifies that setRemoteDescription fails when DTLS is disabled and the remote
|
| -// offer has no SDES crypto but only DTLS fingerprint.
|
| -TEST_F(WebRtcSessionTest, TestSetRemoteOfferFailIfDtlsDisabledAndNoCrypto) {
|
| - // Init without DTLS.
|
| - Init();
|
| - // Create a remote offer with secured transport disabled.
|
| - cricket::MediaSessionOptions options;
|
| - JsepSessionDescription* offer(CreateRemoteOffer(
|
| - options, cricket::SEC_DISABLED));
|
| - // Adds a DTLS fingerprint to the remote offer.
|
| - cricket::SessionDescription* sdp = offer->description();
|
| - TransportInfo* audio = sdp->GetTransportInfoByName("audio");
|
| - ASSERT_TRUE(audio != NULL);
|
| - ASSERT_TRUE(audio->description.identity_fingerprint.get() == NULL);
|
| - audio->description.identity_fingerprint.reset(
|
| - rtc::SSLFingerprint::CreateFromRfc4572(
|
| - rtc::DIGEST_SHA_256, kFakeDtlsFingerprint));
|
| - SetRemoteDescriptionOfferExpectError(kSdpWithoutSdesCrypto,
|
| - offer);
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestCombinedAudioVideoBweConstraint) {
|
| - configuration_.combined_audio_video_bwe = rtc::Optional<bool>(true);
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| -
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - voice_channel_ = media_engine_->GetVoiceChannel(0);
|
| -
|
| - ASSERT_TRUE(voice_channel_ != NULL);
|
| - const cricket::AudioOptions& audio_options = voice_channel_->options();
|
| - EXPECT_EQ(rtc::Optional<bool>(true), audio_options.combined_audio_video_bwe);
|
| -}
|
| -
|
| -// Tests that we can renegotiate new media content with ICE candidates in the
|
| -// new remote SDP.
|
| -TEST_P(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesInSdp) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| -
|
| - SendAudioOnlyStream2();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
|
| -
|
| - cricket::Candidate candidate1;
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
|
| - candidate1.set_component(1);
|
| - JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
|
| - candidate1);
|
| - EXPECT_TRUE(offer->AddCandidate(&ice_candidate));
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// Tests that we can renegotiate new media content with ICE candidates separated
|
| -// from the remote SDP.
|
| -TEST_P(WebRtcSessionTest, TestRenegotiateNewMediaWithCandidatesSeparated) {
|
| - MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
|
| - InitWithDtls(GetParam());
|
| - SetFactoryDtlsSrtp();
|
| -
|
| - SendAudioOnlyStream2();
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - SessionDescriptionInterface* answer = CreateRemoteAnswer(offer);
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_video = true;
|
| - offer = CreateRemoteOffer(options, cricket::SEC_DISABLED);
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - cricket::Candidate candidate1;
|
| - candidate1.set_address(rtc::SocketAddress("1.1.1.1", 5000));
|
| - candidate1.set_component(1);
|
| - JsepIceCandidate ice_candidate(kMediaContentName1, kMediaContentIndex1,
|
| - candidate1);
|
| - EXPECT_TRUE(session_->ProcessIceMessage(&ice_candidate));
|
| -
|
| - answer = CreateAnswer();
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -#ifdef HAVE_QUIC
|
| -TEST_P(WebRtcSessionTest, TestNegotiateQuic) {
|
| - configuration_.enable_quic = true;
|
| - InitWithDtls(GetParam());
|
| - EXPECT_TRUE(session_->data_channel_type() == cricket::DCT_QUIC);
|
| - SessionDescriptionInterface* offer = CreateOffer();
|
| - ASSERT_TRUE(offer);
|
| - ASSERT_TRUE(offer->description());
|
| - SetLocalDescriptionWithoutError(offer);
|
| - cricket::MediaSessionOptions options;
|
| - options.recv_audio = true;
|
| - options.recv_video = true;
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(offer, options, cricket::SEC_DISABLED);
|
| - ASSERT_TRUE(answer);
|
| - ASSERT_TRUE(answer->description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -}
|
| -#endif // HAVE_QUIC
|
| -
|
| -// Tests that RTX codec is removed from the answer when it isn't supported
|
| -// by local side.
|
| -TEST_F(WebRtcSessionTest, TestRtxRemovedByCreateAnswer) {
|
| - Init();
|
| - SendAudioVideoStream1();
|
| - std::string offer_sdp(kSdpWithRtx);
|
| -
|
| - SessionDescriptionInterface* offer =
|
| - CreateSessionDescription(JsepSessionDescription::kOffer, offer_sdp, NULL);
|
| - EXPECT_TRUE(offer->ToString(&offer_sdp));
|
| -
|
| - // Offer SDP contains the RTX codec.
|
| - EXPECT_TRUE(ContainsVideoCodecWithName(offer, "rtx"));
|
| - SetRemoteDescriptionWithoutError(offer);
|
| -
|
| - SessionDescriptionInterface* answer = CreateAnswer();
|
| - // Answer SDP does not contain the RTX codec.
|
| - EXPECT_FALSE(ContainsVideoCodecWithName(answer, "rtx"));
|
| - SetLocalDescriptionWithoutError(answer);
|
| -}
|
| -
|
| -// This verifies that the voice channel after bundle has both options from video
|
| -// and voice channels.
|
| -TEST_F(WebRtcSessionTest, TestSetSocketOptionBeforeBundle) {
|
| - InitWithBundlePolicy(PeerConnectionInterface::kBundlePolicyBalanced);
|
| - SendAudioVideoStream1();
|
| -
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.use_rtp_mux = true;
|
| -
|
| - SessionDescriptionInterface* offer = CreateOffer(options);
|
| - SetLocalDescriptionWithoutError(offer);
|
| -
|
| - session_->video_channel()->SetOption(cricket::BaseChannel::ST_RTP,
|
| - rtc::Socket::Option::OPT_SNDBUF, 4000);
|
| -
|
| - session_->voice_channel()->SetOption(cricket::BaseChannel::ST_RTP,
|
| - rtc::Socket::Option::OPT_RCVBUF, 8000);
|
| -
|
| - int option_val;
|
| - EXPECT_TRUE(session_->video_rtp_transport_channel()->GetOption(
|
| - rtc::Socket::Option::OPT_SNDBUF, &option_val));
|
| - EXPECT_EQ(4000, option_val);
|
| - EXPECT_FALSE(session_->voice_rtp_transport_channel()->GetOption(
|
| - rtc::Socket::Option::OPT_SNDBUF, &option_val));
|
| -
|
| - EXPECT_TRUE(session_->voice_rtp_transport_channel()->GetOption(
|
| - rtc::Socket::Option::OPT_RCVBUF, &option_val));
|
| - EXPECT_EQ(8000, option_val);
|
| - EXPECT_FALSE(session_->video_rtp_transport_channel()->GetOption(
|
| - rtc::Socket::Option::OPT_RCVBUF, &option_val));
|
| -
|
| - EXPECT_NE(session_->voice_rtp_transport_channel(),
|
| - session_->video_rtp_transport_channel());
|
| -
|
| - SendAudioVideoStream2();
|
| - SessionDescriptionInterface* answer =
|
| - CreateRemoteAnswer(session_->local_description());
|
| - SetRemoteDescriptionWithoutError(answer);
|
| -
|
| - EXPECT_TRUE(session_->voice_rtp_transport_channel()->GetOption(
|
| - rtc::Socket::Option::OPT_SNDBUF, &option_val));
|
| - EXPECT_EQ(4000, option_val);
|
| -
|
| - EXPECT_TRUE(session_->voice_rtp_transport_channel()->GetOption(
|
| - rtc::Socket::Option::OPT_RCVBUF, &option_val));
|
| - EXPECT_EQ(8000, option_val);
|
| -}
|
| -
|
| -// Test creating a session, request multiple offers, destroy the session
|
| -// and make sure we got success/failure callbacks for all of the requests.
|
| -// Background: crbug.com/507307
|
| -TEST_F(WebRtcSessionTest, CreateOffersAndShutdown) {
|
| - Init();
|
| -
|
| - rtc::scoped_refptr<WebRtcSessionCreateSDPObserverForTest> observers[100];
|
| - PeerConnectionInterface::RTCOfferAnswerOptions options;
|
| - options.offer_to_receive_audio =
|
| - RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
|
| - cricket::MediaSessionOptions session_options;
|
| - session_options.recv_audio = true;
|
| -
|
| - for (auto& o : observers) {
|
| - o = new WebRtcSessionCreateSDPObserverForTest();
|
| - session_->CreateOffer(o, options, session_options);
|
| - }
|
| -
|
| - session_.reset();
|
| -
|
| - for (auto& o : observers) {
|
| - // We expect to have received a notification now even if the session was
|
| - // terminated. The offer creation may or may not have succeeded, but we
|
| - // must have received a notification which, so the only invalid state
|
| - // is kInit.
|
| - EXPECT_NE(WebRtcSessionCreateSDPObserverForTest::kInit, o->state());
|
| - }
|
| -}
|
| -
|
| -TEST_F(WebRtcSessionTest, TestPacketOptionsAndOnPacketSent) {
|
| - TestPacketOptions();
|
| -}
|
| -
|
| -// Make sure the signal from "GetOnDestroyedSignal()" fires when the session
|
| -// is destroyed.
|
| -TEST_F(WebRtcSessionTest, TestOnDestroyedSignal) {
|
| - Init();
|
| - session_.reset();
|
| - EXPECT_TRUE(session_destroyed_);
|
| -}
|
| -
|
| -// TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled. That test
|
| -// currently fails because upon disconnection and reconnection OnIceComplete is
|
| -// called more than once without returning to IceGatheringGathering.
|
| -
|
| -INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
|
| - WebRtcSessionTest,
|
| - testing::Values(ALREADY_GENERATED,
|
| - DTLS_IDENTITY_STORE));
|
|
|
Chromium Code Reviews
Issue 2514883002:
Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)
