diff options
Diffstat (limited to 'chromium/third_party/libjingle/source/talk/app/webrtc/peerconnectionendtoend_unittest.cc')
| -rw-r--r-- | chromium/third_party/libjingle/source/talk/app/webrtc/peerconnectionendtoend_unittest.cc | 200 |
1 files changed, 199 insertions, 1 deletions
diff --git a/chromium/third_party/libjingle/source/talk/app/webrtc/peerconnectionendtoend_unittest.cc b/chromium/third_party/libjingle/source/talk/app/webrtc/peerconnectionendtoend_unittest.cc index da3c03da4eb..f701e0635f0 100644 --- a/chromium/third_party/libjingle/source/talk/app/webrtc/peerconnectionendtoend_unittest.cc +++ b/chromium/third_party/libjingle/source/talk/app/webrtc/peerconnectionendtoend_unittest.cc @@ -26,6 +26,7 @@ */ #include "talk/app/webrtc/test/peerconnectiontestwrapper.h" +#include "talk/app/webrtc/test/mockpeerconnectionobservers.h" #include "talk/base/gunit.h" #include "talk/base/logging.h" #include "talk/base/ssladapter.h" @@ -33,6 +34,13 @@ #include "talk/base/stringencode.h" #include "talk/base/stringutils.h" +#define MAYBE_SKIP_TEST(feature) \ + if (!(feature())) { \ + LOG(LS_INFO) << "Feature disabled... skipping"; \ + return; \ + } + +using webrtc::DataChannelInterface; using webrtc::FakeConstraints; using webrtc::MediaConstraintsInterface; using webrtc::MediaStreamInterface; @@ -42,6 +50,7 @@ namespace { const char kExternalGiceUfrag[] = "1234567890123456"; const char kExternalGicePwd[] = "123456789012345678901234"; +const size_t kMaxWait = 10000; void RemoveLinesFromSdp(const std::string& line_start, std::string* sdp) { @@ -117,6 +126,9 @@ class PeerConnectionEndToEndTest : public sigslot::has_slots<>, public testing::Test { public: + typedef std::vector<talk_base::scoped_refptr<DataChannelInterface> > + DataChannelList; + PeerConnectionEndToEndTest() : caller_(new talk_base::RefCountedObject<PeerConnectionTestWrapper>( "caller")), @@ -133,6 +145,11 @@ class PeerConnectionEndToEndTest EXPECT_TRUE(caller_->CreatePc(pc_constraints)); EXPECT_TRUE(callee_->CreatePc(pc_constraints)); PeerConnectionTestWrapper::Connect(caller_.get(), callee_.get()); + + caller_->SignalOnDataChannel.connect( + this, &PeerConnectionEndToEndTest::OnCallerAddedDataChanel); + callee_->SignalOnDataChannel.connect( + this, &PeerConnectionEndToEndTest::OnCalleeAddedDataChannel); } void GetAndAddUserMedia() { @@ -158,6 +175,11 @@ class PeerConnectionEndToEndTest callee_->WaitForCallEstablished(); } + void WaitForConnection() { + caller_->WaitForConnection(); + callee_->WaitForConnection(); + } + void SetupLegacySdpConverter() { caller_->SignalOnSdpCreated.connect( this, &PeerConnectionEndToEndTest::ConvertToLegacySdp); @@ -189,6 +211,57 @@ class PeerConnectionEndToEndTest LOG(LS_INFO) << "AddGiceCredsToCandidate: " << *sdp; } + void OnCallerAddedDataChanel(DataChannelInterface* dc) { + caller_signaled_data_channels_.push_back(dc); + } + + void OnCalleeAddedDataChannel(DataChannelInterface* dc) { + callee_signaled_data_channels_.push_back(dc); + } + + // Tests that |dc1| and |dc2| can send to and receive from each other. + void TestDataChannelSendAndReceive( + DataChannelInterface* dc1, DataChannelInterface* dc2) { + talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc1_observer( + new webrtc::MockDataChannelObserver(dc1)); + + talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc2_observer( + new webrtc::MockDataChannelObserver(dc2)); + + static const std::string kDummyData = "abcdefg"; + webrtc::DataBuffer buffer(kDummyData); + EXPECT_TRUE(dc1->Send(buffer)); + EXPECT_EQ_WAIT(kDummyData, dc2_observer->last_message(), kMaxWait); + + EXPECT_TRUE(dc2->Send(buffer)); + EXPECT_EQ_WAIT(kDummyData, dc1_observer->last_message(), kMaxWait); + + EXPECT_EQ(1U, dc1_observer->received_message_count()); + EXPECT_EQ(1U, dc2_observer->received_message_count()); + } + + void WaitForDataChannelsToOpen(DataChannelInterface* local_dc, + const DataChannelList& remote_dc_list, + size_t remote_dc_index) { + EXPECT_EQ_WAIT(DataChannelInterface::kOpen, local_dc->state(), kMaxWait); + + EXPECT_TRUE_WAIT(remote_dc_list.size() > remote_dc_index, kMaxWait); + EXPECT_EQ_WAIT(DataChannelInterface::kOpen, + remote_dc_list[remote_dc_index]->state(), + kMaxWait); + EXPECT_EQ(local_dc->id(), remote_dc_list[remote_dc_index]->id()); + } + + void CloseDataChannels(DataChannelInterface* local_dc, + const DataChannelList& remote_dc_list, + size_t remote_dc_index) { + local_dc->Close(); + EXPECT_EQ_WAIT(DataChannelInterface::kClosed, local_dc->state(), kMaxWait); + EXPECT_EQ_WAIT(DataChannelInterface::kClosed, + remote_dc_list[remote_dc_index]->state(), + kMaxWait); + } + ~PeerConnectionEndToEndTest() { talk_base::CleanupSSL(); } @@ -196,6 +269,8 @@ class PeerConnectionEndToEndTest protected: talk_base::scoped_refptr<PeerConnectionTestWrapper> caller_; talk_base::scoped_refptr<PeerConnectionTestWrapper> callee_; + DataChannelList caller_signaled_data_channels_; + DataChannelList callee_signaled_data_channels_; }; // Disable for TSan v2, see @@ -209,7 +284,8 @@ TEST_F(PeerConnectionEndToEndTest, Call) { WaitForCallEstablished(); } -TEST_F(PeerConnectionEndToEndTest, CallWithLegacySdp) { +// Disabled per b/14899892 +TEST_F(PeerConnectionEndToEndTest, DISABLED_CallWithLegacySdp) { FakeConstraints pc_constraints; pc_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, false); @@ -221,4 +297,126 @@ TEST_F(PeerConnectionEndToEndTest, CallWithLegacySdp) { WaitForCallEstablished(); } +// Verifies that a DataChannel created before the negotiation can transition to +// "OPEN" and transfer data. +TEST_F(PeerConnectionEndToEndTest, CreateDataChannelBeforeNegotiate) { + MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp); + + CreatePcs(); + + webrtc::DataChannelInit init; + talk_base::scoped_refptr<DataChannelInterface> caller_dc( + caller_->CreateDataChannel("data", init)); + talk_base::scoped_refptr<DataChannelInterface> callee_dc( + callee_->CreateDataChannel("data", init)); + + Negotiate(); + WaitForConnection(); + + WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 0); + WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); + + TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[0]); + TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); + + CloseDataChannels(caller_dc, callee_signaled_data_channels_, 0); + CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); +} + +// Verifies that a DataChannel created after the negotiation can transition to +// "OPEN" and transfer data. +TEST_F(PeerConnectionEndToEndTest, CreateDataChannelAfterNegotiate) { + MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp); + + CreatePcs(); + + webrtc::DataChannelInit init; + + // This DataChannel is for creating the data content in the negotiation. + talk_base::scoped_refptr<DataChannelInterface> dummy( + caller_->CreateDataChannel("data", init)); + Negotiate(); + WaitForConnection(); + + // Creates new DataChannels after the negotiation and verifies their states. + talk_base::scoped_refptr<DataChannelInterface> caller_dc( + caller_->CreateDataChannel("hello", init)); + talk_base::scoped_refptr<DataChannelInterface> callee_dc( + callee_->CreateDataChannel("hello", init)); + + WaitForDataChannelsToOpen(caller_dc, callee_signaled_data_channels_, 1); + WaitForDataChannelsToOpen(callee_dc, caller_signaled_data_channels_, 0); + + TestDataChannelSendAndReceive(caller_dc, callee_signaled_data_channels_[1]); + TestDataChannelSendAndReceive(callee_dc, caller_signaled_data_channels_[0]); + + CloseDataChannels(caller_dc, callee_signaled_data_channels_, 1); + CloseDataChannels(callee_dc, caller_signaled_data_channels_, 0); +} + +// Verifies that DataChannel IDs are even/odd based on the DTLS roles. +TEST_F(PeerConnectionEndToEndTest, DataChannelIdAssignment) { + MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp); + + CreatePcs(); + + webrtc::DataChannelInit init; + talk_base::scoped_refptr<DataChannelInterface> caller_dc_1( + caller_->CreateDataChannel("data", init)); + talk_base::scoped_refptr<DataChannelInterface> callee_dc_1( + callee_->CreateDataChannel("data", init)); + + Negotiate(); + WaitForConnection(); + + EXPECT_EQ(1U, caller_dc_1->id() % 2); + EXPECT_EQ(0U, callee_dc_1->id() % 2); + + talk_base::scoped_refptr<DataChannelInterface> caller_dc_2( + caller_->CreateDataChannel("data", init)); + talk_base::scoped_refptr<DataChannelInterface> callee_dc_2( + callee_->CreateDataChannel("data", init)); + + EXPECT_EQ(1U, caller_dc_2->id() % 2); + EXPECT_EQ(0U, callee_dc_2->id() % 2); +} + +// Verifies that the message is received by the right remote DataChannel when +// there are multiple DataChannels. +TEST_F(PeerConnectionEndToEndTest, + MessageTransferBetweenTwoPairsOfDataChannels) { + MAYBE_SKIP_TEST(talk_base::SSLStreamAdapter::HaveDtlsSrtp); + + CreatePcs(); + + webrtc::DataChannelInit init; + + talk_base::scoped_refptr<DataChannelInterface> caller_dc_1( + caller_->CreateDataChannel("data", init)); + talk_base::scoped_refptr<DataChannelInterface> caller_dc_2( + caller_->CreateDataChannel("data", init)); + + Negotiate(); + WaitForConnection(); + WaitForDataChannelsToOpen(caller_dc_1, callee_signaled_data_channels_, 0); + WaitForDataChannelsToOpen(caller_dc_2, callee_signaled_data_channels_, 1); + + talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc_1_observer( + new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[0])); + + talk_base::scoped_ptr<webrtc::MockDataChannelObserver> dc_2_observer( + new webrtc::MockDataChannelObserver(callee_signaled_data_channels_[1])); + + const std::string message_1 = "hello 1"; + const std::string message_2 = "hello 2"; + + caller_dc_1->Send(webrtc::DataBuffer(message_1)); + EXPECT_EQ_WAIT(message_1, dc_1_observer->last_message(), kMaxWait); + + caller_dc_2->Send(webrtc::DataBuffer(message_2)); + EXPECT_EQ_WAIT(message_2, dc_2_observer->last_message(), kMaxWait); + + EXPECT_EQ(1U, dc_1_observer->received_message_count()); + EXPECT_EQ(1U, dc_2_observer->received_message_count()); +} #endif // if !defined(THREAD_SANITIZER) |