| 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 |