OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/cast/net/cast_transport_sender_impl.h" | 5 #include "media/cast/net/cast_transport_sender_impl.h" |
6 | 6 |
7 #include <gtest/gtest.h> | 7 #include <gtest/gtest.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 #include <utility> | 9 #include <utility> |
10 | 10 |
11 #include "base/bind.h" | 11 #include "base/bind.h" |
12 #include "base/bind_helpers.h" | 12 #include "base/bind_helpers.h" |
13 #include "base/macros.h" | 13 #include "base/macros.h" |
14 #include "base/memory/scoped_ptr.h" | 14 #include "base/memory/scoped_ptr.h" |
15 #include "base/test/simple_test_tick_clock.h" | 15 #include "base/test/simple_test_tick_clock.h" |
16 #include "base/values.h" | 16 #include "base/values.h" |
17 #include "media/cast/net/cast_transport_config.h" | 17 #include "media/cast/net/cast_transport_config.h" |
18 #include "media/cast/net/rtcp/rtcp_defines.h" | 18 #include "media/cast/net/rtcp/rtcp_defines.h" |
19 #include "media/cast/test/fake_single_thread_task_runner.h" | 19 #include "media/cast/test/fake_single_thread_task_runner.h" |
20 #include "testing/gtest/include/gtest/gtest.h" | 20 #include "testing/gtest/include/gtest/gtest.h" |
21 | 21 |
22 namespace media { | 22 namespace media { |
23 namespace cast { | 23 namespace cast { |
24 | 24 |
25 namespace { | 25 namespace { |
| 26 |
26 const int64_t kStartMillisecond = INT64_C(12345678900000); | 27 const int64_t kStartMillisecond = INT64_C(12345678900000); |
27 const uint32_t kVideoSsrc = 1; | 28 const uint32_t kVideoSsrc = 1; |
28 const uint32_t kAudioSsrc = 2; | 29 const uint32_t kAudioSsrc = 2; |
| 30 |
29 } // namespace | 31 } // namespace |
30 | 32 |
31 class FakePacketSender : public PacketSender { | 33 class FakePacketSender : public PacketSender { |
32 public: | 34 public: |
33 FakePacketSender() | 35 FakePacketSender() |
34 : paused_(false), packets_sent_(0), bytes_sent_(0) {} | 36 : paused_(false), packets_sent_(0), bytes_sent_(0) {} |
35 | 37 |
36 bool SendPacket(PacketRef packet, const base::Closure& cb) final { | 38 bool SendPacket(PacketRef packet, const base::Closure& cb) final { |
37 if (paused_) { | 39 if (paused_) { |
38 stored_packet_ = packet; | 40 stored_packet_ = packet; |
39 callback_ = cb; | 41 callback_ = cb; |
40 return false; | 42 return false; |
41 } | 43 } |
42 ++packets_sent_; | 44 ++packets_sent_; |
43 bytes_sent_ += packet->data.size(); | 45 bytes_sent_ += packet->data.size(); |
44 return true; | 46 return true; |
45 } | 47 } |
46 | 48 |
47 int64_t GetBytesSent() final { return bytes_sent_; } | 49 int64_t GetBytesSent() final { return bytes_sent_; } |
48 | 50 |
| 51 void StartReceiving( |
| 52 const PacketReceiverCallbackWithStatus& packet_receiver) final {} |
| 53 |
| 54 void StopReceiving() final {} |
| 55 |
49 void SetPaused(bool paused) { | 56 void SetPaused(bool paused) { |
50 paused_ = paused; | 57 paused_ = paused; |
51 if (!paused && stored_packet_.get()) { | 58 if (!paused && stored_packet_.get()) { |
52 SendPacket(stored_packet_, callback_); | 59 SendPacket(stored_packet_, callback_); |
53 callback_.Run(); | 60 callback_.Run(); |
54 } | 61 } |
55 } | 62 } |
56 | 63 |
57 int packets_sent() const { return packets_sent_; } | 64 int packets_sent() const { return packets_sent_; } |
58 | 65 |
59 private: | 66 private: |
60 bool paused_; | 67 bool paused_; |
61 base::Closure callback_; | 68 base::Closure callback_; |
62 PacketRef stored_packet_; | 69 PacketRef stored_packet_; |
63 int packets_sent_; | 70 int packets_sent_; |
64 int64_t bytes_sent_; | 71 int64_t bytes_sent_; |
65 | 72 |
66 DISALLOW_COPY_AND_ASSIGN(FakePacketSender); | 73 DISALLOW_COPY_AND_ASSIGN(FakePacketSender); |
67 }; | 74 }; |
68 | 75 |
69 class CastTransportSenderImplTest : public ::testing::Test { | 76 class CastTransportSenderImplTest : public ::testing::Test { |
| 77 public: |
| 78 void ReceivedLoggingEvents() { num_times_logging_callback_called_++; } |
| 79 |
70 protected: | 80 protected: |
71 CastTransportSenderImplTest() : num_times_logging_callback_called_(0) { | 81 CastTransportSenderImplTest() : num_times_logging_callback_called_(0) { |
72 testing_clock_.Advance( | 82 testing_clock_.Advance( |
73 base::TimeDelta::FromMilliseconds(kStartMillisecond)); | 83 base::TimeDelta::FromMilliseconds(kStartMillisecond)); |
74 task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_); | 84 task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_); |
75 } | 85 } |
76 | 86 |
77 ~CastTransportSenderImplTest() override {} | 87 ~CastTransportSenderImplTest() override {} |
78 | 88 |
79 void InitWithoutLogging() { | 89 void InitWithoutLogging(); |
80 transport_sender_.reset( | 90 void InitWithOptions(); |
81 new CastTransportSenderImpl(NULL, | 91 void InitWithLogging(); |
82 &testing_clock_, | |
83 net::IPEndPoint(), | |
84 net::IPEndPoint(), | |
85 make_scoped_ptr(new base::DictionaryValue), | |
86 base::Bind(&UpdateCastTransportStatus), | |
87 BulkRawEventsCallback(), | |
88 base::TimeDelta(), | |
89 task_runner_, | |
90 PacketReceiverCallback(), | |
91 &transport_)); | |
92 task_runner_->RunTasks(); | |
93 } | |
94 | |
95 void InitWithOptions() { | |
96 scoped_ptr<base::DictionaryValue> options( | |
97 new base::DictionaryValue); | |
98 options->SetBoolean("DHCP", true); | |
99 options->SetBoolean("disable_wifi_scan", true); | |
100 options->SetBoolean("media_streaming_mode", true); | |
101 options->SetInteger("pacer_target_burst_size", 20); | |
102 options->SetInteger("pacer_max_burst_size", 100); | |
103 transport_sender_.reset(new CastTransportSenderImpl( | |
104 NULL, &testing_clock_, net::IPEndPoint(), net::IPEndPoint(), | |
105 std::move(options), base::Bind(&UpdateCastTransportStatus), | |
106 BulkRawEventsCallback(), base::TimeDelta(), task_runner_, | |
107 PacketReceiverCallback(), &transport_)); | |
108 task_runner_->RunTasks(); | |
109 } | |
110 | |
111 void InitWithLogging() { | |
112 transport_sender_.reset(new CastTransportSenderImpl( | |
113 NULL, | |
114 &testing_clock_, | |
115 net::IPEndPoint(), | |
116 net::IPEndPoint(), | |
117 make_scoped_ptr(new base::DictionaryValue), | |
118 base::Bind(&UpdateCastTransportStatus), | |
119 base::Bind(&CastTransportSenderImplTest::LogRawEvents, | |
120 base::Unretained(this)), | |
121 base::TimeDelta::FromMilliseconds(10), | |
122 task_runner_, | |
123 PacketReceiverCallback(), | |
124 &transport_)); | |
125 task_runner_->RunTasks(); | |
126 } | |
127 | 92 |
128 void InitializeVideo() { | 93 void InitializeVideo() { |
129 CastTransportRtpConfig rtp_config; | 94 CastTransportRtpConfig rtp_config; |
130 rtp_config.ssrc = kVideoSsrc; | 95 rtp_config.ssrc = kVideoSsrc; |
131 rtp_config.feedback_ssrc = 2; | 96 rtp_config.feedback_ssrc = 2; |
132 rtp_config.rtp_payload_type = 3; | 97 rtp_config.rtp_payload_type = 3; |
133 transport_sender_->InitializeVideo(rtp_config, | 98 transport_sender_->InitializeVideo(rtp_config, RtcpCastMessageCallback(), |
134 RtcpCastMessageCallback(), | |
135 RtcpRttCallback()); | 99 RtcpRttCallback()); |
136 } | 100 } |
137 | 101 |
138 void InitializeAudio() { | 102 void InitializeAudio() { |
139 CastTransportRtpConfig rtp_config; | 103 CastTransportRtpConfig rtp_config; |
140 rtp_config.ssrc = kAudioSsrc; | 104 rtp_config.ssrc = kAudioSsrc; |
141 rtp_config.feedback_ssrc = 3; | 105 rtp_config.feedback_ssrc = 3; |
142 rtp_config.rtp_payload_type = 4; | 106 rtp_config.rtp_payload_type = 4; |
143 transport_sender_->InitializeAudio(rtp_config, | 107 transport_sender_->InitializeAudio(rtp_config, RtcpCastMessageCallback(), |
144 RtcpCastMessageCallback(), | |
145 RtcpRttCallback()); | 108 RtcpRttCallback()); |
146 } | 109 } |
147 | 110 |
148 void LogRawEvents(scoped_ptr<std::vector<FrameEvent>> frame_events, | |
149 scoped_ptr<std::vector<PacketEvent>> packet_events) { | |
150 num_times_logging_callback_called_++; | |
151 } | |
152 | |
153 static void UpdateCastTransportStatus(CastTransportStatus status) { | |
154 } | |
155 | |
156 base::SimpleTestTickClock testing_clock_; | 111 base::SimpleTestTickClock testing_clock_; |
157 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; | 112 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; |
158 scoped_ptr<CastTransportSenderImpl> transport_sender_; | 113 scoped_ptr<CastTransportSenderImpl> transport_sender_; |
159 FakePacketSender transport_; | 114 FakePacketSender* transport_; // Owned by CastTransportSender. |
160 int num_times_logging_callback_called_; | 115 int num_times_logging_callback_called_; |
161 }; | 116 }; |
162 | 117 |
| 118 namespace { |
| 119 |
| 120 class TransportClient : public CastTransportSender::Client { |
| 121 public: |
| 122 explicit TransportClient( |
| 123 CastTransportSenderImplTest* cast_transport_sender_impl_test) |
| 124 : cast_transport_sender_impl_test_(cast_transport_sender_impl_test) {} |
| 125 |
| 126 void OnStatusChanged(CastTransportStatus status) final{}; |
| 127 void OnLoggingEventsReceived( |
| 128 scoped_ptr<std::vector<FrameEvent>> frame_events, |
| 129 scoped_ptr<std::vector<PacketEvent>> packet_events) final { |
| 130 CHECK(cast_transport_sender_impl_test_); |
| 131 cast_transport_sender_impl_test_->ReceivedLoggingEvents(); |
| 132 }; |
| 133 void ProcessRtpPacket(scoped_ptr<Packet> packet) final{}; |
| 134 |
| 135 private: |
| 136 CastTransportSenderImplTest* const cast_transport_sender_impl_test_; |
| 137 |
| 138 DISALLOW_COPY_AND_ASSIGN(TransportClient); |
| 139 }; |
| 140 |
| 141 } // namespace |
| 142 |
| 143 void CastTransportSenderImplTest::InitWithoutLogging() { |
| 144 transport_ = new FakePacketSender(); |
| 145 transport_sender_.reset( |
| 146 new CastTransportSenderImpl(&testing_clock_, base::TimeDelta(), |
| 147 make_scoped_ptr(new TransportClient(nullptr)), |
| 148 make_scoped_ptr(transport_), task_runner_)); |
| 149 task_runner_->RunTasks(); |
| 150 } |
| 151 |
| 152 void CastTransportSenderImplTest::InitWithOptions() { |
| 153 scoped_ptr<base::DictionaryValue> options(new base::DictionaryValue); |
| 154 options->SetBoolean("disable_wifi_scan", true); |
| 155 options->SetBoolean("media_streaming_mode", true); |
| 156 options->SetInteger("pacer_target_burst_size", 20); |
| 157 options->SetInteger("pacer_max_burst_size", 100); |
| 158 transport_ = new FakePacketSender(); |
| 159 transport_sender_.reset( |
| 160 new CastTransportSenderImpl(&testing_clock_, base::TimeDelta(), |
| 161 make_scoped_ptr(new TransportClient(nullptr)), |
| 162 make_scoped_ptr(transport_), task_runner_)); |
| 163 transport_sender_->SetOptions(*options); |
| 164 task_runner_->RunTasks(); |
| 165 } |
| 166 |
| 167 void CastTransportSenderImplTest::InitWithLogging() { |
| 168 transport_ = new FakePacketSender(); |
| 169 transport_sender_.reset(new CastTransportSenderImpl( |
| 170 &testing_clock_, base::TimeDelta::FromMilliseconds(10), |
| 171 make_scoped_ptr(new TransportClient(this)), make_scoped_ptr(transport_), |
| 172 task_runner_)); |
| 173 task_runner_->RunTasks(); |
| 174 } |
| 175 |
163 TEST_F(CastTransportSenderImplTest, InitWithoutLogging) { | 176 TEST_F(CastTransportSenderImplTest, InitWithoutLogging) { |
164 InitWithoutLogging(); | 177 InitWithoutLogging(); |
165 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 178 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
166 EXPECT_EQ(0, num_times_logging_callback_called_); | 179 EXPECT_EQ(0, num_times_logging_callback_called_); |
167 } | 180 } |
168 | 181 |
169 TEST_F(CastTransportSenderImplTest, InitWithOptions) { | 182 TEST_F(CastTransportSenderImplTest, InitWithOptions) { |
170 InitWithOptions(); | 183 InitWithOptions(); |
171 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 184 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
172 EXPECT_EQ(0, num_times_logging_callback_called_); | 185 EXPECT_EQ(0, num_times_logging_callback_called_); |
173 } | 186 } |
174 | 187 |
175 TEST_F(CastTransportSenderImplTest, NacksCancelRetransmits) { | 188 TEST_F(CastTransportSenderImplTest, NacksCancelRetransmits) { |
176 InitWithLogging(); | 189 InitWithLogging(); |
177 InitializeVideo(); | 190 InitializeVideo(); |
178 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 191 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
179 EXPECT_EQ(0, num_times_logging_callback_called_); | 192 EXPECT_EQ(0, num_times_logging_callback_called_); |
180 | 193 |
181 // A fake frame that will be decomposed into 4 packets. | 194 // A fake frame that will be decomposed into 4 packets. |
182 EncodedFrame fake_frame; | 195 EncodedFrame fake_frame; |
183 fake_frame.frame_id = 1; | 196 fake_frame.frame_id = 1; |
184 fake_frame.rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(1)); | 197 fake_frame.rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(1)); |
185 fake_frame.dependency = EncodedFrame::KEY; | 198 fake_frame.dependency = EncodedFrame::KEY; |
186 fake_frame.data.resize(5000, ' '); | 199 fake_frame.data.resize(5000, ' '); |
187 | 200 |
188 transport_sender_->InsertFrame(kVideoSsrc, fake_frame); | 201 transport_sender_->InsertFrame(kVideoSsrc, fake_frame); |
189 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 202 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
190 EXPECT_EQ(4, transport_.packets_sent()); | 203 EXPECT_EQ(4, transport_->packets_sent()); |
191 EXPECT_EQ(1, num_times_logging_callback_called_); | 204 EXPECT_EQ(1, num_times_logging_callback_called_); |
192 | 205 |
193 // Resend packet 0. | 206 // Resend packet 0. |
194 MissingFramesAndPacketsMap missing_packets; | 207 MissingFramesAndPacketsMap missing_packets; |
195 missing_packets[1].insert(0); | 208 missing_packets[1].insert(0); |
196 missing_packets[1].insert(1); | 209 missing_packets[1].insert(1); |
197 missing_packets[1].insert(2); | 210 missing_packets[1].insert(2); |
198 | 211 |
199 transport_.SetPaused(true); | 212 transport_->SetPaused(true); |
200 DedupInfo dedup_info; | 213 DedupInfo dedup_info; |
201 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); | 214 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); |
202 transport_sender_->ResendPackets( | 215 transport_sender_->ResendPackets( |
203 kVideoSsrc, missing_packets, true, dedup_info); | 216 kVideoSsrc, missing_packets, true, dedup_info); |
204 | 217 |
205 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 218 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
206 EXPECT_EQ(2, num_times_logging_callback_called_); | 219 EXPECT_EQ(2, num_times_logging_callback_called_); |
207 | 220 |
208 RtcpCastMessage cast_message; | 221 RtcpCastMessage cast_message; |
209 cast_message.media_ssrc = kVideoSsrc; | 222 cast_message.media_ssrc = kVideoSsrc; |
210 cast_message.ack_frame_id = 1; | 223 cast_message.ack_frame_id = 1; |
211 cast_message.missing_frames_and_packets[1].insert(3); | 224 cast_message.missing_frames_and_packets[1].insert(3); |
212 transport_sender_->OnReceivedCastMessage(kVideoSsrc, | 225 transport_sender_->OnReceivedCastMessage(kVideoSsrc, |
213 RtcpCastMessageCallback(), | 226 RtcpCastMessageCallback(), |
214 cast_message); | 227 cast_message); |
215 transport_.SetPaused(false); | 228 transport_->SetPaused(false); |
216 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 229 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
217 EXPECT_EQ(3, num_times_logging_callback_called_); | 230 EXPECT_EQ(3, num_times_logging_callback_called_); |
218 | 231 |
219 // Resend one packet in the socket when unpaused. | 232 // Resend one packet in the socket when unpaused. |
220 // Resend one more packet from NACK. | 233 // Resend one more packet from NACK. |
221 EXPECT_EQ(6, transport_.packets_sent()); | 234 EXPECT_EQ(6, transport_->packets_sent()); |
222 } | 235 } |
223 | 236 |
224 TEST_F(CastTransportSenderImplTest, CancelRetransmits) { | 237 TEST_F(CastTransportSenderImplTest, CancelRetransmits) { |
225 InitWithLogging(); | 238 InitWithLogging(); |
226 InitializeVideo(); | 239 InitializeVideo(); |
227 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 240 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
228 EXPECT_EQ(0, num_times_logging_callback_called_); | 241 EXPECT_EQ(0, num_times_logging_callback_called_); |
229 | 242 |
230 // A fake frame that will be decomposed into 4 packets. | 243 // A fake frame that will be decomposed into 4 packets. |
231 EncodedFrame fake_frame; | 244 EncodedFrame fake_frame; |
232 fake_frame.frame_id = 1; | 245 fake_frame.frame_id = 1; |
233 fake_frame.rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(1)); | 246 fake_frame.rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(1)); |
234 fake_frame.dependency = EncodedFrame::KEY; | 247 fake_frame.dependency = EncodedFrame::KEY; |
235 fake_frame.data.resize(5000, ' '); | 248 fake_frame.data.resize(5000, ' '); |
236 | 249 |
237 transport_sender_->InsertFrame(kVideoSsrc, fake_frame); | 250 transport_sender_->InsertFrame(kVideoSsrc, fake_frame); |
238 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 251 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
239 EXPECT_EQ(4, transport_.packets_sent()); | 252 EXPECT_EQ(4, transport_->packets_sent()); |
240 EXPECT_EQ(1, num_times_logging_callback_called_); | 253 EXPECT_EQ(1, num_times_logging_callback_called_); |
241 | 254 |
242 // Resend all packets for frame 1. | 255 // Resend all packets for frame 1. |
243 MissingFramesAndPacketsMap missing_packets; | 256 MissingFramesAndPacketsMap missing_packets; |
244 missing_packets[1].insert(kRtcpCastAllPacketsLost); | 257 missing_packets[1].insert(kRtcpCastAllPacketsLost); |
245 | 258 |
246 transport_.SetPaused(true); | 259 transport_->SetPaused(true); |
247 DedupInfo dedup_info; | 260 DedupInfo dedup_info; |
248 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); | 261 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); |
249 transport_sender_->ResendPackets( | 262 transport_sender_->ResendPackets( |
250 kVideoSsrc, missing_packets, true, dedup_info); | 263 kVideoSsrc, missing_packets, true, dedup_info); |
251 | 264 |
252 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 265 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
253 EXPECT_EQ(2, num_times_logging_callback_called_); | 266 EXPECT_EQ(2, num_times_logging_callback_called_); |
254 | 267 |
255 std::vector<uint32_t> cancel_sending_frames; | 268 std::vector<uint32_t> cancel_sending_frames; |
256 cancel_sending_frames.push_back(1); | 269 cancel_sending_frames.push_back(1); |
257 transport_sender_->CancelSendingFrames(kVideoSsrc, | 270 transport_sender_->CancelSendingFrames(kVideoSsrc, |
258 cancel_sending_frames); | 271 cancel_sending_frames); |
259 transport_.SetPaused(false); | 272 transport_->SetPaused(false); |
260 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 273 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
261 EXPECT_EQ(2, num_times_logging_callback_called_); | 274 EXPECT_EQ(2, num_times_logging_callback_called_); |
262 | 275 |
263 // Resend one packet in the socket when unpaused. | 276 // Resend one packet in the socket when unpaused. |
264 EXPECT_EQ(5, transport_.packets_sent()); | 277 EXPECT_EQ(5, transport_->packets_sent()); |
265 } | 278 } |
266 | 279 |
267 TEST_F(CastTransportSenderImplTest, Kickstart) { | 280 TEST_F(CastTransportSenderImplTest, Kickstart) { |
268 InitWithLogging(); | 281 InitWithLogging(); |
269 InitializeVideo(); | 282 InitializeVideo(); |
270 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 283 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
271 EXPECT_EQ(0, num_times_logging_callback_called_); | 284 EXPECT_EQ(0, num_times_logging_callback_called_); |
272 | 285 |
273 // A fake frame that will be decomposed into 4 packets. | 286 // A fake frame that will be decomposed into 4 packets. |
274 EncodedFrame fake_frame; | 287 EncodedFrame fake_frame; |
275 fake_frame.frame_id = 1; | 288 fake_frame.frame_id = 1; |
276 fake_frame.rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(1)); | 289 fake_frame.rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(1)); |
277 fake_frame.dependency = EncodedFrame::KEY; | 290 fake_frame.dependency = EncodedFrame::KEY; |
278 fake_frame.data.resize(5000, ' '); | 291 fake_frame.data.resize(5000, ' '); |
279 | 292 |
280 transport_.SetPaused(true); | 293 transport_->SetPaused(true); |
281 transport_sender_->InsertFrame(kVideoSsrc, fake_frame); | 294 transport_sender_->InsertFrame(kVideoSsrc, fake_frame); |
282 transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1); | 295 transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1); |
283 transport_.SetPaused(false); | 296 transport_->SetPaused(false); |
284 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 297 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
285 EXPECT_EQ(4, transport_.packets_sent()); | 298 EXPECT_EQ(4, transport_->packets_sent()); |
286 EXPECT_EQ(1, num_times_logging_callback_called_); | 299 EXPECT_EQ(1, num_times_logging_callback_called_); |
287 | 300 |
288 // Resend 2 packets for frame 1. | 301 // Resend 2 packets for frame 1. |
289 MissingFramesAndPacketsMap missing_packets; | 302 MissingFramesAndPacketsMap missing_packets; |
290 missing_packets[1].insert(0); | 303 missing_packets[1].insert(0); |
291 missing_packets[1].insert(1); | 304 missing_packets[1].insert(1); |
292 | 305 |
293 transport_.SetPaused(true); | 306 transport_->SetPaused(true); |
294 DedupInfo dedup_info; | 307 DedupInfo dedup_info; |
295 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); | 308 dedup_info.resend_interval = base::TimeDelta::FromMilliseconds(10); |
296 transport_sender_->ResendPackets( | 309 transport_sender_->ResendPackets( |
297 kVideoSsrc, missing_packets, true, dedup_info); | 310 kVideoSsrc, missing_packets, true, dedup_info); |
298 transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1); | 311 transport_sender_->ResendFrameForKickstart(kVideoSsrc, 1); |
299 transport_.SetPaused(false); | 312 transport_->SetPaused(false); |
300 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 313 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
301 EXPECT_EQ(2, num_times_logging_callback_called_); | 314 EXPECT_EQ(2, num_times_logging_callback_called_); |
302 | 315 |
303 // Resend one packet in the socket when unpaused. | 316 // Resend one packet in the socket when unpaused. |
304 // Two more retransmission packets sent. | 317 // Two more retransmission packets sent. |
305 EXPECT_EQ(7, transport_.packets_sent()); | 318 EXPECT_EQ(7, transport_->packets_sent()); |
306 } | 319 } |
307 | 320 |
308 TEST_F(CastTransportSenderImplTest, DedupRetransmissionWithAudio) { | 321 TEST_F(CastTransportSenderImplTest, DedupRetransmissionWithAudio) { |
309 InitWithLogging(); | 322 InitWithLogging(); |
310 InitializeAudio(); | 323 InitializeAudio(); |
311 InitializeVideo(); | 324 InitializeVideo(); |
312 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 325 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
313 EXPECT_EQ(0, num_times_logging_callback_called_); | 326 EXPECT_EQ(0, num_times_logging_callback_called_); |
314 | 327 |
315 // Send two audio frames. | 328 // Send two audio frames. |
316 EncodedFrame fake_audio; | 329 EncodedFrame fake_audio; |
317 fake_audio.frame_id = 1; | 330 fake_audio.frame_id = 1; |
318 fake_audio.reference_time = testing_clock_.NowTicks(); | 331 fake_audio.reference_time = testing_clock_.NowTicks(); |
319 fake_audio.dependency = EncodedFrame::KEY; | 332 fake_audio.dependency = EncodedFrame::KEY; |
320 fake_audio.data.resize(100, ' '); | 333 fake_audio.data.resize(100, ' '); |
321 transport_sender_->InsertFrame(kAudioSsrc, fake_audio); | 334 transport_sender_->InsertFrame(kAudioSsrc, fake_audio); |
322 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 335 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
323 fake_audio.frame_id = 2; | 336 fake_audio.frame_id = 2; |
324 fake_audio.reference_time = testing_clock_.NowTicks(); | 337 fake_audio.reference_time = testing_clock_.NowTicks(); |
325 transport_sender_->InsertFrame(kAudioSsrc, fake_audio); | 338 transport_sender_->InsertFrame(kAudioSsrc, fake_audio); |
326 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 339 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
327 EXPECT_EQ(2, transport_.packets_sent()); | 340 EXPECT_EQ(2, transport_->packets_sent()); |
328 | 341 |
329 // Ack the first audio frame. | 342 // Ack the first audio frame. |
330 RtcpCastMessage cast_message; | 343 RtcpCastMessage cast_message; |
331 cast_message.media_ssrc = kAudioSsrc; | 344 cast_message.media_ssrc = kAudioSsrc; |
332 cast_message.ack_frame_id = 1; | 345 cast_message.ack_frame_id = 1; |
333 transport_sender_->OnReceivedCastMessage(kAudioSsrc, | 346 transport_sender_->OnReceivedCastMessage(kAudioSsrc, |
334 RtcpCastMessageCallback(), | 347 RtcpCastMessageCallback(), |
335 cast_message); | 348 cast_message); |
336 task_runner_->RunTasks(); | 349 task_runner_->RunTasks(); |
337 EXPECT_EQ(2, transport_.packets_sent()); | 350 EXPECT_EQ(2, transport_->packets_sent()); |
338 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. | 351 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. |
339 | 352 |
340 // Send a fake video frame that will be decomposed into 4 packets. | 353 // Send a fake video frame that will be decomposed into 4 packets. |
341 EncodedFrame fake_video; | 354 EncodedFrame fake_video; |
342 fake_video.frame_id = 1; | 355 fake_video.frame_id = 1; |
343 fake_video.dependency = EncodedFrame::KEY; | 356 fake_video.dependency = EncodedFrame::KEY; |
344 fake_video.data.resize(5000, ' '); | 357 fake_video.data.resize(5000, ' '); |
345 transport_sender_->InsertFrame(kVideoSsrc, fake_video); | 358 transport_sender_->InsertFrame(kVideoSsrc, fake_video); |
346 task_runner_->RunTasks(); | 359 task_runner_->RunTasks(); |
347 EXPECT_EQ(6, transport_.packets_sent()); | 360 EXPECT_EQ(6, transport_->packets_sent()); |
348 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. | 361 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. |
349 | 362 |
350 // Retransmission is reject because audio is not acked yet. | 363 // Retransmission is reject because audio is not acked yet. |
351 cast_message.media_ssrc = kVideoSsrc; | 364 cast_message.media_ssrc = kVideoSsrc; |
352 cast_message.ack_frame_id = 0; | 365 cast_message.ack_frame_id = 0; |
353 cast_message.missing_frames_and_packets[1].insert(3); | 366 cast_message.missing_frames_and_packets[1].insert(3); |
354 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 367 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
355 transport_sender_->OnReceivedCastMessage(kVideoSsrc, | 368 transport_sender_->OnReceivedCastMessage(kVideoSsrc, |
356 RtcpCastMessageCallback(), | 369 RtcpCastMessageCallback(), |
357 cast_message); | 370 cast_message); |
358 task_runner_->RunTasks(); | 371 task_runner_->RunTasks(); |
359 EXPECT_EQ(6, transport_.packets_sent()); | 372 EXPECT_EQ(6, transport_->packets_sent()); |
360 EXPECT_EQ(1, num_times_logging_callback_called_); | 373 EXPECT_EQ(1, num_times_logging_callback_called_); |
361 | 374 |
362 // Ack the second audio frame. | 375 // Ack the second audio frame. |
363 cast_message.media_ssrc = kAudioSsrc; | 376 cast_message.media_ssrc = kAudioSsrc; |
364 cast_message.ack_frame_id = 2; | 377 cast_message.ack_frame_id = 2; |
365 cast_message.missing_frames_and_packets.clear(); | 378 cast_message.missing_frames_and_packets.clear(); |
366 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 379 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
367 transport_sender_->OnReceivedCastMessage(kAudioSsrc, | 380 transport_sender_->OnReceivedCastMessage(kAudioSsrc, |
368 RtcpCastMessageCallback(), | 381 RtcpCastMessageCallback(), |
369 cast_message); | 382 cast_message); |
370 task_runner_->RunTasks(); | 383 task_runner_->RunTasks(); |
371 EXPECT_EQ(6, transport_.packets_sent()); | 384 EXPECT_EQ(6, transport_->packets_sent()); |
372 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 6 ms since last. | 385 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 6 ms since last. |
373 | 386 |
374 // Retransmission of video packet now accepted. | 387 // Retransmission of video packet now accepted. |
375 cast_message.media_ssrc = kVideoSsrc; | 388 cast_message.media_ssrc = kVideoSsrc; |
376 cast_message.ack_frame_id = 1; | 389 cast_message.ack_frame_id = 1; |
377 cast_message.missing_frames_and_packets[1].insert(3); | 390 cast_message.missing_frames_and_packets[1].insert(3); |
378 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 391 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
379 transport_sender_->OnReceivedCastMessage(kVideoSsrc, | 392 transport_sender_->OnReceivedCastMessage(kVideoSsrc, |
380 RtcpCastMessageCallback(), | 393 RtcpCastMessageCallback(), |
381 cast_message); | 394 cast_message); |
382 task_runner_->RunTasks(); | 395 task_runner_->RunTasks(); |
383 EXPECT_EQ(7, transport_.packets_sent()); | 396 EXPECT_EQ(7, transport_->packets_sent()); |
384 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 8 ms since last. | 397 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 8 ms since last. |
385 | 398 |
386 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 399 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
387 EXPECT_EQ(2, num_times_logging_callback_called_); | 400 EXPECT_EQ(2, num_times_logging_callback_called_); |
388 } | 401 } |
389 | 402 |
390 } // namespace cast | 403 } // namespace cast |
391 } // namespace media | 404 } // namespace media |
OLD | NEW |