OLD | NEW |
| (Empty) |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/test/simple_test_tick_clock.h" | |
6 #include "media/cast/pacing/paced_sender.h" | |
7 #include "media/cast/test/fake_task_runner.h" | |
8 #include "testing/gmock/include/gmock/gmock.h" | |
9 | |
10 namespace media { | |
11 namespace cast { | |
12 | |
13 using testing::_; | |
14 | |
15 static const uint8 kValue = 123; | |
16 static const size_t kSize1 = 100; | |
17 static const size_t kSize2 = 101; | |
18 static const size_t kSize3 = 102; | |
19 static const size_t kSize4 = 103; | |
20 static const size_t kNackSize = 104; | |
21 static const int64 kStartMillisecond = GG_INT64_C(12345678900000); | |
22 | |
23 class TestPacketSender : public PacketSender { | |
24 public: | |
25 virtual bool SendPackets(const PacketList& packets) OVERRIDE { | |
26 PacketList::const_iterator it = packets.begin(); | |
27 for (; it != packets.end(); ++it) { | |
28 EXPECT_FALSE(expected_packet_size_.empty()); | |
29 size_t expected_packet_size = expected_packet_size_.front(); | |
30 expected_packet_size_.pop_front(); | |
31 EXPECT_EQ(expected_packet_size, it->size()); | |
32 } | |
33 return true; | |
34 } | |
35 | |
36 virtual bool SendPacket(const Packet& packet) OVERRIDE { | |
37 return true; | |
38 } | |
39 | |
40 void AddExpectedSize(int expected_packet_size, int repeat_count) { | |
41 for (int i = 0; i < repeat_count; ++i) { | |
42 expected_packet_size_.push_back(expected_packet_size); | |
43 } | |
44 } | |
45 | |
46 private: | |
47 std::list<int> expected_packet_size_; | |
48 }; | |
49 | |
50 class PacedSenderTest : public ::testing::Test { | |
51 protected: | |
52 PacedSenderTest() { | |
53 testing_clock_.Advance( | |
54 base::TimeDelta::FromMilliseconds(kStartMillisecond)); | |
55 } | |
56 | |
57 virtual ~PacedSenderTest() {} | |
58 | |
59 virtual void SetUp() { | |
60 task_runner_ = new test::FakeTaskRunner(&testing_clock_); | |
61 cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_, | |
62 task_runner_, task_runner_, task_runner_, task_runner_, | |
63 GetDefaultCastLoggingConfig()); | |
64 paced_sender_.reset(new PacedSender(cast_environment_, &mock_transport_)); | |
65 } | |
66 | |
67 PacketList CreatePacketList(size_t packet_size, int num_of_packets_in_frame) { | |
68 PacketList packets; | |
69 for (int i = 0; i < num_of_packets_in_frame; ++i) { | |
70 packets.push_back(Packet(packet_size, kValue)); | |
71 } | |
72 return packets; | |
73 } | |
74 | |
75 base::SimpleTestTickClock testing_clock_; | |
76 TestPacketSender mock_transport_; | |
77 scoped_refptr<test::FakeTaskRunner> task_runner_; | |
78 scoped_ptr<PacedSender> paced_sender_; | |
79 scoped_refptr<CastEnvironment> cast_environment_; | |
80 }; | |
81 | |
82 TEST_F(PacedSenderTest, PassThroughRtcp) { | |
83 mock_transport_.AddExpectedSize(kSize1, 1); | |
84 PacketList packets = CreatePacketList(kSize1, 1); | |
85 | |
86 EXPECT_TRUE(paced_sender_->SendPackets(packets)); | |
87 EXPECT_TRUE(paced_sender_->ResendPackets(packets)); | |
88 | |
89 mock_transport_.AddExpectedSize(kSize2, 1); | |
90 EXPECT_TRUE(paced_sender_->SendRtcpPacket(Packet(kSize2, kValue))); | |
91 } | |
92 | |
93 TEST_F(PacedSenderTest, BasicPace) { | |
94 int num_of_packets = 9; | |
95 PacketList packets = CreatePacketList(kSize1, num_of_packets); | |
96 | |
97 mock_transport_.AddExpectedSize(kSize1, 3); | |
98 EXPECT_TRUE(paced_sender_->SendPackets(packets)); | |
99 | |
100 // Check that we get the next burst. | |
101 mock_transport_.AddExpectedSize(kSize1, 3); | |
102 | |
103 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10); | |
104 testing_clock_.Advance(timeout); | |
105 task_runner_->RunTasks(); | |
106 | |
107 // If we call process too early make sure we don't send any packets. | |
108 timeout = base::TimeDelta::FromMilliseconds(5); | |
109 testing_clock_.Advance(timeout); | |
110 task_runner_->RunTasks(); | |
111 | |
112 // Check that we get the next burst. | |
113 mock_transport_.AddExpectedSize(kSize1, 3); | |
114 testing_clock_.Advance(timeout); | |
115 task_runner_->RunTasks(); | |
116 | |
117 // Check that we don't get any more packets. | |
118 testing_clock_.Advance(timeout); | |
119 task_runner_->RunTasks(); | |
120 } | |
121 | |
122 TEST_F(PacedSenderTest, PaceWithNack) { | |
123 // Testing what happen when we get multiple NACK requests for a fully lost | |
124 // frames just as we sent the first packets in a frame. | |
125 int num_of_packets_in_frame = 9; | |
126 int num_of_packets_in_nack = 9; | |
127 | |
128 PacketList first_frame_packets = | |
129 CreatePacketList(kSize1, num_of_packets_in_frame); | |
130 | |
131 PacketList second_frame_packets = | |
132 CreatePacketList(kSize2, num_of_packets_in_frame); | |
133 | |
134 PacketList nack_packets = | |
135 CreatePacketList(kNackSize, num_of_packets_in_nack); | |
136 | |
137 // Check that the first burst of the frame go out on the wire. | |
138 mock_transport_.AddExpectedSize(kSize1, 3); | |
139 EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets)); | |
140 | |
141 // Add first NACK request. | |
142 EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets)); | |
143 | |
144 // Check that we get the first NACK burst. | |
145 mock_transport_.AddExpectedSize(kNackSize, 5); | |
146 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10); | |
147 testing_clock_.Advance(timeout); | |
148 task_runner_->RunTasks(); | |
149 | |
150 // Add second NACK request. | |
151 EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets)); | |
152 | |
153 // Check that we get the next NACK burst. | |
154 mock_transport_.AddExpectedSize(kNackSize, 7); | |
155 testing_clock_.Advance(timeout); | |
156 task_runner_->RunTasks(); | |
157 | |
158 // End of NACK plus a packet from the oldest frame. | |
159 mock_transport_.AddExpectedSize(kNackSize, 6); | |
160 mock_transport_.AddExpectedSize(kSize1, 1); | |
161 testing_clock_.Advance(timeout); | |
162 task_runner_->RunTasks(); | |
163 | |
164 // Add second frame. | |
165 // Make sure we don't delay the second frame due to the previous packets. | |
166 EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets)); | |
167 | |
168 // Last packets of frame 1 and the first packets of frame 2. | |
169 mock_transport_.AddExpectedSize(kSize1, 5); | |
170 mock_transport_.AddExpectedSize(kSize2, 2); | |
171 testing_clock_.Advance(timeout); | |
172 task_runner_->RunTasks(); | |
173 | |
174 // Last packets of frame 2. | |
175 mock_transport_.AddExpectedSize(kSize2, 7); | |
176 testing_clock_.Advance(timeout); | |
177 task_runner_->RunTasks(); | |
178 | |
179 // No more packets. | |
180 testing_clock_.Advance(timeout); | |
181 task_runner_->RunTasks(); | |
182 } | |
183 | |
184 TEST_F(PacedSenderTest, PaceWith60fps) { | |
185 // Testing what happen when we get multiple NACK requests for a fully lost | |
186 // frames just as we sent the first packets in a frame. | |
187 int num_of_packets_in_frame = 9; | |
188 | |
189 PacketList first_frame_packets = | |
190 CreatePacketList(kSize1, num_of_packets_in_frame); | |
191 | |
192 PacketList second_frame_packets = | |
193 CreatePacketList(kSize2, num_of_packets_in_frame); | |
194 | |
195 PacketList third_frame_packets = | |
196 CreatePacketList(kSize3, num_of_packets_in_frame); | |
197 | |
198 PacketList fourth_frame_packets = | |
199 CreatePacketList(kSize4, num_of_packets_in_frame); | |
200 | |
201 base::TimeDelta timeout_10ms = base::TimeDelta::FromMilliseconds(10); | |
202 | |
203 // Check that the first burst of the frame go out on the wire. | |
204 mock_transport_.AddExpectedSize(kSize1, 3); | |
205 EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets)); | |
206 | |
207 mock_transport_.AddExpectedSize(kSize1, 3); | |
208 testing_clock_.Advance(timeout_10ms); | |
209 task_runner_->RunTasks(); | |
210 | |
211 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(6)); | |
212 | |
213 // Add second frame, after 16 ms. | |
214 EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets)); | |
215 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(4)); | |
216 | |
217 mock_transport_.AddExpectedSize(kSize1, 3); | |
218 mock_transport_.AddExpectedSize(kSize2, 1); | |
219 testing_clock_.Advance(timeout_10ms); | |
220 task_runner_->RunTasks(); | |
221 | |
222 mock_transport_.AddExpectedSize(kSize2, 4); | |
223 testing_clock_.Advance(timeout_10ms); | |
224 task_runner_->RunTasks(); | |
225 | |
226 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(3)); | |
227 | |
228 // Add third frame, after 33 ms. | |
229 EXPECT_TRUE(paced_sender_->SendPackets(third_frame_packets)); | |
230 mock_transport_.AddExpectedSize(kSize2, 4); | |
231 mock_transport_.AddExpectedSize(kSize3, 1); | |
232 | |
233 testing_clock_.Advance(base::TimeDelta::FromMilliseconds(7)); | |
234 task_runner_->RunTasks(); | |
235 | |
236 // Add fourth frame, after 50 ms. | |
237 EXPECT_TRUE(paced_sender_->SendPackets(fourth_frame_packets)); | |
238 | |
239 mock_transport_.AddExpectedSize(kSize3, 6); | |
240 testing_clock_.Advance(timeout_10ms); | |
241 task_runner_->RunTasks(); | |
242 | |
243 mock_transport_.AddExpectedSize(kSize3, 2); | |
244 mock_transport_.AddExpectedSize(kSize4, 4); | |
245 testing_clock_.Advance(timeout_10ms); | |
246 task_runner_->RunTasks(); | |
247 | |
248 mock_transport_.AddExpectedSize(kSize4, 5); | |
249 testing_clock_.Advance(timeout_10ms); | |
250 task_runner_->RunTasks(); | |
251 | |
252 testing_clock_.Advance(timeout_10ms); | |
253 task_runner_->RunTasks(); | |
254 } | |
255 | |
256 } // namespace cast | |
257 } // namespace media | |
OLD | NEW |