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