Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(236)

Side by Side Diff: media/cast/net/cast_transport_impl_unittest.cc

Issue 1878883003: Refactor: simplify interface of SenderRtcpSession and CastTransport. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Addressed comments. Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698