xref: /aosp_15_r20/external/webrtc/pc/data_channel_integrationtest.cc (revision d9f758449e529ab9291ac668be2861e7a55c2422) 
1 /*
2  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include <stdint.h>
12 
13 #include <cstdlib>
14 #include <iterator>
15 #include <string>
16 #include <tuple>
17 #include <vector>
18 
19 #include "absl/algorithm/container.h"
20 #include "absl/types/optional.h"
21 #include "api/data_channel_interface.h"
22 #include "api/dtls_transport_interface.h"
23 #include "api/peer_connection_interface.h"
24 #include "api/scoped_refptr.h"
25 #include "api/sctp_transport_interface.h"
26 #include "api/stats/rtc_stats_report.h"
27 #include "api/stats/rtcstats_objects.h"
28 #include "api/units/time_delta.h"
29 #include "p2p/base/transport_description.h"
30 #include "p2p/base/transport_info.h"
31 #include "pc/media_session.h"
32 #include "pc/session_description.h"
33 #include "pc/test/integration_test_helpers.h"
34 #include "pc/test/mock_peer_connection_observers.h"
35 #include "rtc_base/copy_on_write_buffer.h"
36 #include "rtc_base/fake_clock.h"
37 #include "rtc_base/gunit.h"
38 #include "rtc_base/helpers.h"
39 #include "rtc_base/logging.h"
40 #include "rtc_base/numerics/safe_conversions.h"
41 #include "rtc_base/virtual_socket_server.h"
42 #include "test/gmock.h"
43 #include "test/gtest.h"
44 
45 namespace webrtc {
46 
47 namespace {
48 
49 // All tests in this file require SCTP support.
50 #ifdef WEBRTC_HAVE_SCTP
51 
52 #if defined(WEBRTC_ANDROID)
53 // Disable heavy tests running on low-end Android devices.
54 #define DISABLED_ON_ANDROID(t) DISABLED_##t
55 #else
56 #define DISABLED_ON_ANDROID(t) t
57 #endif
58 
59 class DataChannelIntegrationTest
60     : public PeerConnectionIntegrationBaseTest,
61       public ::testing::WithParamInterface<std::tuple<SdpSemantics, bool>> {
62  protected:
DataChannelIntegrationTest()63   DataChannelIntegrationTest()
64       : PeerConnectionIntegrationBaseTest(std::get<0>(GetParam())),
65         allow_media_(std::get<1>(GetParam())) {}
allow_media()66   bool allow_media() { return allow_media_; }
67 
CreatePeerConnectionWrappers()68   bool CreatePeerConnectionWrappers() {
69     if (allow_media_) {
70       return PeerConnectionIntegrationBaseTest::CreatePeerConnectionWrappers();
71     }
72     return PeerConnectionIntegrationBaseTest::
73         CreatePeerConnectionWrappersWithoutMediaEngine();
74   }
75 
76  private:
77   // True if media is allowed to be added
78   const bool allow_media_;
79 };
80 
81 // Fake clock must be set before threads are started to prevent race on
82 // Set/GetClockForTesting().
83 // To achieve that, multiple inheritance is used as a mixin pattern
84 // where order of construction is finely controlled.
85 // This also ensures peerconnection is closed before switching back to non-fake
86 // clock, avoiding other races and DCHECK failures such as in rtp_sender.cc.
87 class FakeClockForTest : public rtc::ScopedFakeClock {
88  protected:
FakeClockForTest()89   FakeClockForTest() {
90     // Some things use a time of "0" as a special value, so we need to start out
91     // the fake clock at a nonzero time.
92     // TODO(deadbeef): Fix this.
93     AdvanceTime(webrtc::TimeDelta::Seconds(1));
94   }
95 
96   // Explicit handle.
FakeClock()97   ScopedFakeClock& FakeClock() { return *this; }
98 };
99 
100 class DataChannelIntegrationTestPlanB
101     : public PeerConnectionIntegrationBaseTest {
102  protected:
DataChannelIntegrationTestPlanB()103   DataChannelIntegrationTestPlanB()
104       : PeerConnectionIntegrationBaseTest(SdpSemantics::kPlanB_DEPRECATED) {}
105 };
106 
107 class DataChannelIntegrationTestUnifiedPlan
108     : public PeerConnectionIntegrationBaseTest {
109  protected:
DataChannelIntegrationTestUnifiedPlan()110   DataChannelIntegrationTestUnifiedPlan()
111       : PeerConnectionIntegrationBaseTest(SdpSemantics::kUnifiedPlan) {}
112 };
113 
MakeActiveSctpOffer(cricket::SessionDescription * desc)114 void MakeActiveSctpOffer(cricket::SessionDescription* desc) {
115   auto& transport_infos = desc->transport_infos();
116   for (auto& transport_info : transport_infos) {
117     transport_info.description.connection_role = cricket::CONNECTIONROLE_ACTIVE;
118   }
119 }
120 
121 // This test causes a PeerConnection to enter Disconnected state, and
122 // sends data on a DataChannel while disconnected.
123 // The data should be surfaced when the connection reestablishes.
TEST_P(DataChannelIntegrationTest,DataChannelWhileDisconnected)124 TEST_P(DataChannelIntegrationTest, DataChannelWhileDisconnected) {
125   CreatePeerConnectionWrappers();
126   ConnectFakeSignaling();
127   caller()->CreateDataChannel();
128   caller()->CreateAndSetAndSignalOffer();
129   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
130   ASSERT_TRUE_WAIT(callee()->data_observer(), kDefaultTimeout);
131   std::string data1 = "hello first";
132   caller()->data_channel()->Send(DataBuffer(data1));
133   EXPECT_EQ_WAIT(data1, callee()->data_observer()->last_message(),
134                  kDefaultTimeout);
135   // Cause a network outage
136   virtual_socket_server()->set_drop_probability(1.0);
137   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
138                  caller()->standardized_ice_connection_state(),
139                  kDefaultTimeout);
140   std::string data2 = "hello second";
141   caller()->data_channel()->Send(DataBuffer(data2));
142   // Remove the network outage. The connection should reestablish.
143   virtual_socket_server()->set_drop_probability(0.0);
144   EXPECT_EQ_WAIT(data2, callee()->data_observer()->last_message(),
145                  kDefaultTimeout);
146 }
147 
148 // This test causes a PeerConnection to enter Disconnected state,
149 // sends data on a DataChannel while disconnected, and then triggers
150 // an ICE restart.
151 // The data should be surfaced when the connection reestablishes.
TEST_P(DataChannelIntegrationTest,DataChannelWhileDisconnectedIceRestart)152 TEST_P(DataChannelIntegrationTest, DataChannelWhileDisconnectedIceRestart) {
153   CreatePeerConnectionWrappers();
154   ConnectFakeSignaling();
155   caller()->CreateDataChannel();
156   caller()->CreateAndSetAndSignalOffer();
157   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
158   ASSERT_TRUE_WAIT(callee()->data_observer(), kDefaultTimeout);
159   std::string data1 = "hello first";
160   caller()->data_channel()->Send(DataBuffer(data1));
161   EXPECT_EQ_WAIT(data1, callee()->data_observer()->last_message(),
162                  kDefaultTimeout);
163   // Cause a network outage
164   virtual_socket_server()->set_drop_probability(1.0);
165   ASSERT_EQ_WAIT(PeerConnectionInterface::kIceConnectionDisconnected,
166                  caller()->standardized_ice_connection_state(),
167                  kDefaultTimeout);
168   std::string data2 = "hello second";
169   caller()->data_channel()->Send(DataBuffer(data2));
170 
171   // Trigger an ICE restart. The signaling channel is not affected by
172   // the network outage.
173   caller()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
174   caller()->CreateAndSetAndSignalOffer();
175   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
176   // Remove the network outage. The connection should reestablish.
177   virtual_socket_server()->set_drop_probability(0.0);
178   EXPECT_EQ_WAIT(data2, callee()->data_observer()->last_message(),
179                  kDefaultTimeout);
180 }
181 
182 // This test sets up a call between two parties with audio, video and an SCTP
183 // data channel.
TEST_P(DataChannelIntegrationTest,EndToEndCallWithSctpDataChannel)184 TEST_P(DataChannelIntegrationTest, EndToEndCallWithSctpDataChannel) {
185   ASSERT_TRUE(CreatePeerConnectionWrappers());
186   ConnectFakeSignaling();
187   // Expect that data channel created on caller side will show up for callee as
188   // well.
189   caller()->CreateDataChannel();
190   if (allow_media()) {
191     caller()->AddAudioVideoTracks();
192     callee()->AddAudioVideoTracks();
193   }
194   caller()->CreateAndSetAndSignalOffer();
195   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
196   if (allow_media()) {
197     // Ensure the existence of the SCTP data channel didn't impede audio/video.
198     MediaExpectations media_expectations;
199     media_expectations.ExpectBidirectionalAudioAndVideo();
200     ASSERT_TRUE(ExpectNewFrames(media_expectations));
201   }
202   // Caller data channel should already exist (it created one). Callee data
203   // channel may not exist yet, since negotiation happens in-band, not in SDP.
204   ASSERT_NE(nullptr, caller()->data_channel());
205   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
206   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
207   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
208 
209   // Ensure data can be sent in both directions.
210   std::string data = "hello world";
211   caller()->data_channel()->Send(DataBuffer(data));
212   EXPECT_EQ_WAIT(data, callee()->data_observer()->last_message(),
213                  kDefaultTimeout);
214   callee()->data_channel()->Send(DataBuffer(data));
215   EXPECT_EQ_WAIT(data, caller()->data_observer()->last_message(),
216                  kDefaultTimeout);
217 }
218 
219 // This test sets up a call between two parties with an SCTP
220 // data channel only, and sends messages of various sizes.
TEST_P(DataChannelIntegrationTest,EndToEndCallWithSctpDataChannelVariousSizes)221 TEST_P(DataChannelIntegrationTest,
222        EndToEndCallWithSctpDataChannelVariousSizes) {
223   ASSERT_TRUE(CreatePeerConnectionWrappers());
224   ConnectFakeSignaling();
225   // Expect that data channel created on caller side will show up for callee as
226   // well.
227   caller()->CreateDataChannel();
228   caller()->CreateAndSetAndSignalOffer();
229   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
230   // Caller data channel should already exist (it created one). Callee data
231   // channel may not exist yet, since negotiation happens in-band, not in SDP.
232   ASSERT_NE(nullptr, caller()->data_channel());
233   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
234   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
235   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
236 
237   for (int message_size = 1; message_size < 100000; message_size *= 2) {
238     std::string data(message_size, 'a');
239     caller()->data_channel()->Send(DataBuffer(data));
240     EXPECT_EQ_WAIT(data, callee()->data_observer()->last_message(),
241                    kDefaultTimeout);
242     callee()->data_channel()->Send(DataBuffer(data));
243     EXPECT_EQ_WAIT(data, caller()->data_observer()->last_message(),
244                    kDefaultTimeout);
245   }
246   // Specifically probe the area around the MTU size.
247   for (int message_size = 1100; message_size < 1300; message_size += 1) {
248     std::string data(message_size, 'a');
249     caller()->data_channel()->Send(DataBuffer(data));
250     EXPECT_EQ_WAIT(data, callee()->data_observer()->last_message(),
251                    kDefaultTimeout);
252     callee()->data_channel()->Send(DataBuffer(data));
253     EXPECT_EQ_WAIT(data, caller()->data_observer()->last_message(),
254                    kDefaultTimeout);
255   }
256 }
257 
258 // This test sets up a call between two parties with an SCTP
259 // data channel only, and sends empty messages
TEST_P(DataChannelIntegrationTest,EndToEndCallWithSctpDataChannelEmptyMessages)260 TEST_P(DataChannelIntegrationTest,
261        EndToEndCallWithSctpDataChannelEmptyMessages) {
262   ASSERT_TRUE(CreatePeerConnectionWrappers());
263   ConnectFakeSignaling();
264   // Expect that data channel created on caller side will show up for callee as
265   // well.
266   caller()->CreateDataChannel();
267   caller()->CreateAndSetAndSignalOffer();
268   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
269   // Caller data channel should already exist (it created one). Callee data
270   // channel may not exist yet, since negotiation happens in-band, not in SDP.
271   ASSERT_NE(nullptr, caller()->data_channel());
272   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
273   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
274   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
275 
276   // Ensure data can be sent in both directions.
277   // Sending empty string data
278   std::string data = "";
279   caller()->data_channel()->Send(DataBuffer(data));
280   EXPECT_EQ_WAIT(1u, callee()->data_observer()->received_message_count(),
281                  kDefaultTimeout);
282   EXPECT_TRUE(callee()->data_observer()->last_message().empty());
283   EXPECT_FALSE(callee()->data_observer()->messages().back().binary);
284   callee()->data_channel()->Send(DataBuffer(data));
285   EXPECT_EQ_WAIT(1u, caller()->data_observer()->received_message_count(),
286                  kDefaultTimeout);
287   EXPECT_TRUE(caller()->data_observer()->last_message().empty());
288   EXPECT_FALSE(caller()->data_observer()->messages().back().binary);
289 
290   // Sending empty binary data
291   rtc::CopyOnWriteBuffer empty_buffer;
292   caller()->data_channel()->Send(DataBuffer(empty_buffer, true));
293   EXPECT_EQ_WAIT(2u, callee()->data_observer()->received_message_count(),
294                  kDefaultTimeout);
295   EXPECT_TRUE(callee()->data_observer()->last_message().empty());
296   EXPECT_TRUE(callee()->data_observer()->messages().back().binary);
297   callee()->data_channel()->Send(DataBuffer(empty_buffer, true));
298   EXPECT_EQ_WAIT(2u, caller()->data_observer()->received_message_count(),
299                  kDefaultTimeout);
300   EXPECT_TRUE(caller()->data_observer()->last_message().empty());
301   EXPECT_TRUE(caller()->data_observer()->messages().back().binary);
302 }
303 
TEST_P(DataChannelIntegrationTest,EndToEndCallWithSctpDataChannelLowestSafeMtu)304 TEST_P(DataChannelIntegrationTest,
305        EndToEndCallWithSctpDataChannelLowestSafeMtu) {
306   // The lowest payload size limit that's tested and found safe for this
307   // application. Note that this is not the safe limit under all conditions;
308   // in particular, the default is not the largest DTLS signature, and
309   // this test does not use TURN.
310   const size_t kLowestSafePayloadSizeLimit = 1225;
311 
312   ASSERT_TRUE(CreatePeerConnectionWrappers());
313   ConnectFakeSignaling();
314   // Expect that data channel created on caller side will show up for callee as
315   // well.
316   caller()->CreateDataChannel();
317   caller()->CreateAndSetAndSignalOffer();
318   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
319   // Caller data channel should already exist (it created one). Callee data
320   // channel may not exist yet, since negotiation happens in-band, not in SDP.
321   ASSERT_NE(nullptr, caller()->data_channel());
322   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
323   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
324   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
325 
326   virtual_socket_server()->set_max_udp_payload(kLowestSafePayloadSizeLimit);
327   for (int message_size = 1140; message_size < 1240; message_size += 1) {
328     std::string data(message_size, 'a');
329     caller()->data_channel()->Send(DataBuffer(data));
330     ASSERT_EQ_WAIT(data, callee()->data_observer()->last_message(),
331                    kDefaultTimeout);
332     callee()->data_channel()->Send(DataBuffer(data));
333     ASSERT_EQ_WAIT(data, caller()->data_observer()->last_message(),
334                    kDefaultTimeout);
335   }
336 }
337 
338 // This test verifies that lowering the MTU of the connection will cause
339 // the datachannel to not transmit reliably.
340 // The purpose of this test is to ensure that we know how a too-small MTU
341 // error manifests itself.
TEST_P(DataChannelIntegrationTest,EndToEndCallWithSctpDataChannelHarmfulMtu)342 TEST_P(DataChannelIntegrationTest, EndToEndCallWithSctpDataChannelHarmfulMtu) {
343   // The lowest payload size limit that's tested and found safe for this
344   // application in this configuration (see test above).
345   const size_t kLowestSafePayloadSizeLimit = 1225;
346   // The size of the smallest message that fails to be delivered.
347   const size_t kMessageSizeThatIsNotDelivered = 1157;
348 
349   ASSERT_TRUE(CreatePeerConnectionWrappers());
350   ConnectFakeSignaling();
351   caller()->CreateDataChannel();
352   caller()->CreateAndSetAndSignalOffer();
353   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
354   ASSERT_NE(nullptr, caller()->data_channel());
355   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
356   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
357   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
358 
359   virtual_socket_server()->set_max_udp_payload(kLowestSafePayloadSizeLimit - 1);
360   // Probe for an undelivered or slowly delivered message. The exact
361   // size limit seems to be dependent on the message history, so make the
362   // code easily able to find the current value.
363   bool failure_seen = false;
364   for (size_t message_size = 1110; message_size < 1400; message_size++) {
365     const size_t message_count =
366         callee()->data_observer()->received_message_count();
367     const std::string data(message_size, 'a');
368     caller()->data_channel()->Send(DataBuffer(data));
369     // Wait a very short time for the message to be delivered.
370     // Note: Waiting only 10 ms is too short for Windows bots; they will
371     // flakily fail at a random frame.
372     WAIT(callee()->data_observer()->received_message_count() > message_count,
373          100);
374     if (callee()->data_observer()->received_message_count() == message_count) {
375       ASSERT_EQ(kMessageSizeThatIsNotDelivered, message_size);
376       failure_seen = true;
377       break;
378     }
379   }
380   ASSERT_TRUE(failure_seen);
381 }
382 
383 // Ensure that when the callee closes an SCTP data channel, the closing
384 // procedure results in the data channel being closed for the caller as well.
TEST_P(DataChannelIntegrationTest,CalleeClosesSctpDataChannel)385 TEST_P(DataChannelIntegrationTest, CalleeClosesSctpDataChannel) {
386   // Same procedure as above test.
387   ASSERT_TRUE(CreatePeerConnectionWrappers());
388   ConnectFakeSignaling();
389   caller()->CreateDataChannel();
390   if (allow_media()) {
391     caller()->AddAudioVideoTracks();
392     callee()->AddAudioVideoTracks();
393   }
394   caller()->CreateAndSetAndSignalOffer();
395   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
396   ASSERT_NE(nullptr, caller()->data_channel());
397   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
398   ASSERT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
399   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
400 
401   // Close the data channel on the callee side, and wait for it to reach the
402   // "closed" state on both sides.
403   callee()->data_channel()->Close();
404 
405   DataChannelInterface::DataState expected_states[] = {
406       DataChannelInterface::DataState::kConnecting,
407       DataChannelInterface::DataState::kOpen,
408       DataChannelInterface::DataState::kClosing,
409       DataChannelInterface::DataState::kClosed};
410 
411   EXPECT_EQ_WAIT(DataChannelInterface::DataState::kClosed,
412                  caller()->data_observer()->state(), kDefaultTimeout);
413   EXPECT_THAT(caller()->data_observer()->states(),
414               ::testing::ElementsAreArray(expected_states));
415 
416   EXPECT_EQ_WAIT(DataChannelInterface::DataState::kClosed,
417                  callee()->data_observer()->state(), kDefaultTimeout);
418   EXPECT_THAT(callee()->data_observer()->states(),
419               ::testing::ElementsAreArray(expected_states));
420 }
421 
TEST_P(DataChannelIntegrationTest,SctpDataChannelConfigSentToOtherSide)422 TEST_P(DataChannelIntegrationTest, SctpDataChannelConfigSentToOtherSide) {
423   ASSERT_TRUE(CreatePeerConnectionWrappers());
424   ConnectFakeSignaling();
425   webrtc::DataChannelInit init;
426   init.id = 53;
427   init.maxRetransmits = 52;
428   caller()->CreateDataChannel("data-channel", &init);
429   if (allow_media()) {
430     caller()->AddAudioVideoTracks();
431     callee()->AddAudioVideoTracks();
432   }
433   caller()->CreateAndSetAndSignalOffer();
434   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
435   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
436   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
437   // Since "negotiated" is false, the "id" parameter should be ignored.
438   EXPECT_NE(init.id, callee()->data_channel()->id());
439   EXPECT_EQ("data-channel", callee()->data_channel()->label());
440   EXPECT_EQ(init.maxRetransmits, callee()->data_channel()->maxRetransmits());
441   EXPECT_FALSE(callee()->data_channel()->negotiated());
442 }
443 
444 // Test sctp's ability to process unordered data stream, where data actually
445 // arrives out of order using simulated delays. Previously there have been some
446 // bugs in this area.
TEST_P(DataChannelIntegrationTest,StressTestUnorderedSctpDataChannel)447 TEST_P(DataChannelIntegrationTest, StressTestUnorderedSctpDataChannel) {
448   // Introduce random network delays.
449   // Otherwise it's not a true "unordered" test.
450   virtual_socket_server()->set_delay_mean(20);
451   virtual_socket_server()->set_delay_stddev(5);
452   virtual_socket_server()->UpdateDelayDistribution();
453   // Normal procedure, but with unordered data channel config.
454   ASSERT_TRUE(CreatePeerConnectionWrappers());
455   ConnectFakeSignaling();
456   webrtc::DataChannelInit init;
457   init.ordered = false;
458   caller()->CreateDataChannel(&init);
459   caller()->CreateAndSetAndSignalOffer();
460   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
461   ASSERT_NE(nullptr, caller()->data_channel());
462   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
463   ASSERT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
464   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
465 
466   static constexpr int kNumMessages = 100;
467   // Deliberately chosen to be larger than the MTU so messages get fragmented.
468   static constexpr size_t kMaxMessageSize = 4096;
469   // Create and send random messages.
470   std::vector<std::string> sent_messages;
471   for (int i = 0; i < kNumMessages; ++i) {
472     size_t length =
473         (rand() % kMaxMessageSize) + 1;  // NOLINT (rand_r instead of rand)
474     std::string message;
475     ASSERT_TRUE(rtc::CreateRandomString(length, &message));
476     caller()->data_channel()->Send(DataBuffer(message));
477     callee()->data_channel()->Send(DataBuffer(message));
478     sent_messages.push_back(message);
479   }
480 
481   // Wait for all messages to be received.
482   EXPECT_EQ_WAIT(rtc::checked_cast<size_t>(kNumMessages),
483                  caller()->data_observer()->received_message_count(),
484                  kDefaultTimeout);
485   EXPECT_EQ_WAIT(rtc::checked_cast<size_t>(kNumMessages),
486                  callee()->data_observer()->received_message_count(),
487                  kDefaultTimeout);
488 
489   // Sort and compare to make sure none of the messages were corrupted.
490   std::vector<std::string> caller_received_messages;
491   absl::c_transform(caller()->data_observer()->messages(),
492                     std::back_inserter(caller_received_messages),
493                     [](const auto& a) { return a.data; });
494 
495   std::vector<std::string> callee_received_messages;
496   absl::c_transform(callee()->data_observer()->messages(),
497                     std::back_inserter(callee_received_messages),
498                     [](const auto& a) { return a.data; });
499 
500   absl::c_sort(sent_messages);
501   absl::c_sort(caller_received_messages);
502   absl::c_sort(callee_received_messages);
503   EXPECT_EQ(sent_messages, caller_received_messages);
504   EXPECT_EQ(sent_messages, callee_received_messages);
505 }
506 
507 // Repeatedly open and close data channels on a peer connection to check that
508 // the channels are properly negotiated and SCTP stream IDs properly recycled.
TEST_P(DataChannelIntegrationTest,StressTestOpenCloseChannelNoDelay)509 TEST_P(DataChannelIntegrationTest, StressTestOpenCloseChannelNoDelay) {
510   ASSERT_TRUE(CreatePeerConnectionWrappers());
511   ConnectFakeSignaling();
512 
513   int channel_id = 0;
514   const size_t kChannelCount = 8;
515   const size_t kIterations = 10;
516   bool has_negotiated = false;
517 
518   webrtc::DataChannelInit init;
519   for (size_t repeats = 0; repeats < kIterations; ++repeats) {
520     RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;
521 
522     for (size_t i = 0; i < kChannelCount; ++i) {
523       rtc::StringBuilder sb;
524       sb << "channel-" << channel_id++;
525       caller()->CreateDataChannel(sb.Release(), &init);
526     }
527     ASSERT_EQ(caller()->data_channels().size(), kChannelCount);
528 
529     if (!has_negotiated) {
530       caller()->CreateAndSetAndSignalOffer();
531       ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
532       has_negotiated = true;
533     }
534 
535     for (size_t i = 0; i < kChannelCount; ++i) {
536       ASSERT_EQ_WAIT(caller()->data_channels()[i]->state(),
537                      DataChannelInterface::DataState::kOpen, kDefaultTimeout);
538       RTC_LOG(LS_INFO) << "Caller Channel "
539                        << caller()->data_channels()[i]->label() << " with id "
540                        << caller()->data_channels()[i]->id() << " is open.";
541     }
542     ASSERT_EQ_WAIT(callee()->data_channels().size(), kChannelCount,
543                    kDefaultTimeout);
544     for (size_t i = 0; i < kChannelCount; ++i) {
545       ASSERT_EQ_WAIT(callee()->data_channels()[i]->state(),
546                      DataChannelInterface::DataState::kOpen, kDefaultTimeout);
547       RTC_LOG(LS_INFO) << "Callee Channel "
548                        << callee()->data_channels()[i]->label() << " with id "
549                        << callee()->data_channels()[i]->id() << " is open.";
550     }
551 
552     // Closing from both sides to attempt creating races.
553     // A real application would likely only close from one side.
554     for (size_t i = 0; i < kChannelCount; ++i) {
555       if (i % 3 == 0) {
556         callee()->data_channels()[i]->Close();
557         caller()->data_channels()[i]->Close();
558       } else {
559         caller()->data_channels()[i]->Close();
560         callee()->data_channels()[i]->Close();
561       }
562     }
563 
564     for (size_t i = 0; i < kChannelCount; ++i) {
565       ASSERT_EQ_WAIT(caller()->data_channels()[i]->state(),
566                      DataChannelInterface::DataState::kClosed, kDefaultTimeout);
567       ASSERT_EQ_WAIT(callee()->data_channels()[i]->state(),
568                      DataChannelInterface::DataState::kClosed, kDefaultTimeout);
569     }
570 
571     caller()->data_channels().clear();
572     caller()->data_observers().clear();
573     callee()->data_channels().clear();
574     callee()->data_observers().clear();
575   }
576 }
577 
578 // Repeatedly open and close data channels on a peer connection to check that
579 // the channels are properly negotiated and SCTP stream IDs properly recycled.
580 // Some delay is added for better coverage.
TEST_P(DataChannelIntegrationTest,StressTestOpenCloseChannelWithDelay)581 TEST_P(DataChannelIntegrationTest, StressTestOpenCloseChannelWithDelay) {
582   // Simulate some network delay
583   virtual_socket_server()->set_delay_mean(20);
584   virtual_socket_server()->set_delay_stddev(5);
585   virtual_socket_server()->UpdateDelayDistribution();
586 
587   ASSERT_TRUE(CreatePeerConnectionWrappers());
588   ConnectFakeSignaling();
589 
590   int channel_id = 0;
591   const size_t kChannelCount = 8;
592   const size_t kIterations = 10;
593   bool has_negotiated = false;
594 
595   webrtc::DataChannelInit init;
596   for (size_t repeats = 0; repeats < kIterations; ++repeats) {
597     RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;
598 
599     for (size_t i = 0; i < kChannelCount; ++i) {
600       rtc::StringBuilder sb;
601       sb << "channel-" << channel_id++;
602       caller()->CreateDataChannel(sb.Release(), &init);
603     }
604     ASSERT_EQ(caller()->data_channels().size(), kChannelCount);
605 
606     if (!has_negotiated) {
607       caller()->CreateAndSetAndSignalOffer();
608       ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
609       has_negotiated = true;
610     }
611 
612     for (size_t i = 0; i < kChannelCount; ++i) {
613       ASSERT_EQ_WAIT(caller()->data_channels()[i]->state(),
614                      DataChannelInterface::DataState::kOpen, kDefaultTimeout);
615       RTC_LOG(LS_INFO) << "Caller Channel "
616                        << caller()->data_channels()[i]->label() << " with id "
617                        << caller()->data_channels()[i]->id() << " is open.";
618     }
619     ASSERT_EQ_WAIT(callee()->data_channels().size(), kChannelCount,
620                    kDefaultTimeout);
621     for (size_t i = 0; i < kChannelCount; ++i) {
622       ASSERT_EQ_WAIT(callee()->data_channels()[i]->state(),
623                      DataChannelInterface::DataState::kOpen, kDefaultTimeout);
624       RTC_LOG(LS_INFO) << "Callee Channel "
625                        << callee()->data_channels()[i]->label() << " with id "
626                        << callee()->data_channels()[i]->id() << " is open.";
627     }
628 
629     // Closing from both sides to attempt creating races.
630     // A real application would likely only close from one side.
631     for (size_t i = 0; i < kChannelCount; ++i) {
632       if (i % 3 == 0) {
633         callee()->data_channels()[i]->Close();
634         caller()->data_channels()[i]->Close();
635       } else {
636         caller()->data_channels()[i]->Close();
637         callee()->data_channels()[i]->Close();
638       }
639     }
640 
641     for (size_t i = 0; i < kChannelCount; ++i) {
642       ASSERT_EQ_WAIT(caller()->data_channels()[i]->state(),
643                      DataChannelInterface::DataState::kClosed, kDefaultTimeout);
644       ASSERT_EQ_WAIT(callee()->data_channels()[i]->state(),
645                      DataChannelInterface::DataState::kClosed, kDefaultTimeout);
646     }
647 
648     caller()->data_channels().clear();
649     caller()->data_observers().clear();
650     callee()->data_channels().clear();
651     callee()->data_observers().clear();
652   }
653 }
654 
655 // This test sets up a call between two parties with audio, and video. When
656 // audio and video are setup and flowing, an SCTP data channel is negotiated.
TEST_P(DataChannelIntegrationTest,AddSctpDataChannelInSubsequentOffer)657 TEST_P(DataChannelIntegrationTest, AddSctpDataChannelInSubsequentOffer) {
658   // This test can't be performed without media.
659   if (!allow_media()) {
660     return;
661   }
662   ASSERT_TRUE(CreatePeerConnectionWrappers());
663   ConnectFakeSignaling();
664   // Do initial offer/answer with audio/video.
665   caller()->AddAudioVideoTracks();
666   callee()->AddAudioVideoTracks();
667   caller()->CreateAndSetAndSignalOffer();
668   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
669   // Create data channel and do new offer and answer.
670   caller()->CreateDataChannel();
671   caller()->CreateAndSetAndSignalOffer();
672   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
673   // Caller data channel should already exist (it created one). Callee data
674   // channel may not exist yet, since negotiation happens in-band, not in SDP.
675   ASSERT_NE(nullptr, caller()->data_channel());
676   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
677   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
678   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
679   // Ensure data can be sent in both directions.
680   std::string data = "hello world";
681   caller()->data_channel()->Send(DataBuffer(data));
682   EXPECT_EQ_WAIT(data, callee()->data_observer()->last_message(),
683                  kDefaultTimeout);
684   callee()->data_channel()->Send(DataBuffer(data));
685   EXPECT_EQ_WAIT(data, caller()->data_observer()->last_message(),
686                  kDefaultTimeout);
687 }
688 
689 // Set up a connection initially just using SCTP data channels, later
690 // upgrading to audio/video, ensuring frames are received end-to-end.
691 // Effectively the inverse of the test above. This was broken in M57; see
692 // https://crbug.com/711243
TEST_P(DataChannelIntegrationTest,SctpDataChannelToAudioVideoUpgrade)693 TEST_P(DataChannelIntegrationTest, SctpDataChannelToAudioVideoUpgrade) {
694   // This test can't be performed without media.
695   if (!allow_media()) {
696     return;
697   }
698   ASSERT_TRUE(CreatePeerConnectionWrappers());
699   ConnectFakeSignaling();
700   // Do initial offer/answer with just data channel.
701   caller()->CreateDataChannel();
702   caller()->CreateAndSetAndSignalOffer();
703   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
704   // Wait until data can be sent over the data channel.
705   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
706   ASSERT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
707   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
708 
709   // Do subsequent offer/answer with two-way audio and video. Audio and video
710   // should end up bundled on the DTLS/ICE transport already used for data.
711   caller()->AddAudioVideoTracks();
712   callee()->AddAudioVideoTracks();
713   caller()->CreateAndSetAndSignalOffer();
714   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
715   MediaExpectations media_expectations;
716   media_expectations.ExpectBidirectionalAudioAndVideo();
717   ASSERT_TRUE(ExpectNewFrames(media_expectations));
718 }
719 
MakeSpecCompliantSctpOffer(cricket::SessionDescription * desc)720 static void MakeSpecCompliantSctpOffer(cricket::SessionDescription* desc) {
721   cricket::SctpDataContentDescription* dcd_offer =
722       GetFirstSctpDataContentDescription(desc);
723   // See https://crbug.com/webrtc/11211 - this function is a no-op
724   ASSERT_TRUE(dcd_offer);
725   dcd_offer->set_use_sctpmap(false);
726   dcd_offer->set_protocol("UDP/DTLS/SCTP");
727 }
728 
729 // Test that the data channel works when a spec-compliant SCTP m= section is
730 // offered (using "a=sctp-port" instead of "a=sctpmap", and using
731 // "UDP/DTLS/SCTP" as the protocol).
TEST_P(DataChannelIntegrationTest,DataChannelWorksWhenSpecCompliantSctpOfferReceived)732 TEST_P(DataChannelIntegrationTest,
733        DataChannelWorksWhenSpecCompliantSctpOfferReceived) {
734   ASSERT_TRUE(CreatePeerConnectionWrappers());
735   ConnectFakeSignaling();
736   caller()->CreateDataChannel();
737   caller()->SetGeneratedSdpMunger(MakeSpecCompliantSctpOffer);
738   caller()->CreateAndSetAndSignalOffer();
739   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
740   ASSERT_TRUE_WAIT(callee()->data_channel() != nullptr, kDefaultTimeout);
741   EXPECT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
742   EXPECT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
743 
744   // Ensure data can be sent in both directions.
745   std::string data = "hello world";
746   caller()->data_channel()->Send(DataBuffer(data));
747   EXPECT_EQ_WAIT(data, callee()->data_observer()->last_message(),
748                  kDefaultTimeout);
749   callee()->data_channel()->Send(DataBuffer(data));
750   EXPECT_EQ_WAIT(data, caller()->data_observer()->last_message(),
751                  kDefaultTimeout);
752 }
753 
754 // Test that after closing PeerConnections, they stop sending any packets
755 // (ICE, DTLS, RTP...).
TEST_P(DataChannelIntegrationTest,ClosingConnectionStopsPacketFlow)756 TEST_P(DataChannelIntegrationTest, ClosingConnectionStopsPacketFlow) {
757   // This test can't be performed without media.
758   if (!allow_media()) {
759     return;
760   }
761   // Set up audio/video/data, wait for some frames to be received.
762   ASSERT_TRUE(CreatePeerConnectionWrappers());
763   ConnectFakeSignaling();
764   caller()->AddAudioVideoTracks();
765   caller()->CreateDataChannel();
766   caller()->CreateAndSetAndSignalOffer();
767   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
768   MediaExpectations media_expectations;
769   media_expectations.CalleeExpectsSomeAudioAndVideo();
770   ASSERT_TRUE(ExpectNewFrames(media_expectations));
771   // Close PeerConnections.
772   ClosePeerConnections();
773   // Pump messages for a second, and ensure no new packets end up sent.
774   uint32_t sent_packets_a = virtual_socket_server()->sent_packets();
775   WAIT(false, 1000);
776   uint32_t sent_packets_b = virtual_socket_server()->sent_packets();
777   EXPECT_EQ(sent_packets_a, sent_packets_b);
778 }
779 
TEST_P(DataChannelIntegrationTest,DtlsRoleIsSetNormally)780 TEST_P(DataChannelIntegrationTest, DtlsRoleIsSetNormally) {
781   ASSERT_TRUE(CreatePeerConnectionWrappers());
782   ConnectFakeSignaling();
783   caller()->CreateDataChannel();
784   ASSERT_FALSE(caller()->pc()->GetSctpTransport());
785   caller()->CreateAndSetAndSignalOffer();
786   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
787   ASSERT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
788   ASSERT_TRUE(caller()->pc()->GetSctpTransport());
789   ASSERT_TRUE(
790       caller()->pc()->GetSctpTransport()->Information().dtls_transport());
791   EXPECT_TRUE(caller()
792                   ->pc()
793                   ->GetSctpTransport()
794                   ->Information()
795                   .dtls_transport()
796                   ->Information()
797                   .role());
798   EXPECT_EQ(caller()
799                 ->pc()
800                 ->GetSctpTransport()
801                 ->Information()
802                 .dtls_transport()
803                 ->Information()
804                 .role(),
805             DtlsTransportTlsRole::kServer);
806   EXPECT_EQ(callee()
807                 ->pc()
808                 ->GetSctpTransport()
809                 ->Information()
810                 .dtls_transport()
811                 ->Information()
812                 .role(),
813             DtlsTransportTlsRole::kClient);
814   // ID should be assigned according to the odd/even rule based on role;
815   // client gets even numbers, server gets odd ones. RFC 8832 section 6.
816   // TODO(hta): Test multiple channels.
817   EXPECT_EQ(caller()->data_channel()->id(), 1);
818 }
819 
TEST_P(DataChannelIntegrationTest,DtlsRoleIsSetWhenReversed)820 TEST_P(DataChannelIntegrationTest, DtlsRoleIsSetWhenReversed) {
821   ASSERT_TRUE(CreatePeerConnectionWrappers());
822   ConnectFakeSignaling();
823   caller()->CreateDataChannel();
824   callee()->SetReceivedSdpMunger(MakeActiveSctpOffer);
825   caller()->CreateAndSetAndSignalOffer();
826   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
827   ASSERT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
828   EXPECT_TRUE(caller()
829                   ->pc()
830                   ->GetSctpTransport()
831                   ->Information()
832                   .dtls_transport()
833                   ->Information()
834                   .role());
835   EXPECT_EQ(caller()
836                 ->pc()
837                 ->GetSctpTransport()
838                 ->Information()
839                 .dtls_transport()
840                 ->Information()
841                 .role(),
842             DtlsTransportTlsRole::kClient);
843   EXPECT_EQ(callee()
844                 ->pc()
845                 ->GetSctpTransport()
846                 ->Information()
847                 .dtls_transport()
848                 ->Information()
849                 .role(),
850             DtlsTransportTlsRole::kServer);
851   // ID should be assigned according to the odd/even rule based on role;
852   // client gets even numbers, server gets odd ones. RFC 8832 section 6.
853   // TODO(hta): Test multiple channels.
854   EXPECT_EQ(caller()->data_channel()->id(), 0);
855 }
856 
TEST_P(DataChannelIntegrationTest,DtlsRoleIsSetWhenReversedWithChannelCollision)857 TEST_P(DataChannelIntegrationTest,
858        DtlsRoleIsSetWhenReversedWithChannelCollision) {
859   ASSERT_TRUE(CreatePeerConnectionWrappers());
860   ConnectFakeSignaling();
861   caller()->CreateDataChannel();
862 
863   callee()->SetReceivedSdpMunger([this](cricket::SessionDescription* desc) {
864     MakeActiveSctpOffer(desc);
865     callee()->CreateDataChannel();
866   });
867   caller()->CreateAndSetAndSignalOffer();
868   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
869   ASSERT_TRUE_WAIT(caller()->data_observer()->IsOpen(), kDefaultTimeout);
870   ASSERT_EQ_WAIT(callee()->data_channels().size(), 2U, kDefaultTimeout);
871   ASSERT_EQ_WAIT(caller()->data_channels().size(), 2U, kDefaultTimeout);
872   EXPECT_TRUE(caller()
873                   ->pc()
874                   ->GetSctpTransport()
875                   ->Information()
876                   .dtls_transport()
877                   ->Information()
878                   .role());
879   EXPECT_EQ(caller()
880                 ->pc()
881                 ->GetSctpTransport()
882                 ->Information()
883                 .dtls_transport()
884                 ->Information()
885                 .role(),
886             DtlsTransportTlsRole::kClient);
887   EXPECT_EQ(callee()
888                 ->pc()
889                 ->GetSctpTransport()
890                 ->Information()
891                 .dtls_transport()
892                 ->Information()
893                 .role(),
894             DtlsTransportTlsRole::kServer);
895   // ID should be assigned according to the odd/even rule based on role;
896   // client gets even numbers, server gets odd ones. RFC 8832 section 6.
897   ASSERT_EQ(caller()->data_channels().size(), 2U);
898   ASSERT_EQ(callee()->data_channels().size(), 2U);
899   EXPECT_EQ(caller()->data_channels()[0]->id(), 0);
900   EXPECT_EQ(caller()->data_channels()[1]->id(), 1);
901   EXPECT_EQ(callee()->data_channels()[0]->id(), 1);
902   EXPECT_EQ(callee()->data_channels()[1]->id(), 0);
903 }
904 
905 // Test that transport stats are generated by the RTCStatsCollector for a
906 // connection that only involves data channels. This is a regression test for
907 // crbug.com/826972.
TEST_P(DataChannelIntegrationTest,TransportStatsReportedForDataChannelOnlyConnection)908 TEST_P(DataChannelIntegrationTest,
909        TransportStatsReportedForDataChannelOnlyConnection) {
910   ASSERT_TRUE(CreatePeerConnectionWrappers());
911   ConnectFakeSignaling();
912   caller()->CreateDataChannel();
913 
914   caller()->CreateAndSetAndSignalOffer();
915   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
916   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
917 
918   auto caller_report = caller()->NewGetStats();
919   EXPECT_EQ(1u, caller_report->GetStatsOfType<RTCTransportStats>().size());
920   auto callee_report = callee()->NewGetStats();
921   EXPECT_EQ(1u, callee_report->GetStatsOfType<RTCTransportStats>().size());
922 }
923 
TEST_P(DataChannelIntegrationTest,QueuedPacketsGetDeliveredInReliableMode)924 TEST_P(DataChannelIntegrationTest, QueuedPacketsGetDeliveredInReliableMode) {
925   CreatePeerConnectionWrappers();
926   ConnectFakeSignaling();
927   caller()->CreateDataChannel();
928   caller()->CreateAndSetAndSignalOffer();
929   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
930   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
931 
932   caller()->data_channel()->Send(DataBuffer("hello first"));
933   ASSERT_EQ_WAIT(1u, callee()->data_observer()->received_message_count(),
934                  kDefaultTimeout);
935   // Cause a temporary network outage
936   virtual_socket_server()->set_drop_probability(1.0);
937   for (int i = 1; i <= 10; i++) {
938     caller()->data_channel()->Send(DataBuffer("Sent while blocked"));
939   }
940   // Nothing should be delivered during outage. Short wait.
941   EXPECT_EQ_WAIT(1u, callee()->data_observer()->received_message_count(), 10);
942   // Reverse outage
943   virtual_socket_server()->set_drop_probability(0.0);
944   // All packets should be delivered.
945   EXPECT_EQ_WAIT(11u, callee()->data_observer()->received_message_count(),
946                  kDefaultTimeout);
947 }
948 
TEST_P(DataChannelIntegrationTest,QueuedPacketsGetDroppedInUnreliableMode)949 TEST_P(DataChannelIntegrationTest, QueuedPacketsGetDroppedInUnreliableMode) {
950   CreatePeerConnectionWrappers();
951   ConnectFakeSignaling();
952   DataChannelInit init;
953   init.maxRetransmits = 0;
954   init.ordered = false;
955   caller()->CreateDataChannel(&init);
956   caller()->CreateAndSetAndSignalOffer();
957   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
958   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
959   caller()->data_channel()->Send(DataBuffer("hello first"));
960   ASSERT_EQ_WAIT(1u, callee()->data_observer()->received_message_count(),
961                  kDefaultTimeout);
962   // Cause a temporary network outage
963   virtual_socket_server()->set_drop_probability(1.0);
964   // Send a few packets. Note that all get dropped only when all packets
965   // fit into the receiver receive window/congestion window, so that they
966   // actually get sent.
967   for (int i = 1; i <= 10; i++) {
968     caller()->data_channel()->Send(DataBuffer("Sent while blocked"));
969   }
970   // Nothing should be delivered during outage.
971   // We do a short wait to verify that delivery count is still 1.
972   WAIT(false, 10);
973   EXPECT_EQ(1u, callee()->data_observer()->received_message_count());
974   // Reverse the network outage.
975   virtual_socket_server()->set_drop_probability(0.0);
976   // Send a new packet, and wait for it to be delivered.
977   caller()->data_channel()->Send(DataBuffer("After block"));
978   EXPECT_EQ_WAIT("After block", callee()->data_observer()->last_message(),
979                  kDefaultTimeout);
980   // Some messages should be lost, but first and last message should have
981   // been delivered.
982   // First, check that the protocol guarantee is preserved.
983   EXPECT_GT(11u, callee()->data_observer()->received_message_count());
984   EXPECT_LE(2u, callee()->data_observer()->received_message_count());
985   // Then, check that observed behavior (lose all messages) has not changed
986   EXPECT_EQ(2u, callee()->data_observer()->received_message_count());
987 }
988 
TEST_P(DataChannelIntegrationTest,QueuedPacketsGetDroppedInLifetimeLimitedMode)989 TEST_P(DataChannelIntegrationTest,
990        QueuedPacketsGetDroppedInLifetimeLimitedMode) {
991   CreatePeerConnectionWrappers();
992   ConnectFakeSignaling();
993   DataChannelInit init;
994   init.maxRetransmitTime = 1;
995   init.ordered = false;
996   caller()->CreateDataChannel(&init);
997   caller()->CreateAndSetAndSignalOffer();
998   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
999   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
1000   caller()->data_channel()->Send(DataBuffer("hello first"));
1001   ASSERT_EQ_WAIT(1u, callee()->data_observer()->received_message_count(),
1002                  kDefaultTimeout);
1003   // Cause a temporary network outage
1004   virtual_socket_server()->set_drop_probability(1.0);
1005   for (int i = 1; i <= 200; i++) {
1006     caller()->data_channel()->Send(DataBuffer("Sent while blocked"));
1007   }
1008   // Nothing should be delivered during outage.
1009   // We do a short wait to verify that delivery count is still 1,
1010   // and to make sure max packet lifetime (which is in ms) is exceeded.
1011   WAIT(false, 10);
1012   EXPECT_EQ(1u, callee()->data_observer()->received_message_count());
1013   // Reverse the network outage.
1014   virtual_socket_server()->set_drop_probability(0.0);
1015   // Send a new packet, and wait for it to be delivered.
1016   caller()->data_channel()->Send(DataBuffer("After block"));
1017   EXPECT_EQ_WAIT("After block", callee()->data_observer()->last_message(),
1018                  kDefaultTimeout);
1019   // Some messages should be lost, but first and last message should have
1020   // been delivered.
1021   // First, check that the protocol guarantee is preserved.
1022   EXPECT_GT(202u, callee()->data_observer()->received_message_count());
1023   EXPECT_LE(2u, callee()->data_observer()->received_message_count());
1024   // Then, check that observed behavior (lose some messages) has not changed
1025   // DcSctp loses all messages. This is correct.
1026   EXPECT_EQ(2u, callee()->data_observer()->received_message_count());
1027 }
1028 
TEST_P(DataChannelIntegrationTest,DISABLED_ON_ANDROID (SomeQueuedPacketsGetDroppedInMaxRetransmitsMode))1029 TEST_P(DataChannelIntegrationTest,
1030        DISABLED_ON_ANDROID(SomeQueuedPacketsGetDroppedInMaxRetransmitsMode)) {
1031   CreatePeerConnectionWrappers();
1032   ConnectFakeSignaling();
1033   DataChannelInit init;
1034   init.maxRetransmits = 0;
1035   init.ordered = false;
1036   caller()->CreateDataChannel(&init);
1037   caller()->CreateAndSetAndSignalOffer();
1038   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
1039   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
1040   caller()->data_channel()->Send(DataBuffer("hello first"));
1041   ASSERT_EQ_WAIT(1u, callee()->data_observer()->received_message_count(),
1042                  kDefaultTimeout);
1043   // Cause a temporary network outage
1044   virtual_socket_server()->set_drop_probability(1.0);
1045   // Fill the buffer until queued data starts to build
1046   size_t packet_counter = 0;
1047   while (caller()->data_channel()->buffered_amount() < 1 &&
1048          packet_counter < 10000) {
1049     packet_counter++;
1050     caller()->data_channel()->Send(DataBuffer("Sent while blocked"));
1051   }
1052   if (caller()->data_channel()->buffered_amount()) {
1053     RTC_LOG(LS_INFO) << "Buffered data after " << packet_counter << " packets";
1054   } else {
1055     RTC_LOG(LS_INFO) << "No buffered data after " << packet_counter
1056                      << " packets";
1057   }
1058   // Nothing should be delivered during outage.
1059   // We do a short wait to verify that delivery count is still 1.
1060   WAIT(false, 10);
1061   EXPECT_EQ(1u, callee()->data_observer()->received_message_count());
1062   // Reverse the network outage.
1063   virtual_socket_server()->set_drop_probability(0.0);
1064   // Send a new packet, and wait for it to be delivered.
1065   caller()->data_channel()->Send(DataBuffer("After block"));
1066   EXPECT_EQ_WAIT("After block", callee()->data_observer()->last_message(),
1067                  kDefaultTimeout);
1068   // Some messages should be lost, but first and last message should have
1069   // been delivered.
1070   // Due to the fact that retransmissions are only counted when the packet
1071   // goes on the wire, NOT when they are stalled in queue due to
1072   // congestion, we expect some of the packets to be delivered, because
1073   // congestion prevented them from being sent.
1074   // Citation: https://tools.ietf.org/html/rfc7496#section-3.1
1075 
1076   // First, check that the protocol guarantee is preserved.
1077   EXPECT_GT(packet_counter,
1078             callee()->data_observer()->received_message_count());
1079   EXPECT_LE(2u, callee()->data_observer()->received_message_count());
1080   // Then, check that observed behavior (lose between 100 and 200 messages)
1081   // has not changed.
1082   // Usrsctp behavior is different on Android (177) and other platforms (122).
1083   // Dcsctp loses 432 packets.
1084   EXPECT_GT(2 + packet_counter - 100,
1085             callee()->data_observer()->received_message_count());
1086   EXPECT_LT(2 + packet_counter - 500,
1087             callee()->data_observer()->received_message_count());
1088 }
1089 
1090 INSTANTIATE_TEST_SUITE_P(DataChannelIntegrationTest,
1091                          DataChannelIntegrationTest,
1092                          Combine(Values(SdpSemantics::kPlanB_DEPRECATED,
1093                                         SdpSemantics::kUnifiedPlan),
1094                                  testing::Bool()));
1095 
TEST_F(DataChannelIntegrationTestUnifiedPlan,EndToEndCallWithBundledSctpDataChannel)1096 TEST_F(DataChannelIntegrationTestUnifiedPlan,
1097        EndToEndCallWithBundledSctpDataChannel) {
1098   ASSERT_TRUE(CreatePeerConnectionWrappers());
1099   ConnectFakeSignaling();
1100   caller()->CreateDataChannel();
1101   caller()->AddAudioVideoTracks();
1102   callee()->AddAudioVideoTracks();
1103   caller()->CreateAndSetAndSignalOffer();
1104   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
1105   ASSERT_TRUE_WAIT(caller()->pc()->GetSctpTransport(), kDefaultTimeout);
1106   ASSERT_EQ_WAIT(SctpTransportState::kConnected,
1107                  caller()->pc()->GetSctpTransport()->Information().state(),
1108                  kDefaultTimeout);
1109   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
1110   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
1111 }
1112 
TEST_F(DataChannelIntegrationTestUnifiedPlan,EndToEndCallWithDataChannelOnlyConnects)1113 TEST_F(DataChannelIntegrationTestUnifiedPlan,
1114        EndToEndCallWithDataChannelOnlyConnects) {
1115   ASSERT_TRUE(CreatePeerConnectionWrappers());
1116   ConnectFakeSignaling();
1117   caller()->CreateDataChannel();
1118   caller()->CreateAndSetAndSignalOffer();
1119   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
1120   ASSERT_TRUE_WAIT(callee()->data_channel(), kDefaultTimeout);
1121   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
1122   ASSERT_TRUE(caller()->data_observer()->IsOpen());
1123 }
1124 
TEST_F(DataChannelIntegrationTestUnifiedPlan,DataChannelClosesWhenClosed)1125 TEST_F(DataChannelIntegrationTestUnifiedPlan, DataChannelClosesWhenClosed) {
1126   ASSERT_TRUE(CreatePeerConnectionWrappers());
1127   ConnectFakeSignaling();
1128   caller()->CreateDataChannel();
1129   caller()->CreateAndSetAndSignalOffer();
1130   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
1131   ASSERT_TRUE_WAIT(callee()->data_observer(), kDefaultTimeout);
1132   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
1133   caller()->data_channel()->Close();
1134   ASSERT_TRUE_WAIT(!callee()->data_observer()->IsOpen(), kDefaultTimeout);
1135 }
1136 
TEST_F(DataChannelIntegrationTestUnifiedPlan,DataChannelClosesWhenClosedReverse)1137 TEST_F(DataChannelIntegrationTestUnifiedPlan,
1138        DataChannelClosesWhenClosedReverse) {
1139   ASSERT_TRUE(CreatePeerConnectionWrappers());
1140   ConnectFakeSignaling();
1141   caller()->CreateDataChannel();
1142   caller()->CreateAndSetAndSignalOffer();
1143   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
1144   ASSERT_TRUE_WAIT(callee()->data_observer(), kDefaultTimeout);
1145   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
1146   callee()->data_channel()->Close();
1147   ASSERT_TRUE_WAIT(!caller()->data_observer()->IsOpen(), kDefaultTimeout);
1148 }
1149 
TEST_F(DataChannelIntegrationTestUnifiedPlan,DataChannelClosesWhenPeerConnectionClosed)1150 TEST_F(DataChannelIntegrationTestUnifiedPlan,
1151        DataChannelClosesWhenPeerConnectionClosed) {
1152   ASSERT_TRUE(CreatePeerConnectionWrappers());
1153   ConnectFakeSignaling();
1154   caller()->CreateDataChannel();
1155   caller()->CreateAndSetAndSignalOffer();
1156   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
1157   ASSERT_TRUE_WAIT(callee()->data_observer(), kDefaultTimeout);
1158   ASSERT_TRUE_WAIT(callee()->data_observer()->IsOpen(), kDefaultTimeout);
1159   caller()->pc()->Close();
1160   ASSERT_TRUE_WAIT(!callee()->data_observer()->IsOpen(), kDefaultTimeout);
1161 }
1162 
1163 #endif  // WEBRTC_HAVE_SCTP
1164 
1165 }  // namespace
1166 
1167 }  // namespace webrtc
1168