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_impl.h" | 5 #include "media/cast/net/cast_transport_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/ptr_util.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/base/fake_single_thread_task_runner.h" | 17 #include "media/base/fake_single_thread_task_runner.h" |
18 #include "media/cast/net/cast_transport_config.h" | 18 #include "media/cast/net/cast_transport_config.h" |
19 #include "media/cast/net/rtcp/rtcp_defines.h" | 19 #include "media/cast/net/rtcp/rtcp_defines.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 |
27 const int64_t kStartMillisecond = INT64_C(12345678900000); | 27 const int64_t kStartMillisecond = INT64_C(12345678900000); |
28 const uint32_t kVideoSsrc = 1; | 28 const uint32_t kVideoSsrc = 1; |
29 const uint32_t kAudioSsrc = 2; | 29 const uint32_t kAudioSsrc = 2; |
30 | 30 |
31 class RtcpObserver : public SenderRtcpObserver { | |
miu
2016/04/25 23:23:53
naming nit: How about StubRtcpObserver? (and a co
xjz
2016/04/29 19:15:49
Renamed. I don't quite get this comment. CastTrans
miu
2016/05/02 21:30:01
What I meant was that, for this test code, there a
xjz
2016/05/03 18:13:27
Got it. Thanks for the explanation.:)
| |
32 public: | |
33 RtcpObserver() {} | |
34 | |
35 void OnCastMessageReceived(const RtcpCastMessage& cast_message) final {} | |
36 void OnRttReceived(base::TimeDelta round_trip_time) final {} | |
37 void OnPliReceived() final {} | |
38 | |
39 DISALLOW_COPY_AND_ASSIGN(RtcpObserver); | |
40 }; | |
41 | |
31 } // namespace | 42 } // namespace |
32 | 43 |
33 class FakePacketSender : public PacketTransport { | 44 class FakePacketSender : public PacketTransport { |
34 public: | 45 public: |
35 FakePacketSender() : paused_(false), packets_sent_(0), bytes_sent_(0) {} | 46 FakePacketSender() : paused_(false), packets_sent_(0), bytes_sent_(0) {} |
36 | 47 |
37 bool SendPacket(PacketRef packet, const base::Closure& cb) final { | 48 bool SendPacket(PacketRef packet, const base::Closure& cb) final { |
38 if (paused_) { | 49 if (paused_) { |
39 stored_packet_ = packet; | 50 stored_packet_ = packet; |
40 callback_ = cb; | 51 callback_ = cb; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
87 | 98 |
88 void InitWithoutLogging(); | 99 void InitWithoutLogging(); |
89 void InitWithOptions(); | 100 void InitWithOptions(); |
90 void InitWithLogging(); | 101 void InitWithLogging(); |
91 | 102 |
92 void InitializeVideo() { | 103 void InitializeVideo() { |
93 CastTransportRtpConfig rtp_config; | 104 CastTransportRtpConfig rtp_config; |
94 rtp_config.ssrc = kVideoSsrc; | 105 rtp_config.ssrc = kVideoSsrc; |
95 rtp_config.feedback_ssrc = 2; | 106 rtp_config.feedback_ssrc = 2; |
96 rtp_config.rtp_payload_type = 3; | 107 rtp_config.rtp_payload_type = 3; |
97 transport_sender_->InitializeVideo(rtp_config, RtcpCastMessageCallback(), | 108 transport_sender_->InitializeVideo(rtp_config, |
98 RtcpRttCallback(), RtcpPliCallback()); | 109 base::WrapUnique(new RtcpObserver())); |
99 } | 110 } |
100 | 111 |
101 void InitializeAudio() { | 112 void InitializeAudio() { |
102 CastTransportRtpConfig rtp_config; | 113 CastTransportRtpConfig rtp_config; |
103 rtp_config.ssrc = kAudioSsrc; | 114 rtp_config.ssrc = kAudioSsrc; |
104 rtp_config.feedback_ssrc = 3; | 115 rtp_config.feedback_ssrc = 3; |
105 rtp_config.rtp_payload_type = 4; | 116 rtp_config.rtp_payload_type = 4; |
106 transport_sender_->InitializeAudio(rtp_config, RtcpCastMessageCallback(), | 117 transport_sender_->InitializeAudio(rtp_config, |
107 RtcpRttCallback(), RtcpPliCallback()); | 118 base::WrapUnique(new RtcpObserver())); |
108 } | 119 } |
109 | 120 |
110 base::SimpleTestTickClock testing_clock_; | 121 base::SimpleTestTickClock testing_clock_; |
111 scoped_refptr<FakeSingleThreadTaskRunner> task_runner_; | 122 scoped_refptr<FakeSingleThreadTaskRunner> task_runner_; |
112 scoped_ptr<CastTransportImpl> transport_sender_; | 123 std::unique_ptr<CastTransportImpl> transport_sender_; |
113 FakePacketSender* transport_; // Owned by CastTransport. | 124 FakePacketSender* transport_; // Owned by CastTransport. |
114 int num_times_logging_callback_called_; | 125 int num_times_logging_callback_called_; |
115 }; | 126 }; |
116 | 127 |
117 namespace { | 128 namespace { |
118 | 129 |
119 class TransportClient : public CastTransport::Client { | 130 class TransportClient : public CastTransport::Client { |
120 public: | 131 public: |
121 explicit TransportClient( | 132 explicit TransportClient( |
122 CastTransportImplTest* cast_transport_sender_impl_test) | 133 CastTransportImplTest* cast_transport_sender_impl_test) |
123 : cast_transport_sender_impl_test_(cast_transport_sender_impl_test) {} | 134 : cast_transport_sender_impl_test_(cast_transport_sender_impl_test) {} |
124 | 135 |
125 void OnStatusChanged(CastTransportStatus status) final{}; | 136 void OnStatusChanged(CastTransportStatus status) final{}; |
126 void OnLoggingEventsReceived( | 137 void OnLoggingEventsReceived( |
127 scoped_ptr<std::vector<FrameEvent>> frame_events, | 138 std::unique_ptr<std::vector<FrameEvent>> frame_events, |
128 scoped_ptr<std::vector<PacketEvent>> packet_events) final { | 139 std::unique_ptr<std::vector<PacketEvent>> packet_events) final { |
129 CHECK(cast_transport_sender_impl_test_); | 140 CHECK(cast_transport_sender_impl_test_); |
130 cast_transport_sender_impl_test_->ReceivedLoggingEvents(); | 141 cast_transport_sender_impl_test_->ReceivedLoggingEvents(); |
131 }; | 142 }; |
132 void ProcessRtpPacket(scoped_ptr<Packet> packet) final{}; | 143 void ProcessRtpPacket(std::unique_ptr<Packet> packet) final{}; |
133 | 144 |
134 private: | 145 private: |
135 CastTransportImplTest* const cast_transport_sender_impl_test_; | 146 CastTransportImplTest* const cast_transport_sender_impl_test_; |
136 | 147 |
137 DISALLOW_COPY_AND_ASSIGN(TransportClient); | 148 DISALLOW_COPY_AND_ASSIGN(TransportClient); |
138 }; | 149 }; |
139 | 150 |
140 } // namespace | 151 } // namespace |
141 | 152 |
142 void CastTransportImplTest::InitWithoutLogging() { | 153 void CastTransportImplTest::InitWithoutLogging() { |
143 transport_ = new FakePacketSender(); | 154 transport_ = new FakePacketSender(); |
144 transport_sender_.reset( | 155 transport_sender_.reset( |
145 new CastTransportImpl(&testing_clock_, base::TimeDelta(), | 156 new CastTransportImpl(&testing_clock_, base::TimeDelta(), |
146 make_scoped_ptr(new TransportClient(nullptr)), | 157 base::WrapUnique(new TransportClient(nullptr)), |
147 make_scoped_ptr(transport_), task_runner_)); | 158 base::WrapUnique(transport_), task_runner_)); |
148 task_runner_->RunTasks(); | 159 task_runner_->RunTasks(); |
149 } | 160 } |
150 | 161 |
151 void CastTransportImplTest::InitWithOptions() { | 162 void CastTransportImplTest::InitWithOptions() { |
152 scoped_ptr<base::DictionaryValue> options(new base::DictionaryValue); | 163 std::unique_ptr<base::DictionaryValue> options(new base::DictionaryValue); |
153 options->SetBoolean("disable_wifi_scan", true); | 164 options->SetBoolean("disable_wifi_scan", true); |
154 options->SetBoolean("media_streaming_mode", true); | 165 options->SetBoolean("media_streaming_mode", true); |
155 options->SetInteger("pacer_target_burst_size", 20); | 166 options->SetInteger("pacer_target_burst_size", 20); |
156 options->SetInteger("pacer_max_burst_size", 100); | 167 options->SetInteger("pacer_max_burst_size", 100); |
157 transport_ = new FakePacketSender(); | 168 transport_ = new FakePacketSender(); |
158 transport_sender_.reset( | 169 transport_sender_.reset( |
159 new CastTransportImpl(&testing_clock_, base::TimeDelta(), | 170 new CastTransportImpl(&testing_clock_, base::TimeDelta(), |
160 make_scoped_ptr(new TransportClient(nullptr)), | 171 base::WrapUnique(new TransportClient(nullptr)), |
161 make_scoped_ptr(transport_), task_runner_)); | 172 base::WrapUnique(transport_), task_runner_)); |
162 transport_sender_->SetOptions(*options); | 173 transport_sender_->SetOptions(*options); |
163 task_runner_->RunTasks(); | 174 task_runner_->RunTasks(); |
164 } | 175 } |
165 | 176 |
166 void CastTransportImplTest::InitWithLogging() { | 177 void CastTransportImplTest::InitWithLogging() { |
167 transport_ = new FakePacketSender(); | 178 transport_ = new FakePacketSender(); |
168 transport_sender_.reset(new CastTransportImpl( | 179 transport_sender_.reset(new CastTransportImpl( |
169 &testing_clock_, base::TimeDelta::FromMilliseconds(10), | 180 &testing_clock_, base::TimeDelta::FromMilliseconds(10), |
170 make_scoped_ptr(new TransportClient(this)), make_scoped_ptr(transport_), | 181 base::WrapUnique(new TransportClient(this)), base::WrapUnique(transport_), |
171 task_runner_)); | 182 task_runner_)); |
172 task_runner_->RunTasks(); | 183 task_runner_->RunTasks(); |
173 } | 184 } |
174 | 185 |
175 TEST_F(CastTransportImplTest, InitWithoutLogging) { | 186 TEST_F(CastTransportImplTest, InitWithoutLogging) { |
176 InitWithoutLogging(); | 187 InitWithoutLogging(); |
177 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); | 188 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(50)); |
178 EXPECT_EQ(0, num_times_logging_callback_called_); | 189 EXPECT_EQ(0, num_times_logging_callback_called_); |
179 } | 190 } |
180 | 191 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
214 transport_sender_->ResendPackets(kVideoSsrc, missing_packets, true, | 225 transport_sender_->ResendPackets(kVideoSsrc, missing_packets, true, |
215 dedup_info); | 226 dedup_info); |
216 | 227 |
217 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 228 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
218 EXPECT_EQ(2, num_times_logging_callback_called_); | 229 EXPECT_EQ(2, num_times_logging_callback_called_); |
219 | 230 |
220 RtcpCastMessage cast_message; | 231 RtcpCastMessage cast_message; |
221 cast_message.remote_ssrc = kVideoSsrc; | 232 cast_message.remote_ssrc = kVideoSsrc; |
222 cast_message.ack_frame_id = 1; | 233 cast_message.ack_frame_id = 1; |
223 cast_message.missing_frames_and_packets[1].insert(3); | 234 cast_message.missing_frames_and_packets[1].insert(3); |
224 transport_sender_->OnReceivedCastMessage( | 235 transport_sender_->OnReceivedCastMessage(kVideoSsrc, cast_message); |
225 kVideoSsrc, RtcpCastMessageCallback(), cast_message); | |
226 transport_->SetPaused(false); | 236 transport_->SetPaused(false); |
227 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 237 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
228 EXPECT_EQ(3, num_times_logging_callback_called_); | 238 EXPECT_EQ(3, num_times_logging_callback_called_); |
229 | 239 |
230 // Resend one packet in the socket when unpaused. | 240 // Resend one packet in the socket when unpaused. |
231 // Resend one more packet from NACK. | 241 // Resend one more packet from NACK. |
232 EXPECT_EQ(6, transport_->packets_sent()); | 242 EXPECT_EQ(6, transport_->packets_sent()); |
233 } | 243 } |
234 | 244 |
235 TEST_F(CastTransportImplTest, CancelRetransmits) { | 245 TEST_F(CastTransportImplTest, CancelRetransmits) { |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
333 fake_audio.frame_id = 2; | 343 fake_audio.frame_id = 2; |
334 fake_audio.reference_time = testing_clock_.NowTicks(); | 344 fake_audio.reference_time = testing_clock_.NowTicks(); |
335 transport_sender_->InsertFrame(kAudioSsrc, fake_audio); | 345 transport_sender_->InsertFrame(kAudioSsrc, fake_audio); |
336 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 346 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
337 EXPECT_EQ(2, transport_->packets_sent()); | 347 EXPECT_EQ(2, transport_->packets_sent()); |
338 | 348 |
339 // Ack the first audio frame. | 349 // Ack the first audio frame. |
340 RtcpCastMessage cast_message; | 350 RtcpCastMessage cast_message; |
341 cast_message.remote_ssrc = kAudioSsrc; | 351 cast_message.remote_ssrc = kAudioSsrc; |
342 cast_message.ack_frame_id = 1; | 352 cast_message.ack_frame_id = 1; |
343 transport_sender_->OnReceivedCastMessage( | 353 transport_sender_->OnReceivedCastMessage(kAudioSsrc, cast_message); |
344 kAudioSsrc, RtcpCastMessageCallback(), cast_message); | |
345 task_runner_->RunTasks(); | 354 task_runner_->RunTasks(); |
346 EXPECT_EQ(2, transport_->packets_sent()); | 355 EXPECT_EQ(2, transport_->packets_sent()); |
347 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. | 356 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. |
348 | 357 |
349 // Send a fake video frame that will be decomposed into 4 packets. | 358 // Send a fake video frame that will be decomposed into 4 packets. |
350 EncodedFrame fake_video; | 359 EncodedFrame fake_video; |
351 fake_video.frame_id = 1; | 360 fake_video.frame_id = 1; |
352 fake_video.dependency = EncodedFrame::KEY; | 361 fake_video.dependency = EncodedFrame::KEY; |
353 fake_video.data.resize(5000, ' '); | 362 fake_video.data.resize(5000, ' '); |
354 transport_sender_->InsertFrame(kVideoSsrc, fake_video); | 363 transport_sender_->InsertFrame(kVideoSsrc, fake_video); |
355 task_runner_->RunTasks(); | 364 task_runner_->RunTasks(); |
356 EXPECT_EQ(6, transport_->packets_sent()); | 365 EXPECT_EQ(6, transport_->packets_sent()); |
357 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. | 366 EXPECT_EQ(0, num_times_logging_callback_called_); // Only 4 ms since last. |
358 | 367 |
359 // Retransmission is reject because audio is not acked yet. | 368 // Retransmission is reject because audio is not acked yet. |
360 cast_message.remote_ssrc = kVideoSsrc; | 369 cast_message.remote_ssrc = kVideoSsrc; |
361 cast_message.ack_frame_id = 0; | 370 cast_message.ack_frame_id = 0; |
362 cast_message.missing_frames_and_packets[1].insert(3); | 371 cast_message.missing_frames_and_packets[1].insert(3); |
363 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); | 372 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(10)); |
364 transport_sender_->OnReceivedCastMessage( | 373 transport_sender_->OnReceivedCastMessage(kVideoSsrc, cast_message); |
365 kVideoSsrc, RtcpCastMessageCallback(), cast_message); | |
366 task_runner_->RunTasks(); | 374 task_runner_->RunTasks(); |
367 EXPECT_EQ(6, transport_->packets_sent()); | 375 EXPECT_EQ(6, transport_->packets_sent()); |
368 EXPECT_EQ(1, num_times_logging_callback_called_); | 376 EXPECT_EQ(1, num_times_logging_callback_called_); |
369 | 377 |
370 // Ack the second audio frame. | 378 // Ack the second audio frame. |
371 cast_message.remote_ssrc = kAudioSsrc; | 379 cast_message.remote_ssrc = kAudioSsrc; |
372 cast_message.ack_frame_id = 2; | 380 cast_message.ack_frame_id = 2; |
373 cast_message.missing_frames_and_packets.clear(); | 381 cast_message.missing_frames_and_packets.clear(); |
374 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 382 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
375 transport_sender_->OnReceivedCastMessage( | 383 transport_sender_->OnReceivedCastMessage(kAudioSsrc, cast_message); |
376 kAudioSsrc, RtcpCastMessageCallback(), cast_message); | |
377 task_runner_->RunTasks(); | 384 task_runner_->RunTasks(); |
378 EXPECT_EQ(6, transport_->packets_sent()); | 385 EXPECT_EQ(6, transport_->packets_sent()); |
379 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 6 ms since last. | 386 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 6 ms since last. |
380 | 387 |
381 // Retransmission of video packet now accepted. | 388 // Retransmission of video packet now accepted. |
382 cast_message.remote_ssrc = kVideoSsrc; | 389 cast_message.remote_ssrc = kVideoSsrc; |
383 cast_message.ack_frame_id = 1; | 390 cast_message.ack_frame_id = 1; |
384 cast_message.missing_frames_and_packets[1].insert(3); | 391 cast_message.missing_frames_and_packets[1].insert(3); |
385 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 392 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
386 transport_sender_->OnReceivedCastMessage( | 393 transport_sender_->OnReceivedCastMessage(kVideoSsrc, cast_message); |
387 kVideoSsrc, RtcpCastMessageCallback(), cast_message); | |
388 task_runner_->RunTasks(); | 394 task_runner_->RunTasks(); |
389 EXPECT_EQ(7, transport_->packets_sent()); | 395 EXPECT_EQ(7, transport_->packets_sent()); |
390 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 8 ms since last. | 396 EXPECT_EQ(1, num_times_logging_callback_called_); // Only 8 ms since last. |
391 | 397 |
392 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); | 398 task_runner_->Sleep(base::TimeDelta::FromMilliseconds(2)); |
393 EXPECT_EQ(2, num_times_logging_callback_called_); | 399 EXPECT_EQ(2, num_times_logging_callback_called_); |
394 } | 400 } |
395 | 401 |
396 } // namespace cast | 402 } // namespace cast |
397 } // namespace media | 403 } // namespace media |
OLD | NEW |