| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 */ | |
| 10 | |
| 11 #include <limits> | |
| 12 #include <memory> | |
| 13 #include <vector> | |
| 14 | |
| 15 #include "testing/gmock/include/gmock/gmock.h" | |
| 16 #include "testing/gtest/include/gtest/gtest.h" | |
| 17 | |
| 18 #include "webrtc/base/checks.h" | |
| 19 #include "webrtc/modules/bitrate_controller/include/mock/mock_bitrate_controller
.h" | |
| 20 #include "webrtc/modules/congestion_controller/transport_feedback_adapter.h" | |
| 21 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" | |
| 22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | |
| 23 #include "webrtc/system_wrappers/include/clock.h" | |
| 24 | |
| 25 using ::testing::_; | |
| 26 using ::testing::Invoke; | |
| 27 | |
| 28 namespace webrtc { | |
| 29 namespace test { | |
| 30 | |
| 31 class TransportFeedbackAdapterTest : public ::testing::Test { | |
| 32 public: | |
| 33 TransportFeedbackAdapterTest() | |
| 34 : clock_(0), bitrate_controller_(this), receiver_estimated_bitrate_(0) {} | |
| 35 | |
| 36 virtual ~TransportFeedbackAdapterTest() {} | |
| 37 | |
| 38 virtual void SetUp() { | |
| 39 adapter_.reset(new TransportFeedbackAdapter(&clock_, &bitrate_controller_)); | |
| 40 adapter_->InitBwe(); | |
| 41 } | |
| 42 | |
| 43 virtual void TearDown() { adapter_.reset(); } | |
| 44 | |
| 45 protected: | |
| 46 // Proxy class used since TransportFeedbackAdapter will own the instance | |
| 47 // passed at construction. | |
| 48 class MockBitrateControllerAdapter : public MockBitrateController { | |
| 49 public: | |
| 50 explicit MockBitrateControllerAdapter(TransportFeedbackAdapterTest* owner) | |
| 51 : MockBitrateController(), owner_(owner) {} | |
| 52 | |
| 53 ~MockBitrateControllerAdapter() override {} | |
| 54 | |
| 55 void OnDelayBasedBweResult(const DelayBasedBwe::Result& result) override { | |
| 56 owner_->receiver_estimated_bitrate_ = result.target_bitrate_bps; | |
| 57 } | |
| 58 | |
| 59 TransportFeedbackAdapterTest* const owner_; | |
| 60 }; | |
| 61 | |
| 62 void OnReceivedEstimatedBitrate(uint32_t bitrate) {} | |
| 63 | |
| 64 void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, | |
| 65 int64_t rtt, | |
| 66 int64_t now_ms) {} | |
| 67 | |
| 68 void ComparePacketVectors(const std::vector<PacketInfo>& truth, | |
| 69 const std::vector<PacketInfo>& input) { | |
| 70 ASSERT_EQ(truth.size(), input.size()); | |
| 71 size_t len = truth.size(); | |
| 72 // truth contains the input data for the test, and input is what will be | |
| 73 // sent to the bandwidth estimator. truth.arrival_tims_ms is used to | |
| 74 // populate the transport feedback messages. As these times may be changed | |
| 75 // (because of resolution limits in the packets, and because of the time | |
| 76 // base adjustment performed by the TransportFeedbackAdapter at the first | |
| 77 // packet, the truth[x].arrival_time and input[x].arrival_time may not be | |
| 78 // equal. However, the difference must be the same for all x. | |
| 79 int64_t arrival_time_delta = | |
| 80 truth[0].arrival_time_ms - input[0].arrival_time_ms; | |
| 81 for (size_t i = 0; i < len; ++i) { | |
| 82 EXPECT_EQ(truth[i].arrival_time_ms, | |
| 83 input[i].arrival_time_ms + arrival_time_delta); | |
| 84 EXPECT_EQ(truth[i].send_time_ms, input[i].send_time_ms); | |
| 85 EXPECT_EQ(truth[i].sequence_number, input[i].sequence_number); | |
| 86 EXPECT_EQ(truth[i].payload_size, input[i].payload_size); | |
| 87 EXPECT_EQ(truth[i].probe_cluster_id, input[i].probe_cluster_id); | |
| 88 } | |
| 89 } | |
| 90 | |
| 91 // Utility method, to reset arrival_time_ms before adding send time. | |
| 92 void OnSentPacket(PacketInfo info) { | |
| 93 info.arrival_time_ms = 0; | |
| 94 adapter_->AddPacket(info.sequence_number, info.payload_size, | |
| 95 info.probe_cluster_id); | |
| 96 adapter_->OnSentPacket(info.sequence_number, info.send_time_ms); | |
| 97 } | |
| 98 | |
| 99 SimulatedClock clock_; | |
| 100 MockBitrateControllerAdapter bitrate_controller_; | |
| 101 std::unique_ptr<TransportFeedbackAdapter> adapter_; | |
| 102 | |
| 103 uint32_t receiver_estimated_bitrate_; | |
| 104 }; | |
| 105 | |
| 106 TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { | |
| 107 std::vector<PacketInfo> packets; | |
| 108 packets.push_back(PacketInfo(100, 200, 0, 1500, 0)); | |
| 109 packets.push_back(PacketInfo(110, 210, 1, 1500, 0)); | |
| 110 packets.push_back(PacketInfo(120, 220, 2, 1500, 0)); | |
| 111 packets.push_back(PacketInfo(130, 230, 3, 1500, 1)); | |
| 112 packets.push_back(PacketInfo(140, 240, 4, 1500, 1)); | |
| 113 | |
| 114 for (const PacketInfo& packet : packets) | |
| 115 OnSentPacket(packet); | |
| 116 | |
| 117 rtcp::TransportFeedback feedback; | |
| 118 feedback.SetBase(packets[0].sequence_number, | |
| 119 packets[0].arrival_time_ms * 1000); | |
| 120 | |
| 121 for (const PacketInfo& packet : packets) { | |
| 122 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | |
| 123 packet.arrival_time_ms * 1000)); | |
| 124 } | |
| 125 | |
| 126 feedback.Build(); | |
| 127 | |
| 128 adapter_->OnTransportFeedback(feedback); | |
| 129 ComparePacketVectors(packets, adapter_->GetTransportFeedbackVector()); | |
| 130 } | |
| 131 | |
| 132 TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { | |
| 133 std::vector<PacketInfo> packets; | |
| 134 packets.push_back(PacketInfo(100, 200, 0, 1500, 1)); | |
| 135 packets.push_back(PacketInfo(110, 210, 1, 1500, 2)); | |
| 136 packets.push_back(PacketInfo(120, 220, 2, 1500, 3)); | |
| 137 packets.push_back(PacketInfo(130, 230, 3, 1500, 4)); | |
| 138 packets.push_back(PacketInfo(140, 240, 4, 1500, 5)); | |
| 139 | |
| 140 const uint16_t kSendSideDropBefore = 1; | |
| 141 const uint16_t kReceiveSideDropAfter = 3; | |
| 142 | |
| 143 for (const PacketInfo& packet : packets) { | |
| 144 if (packet.sequence_number >= kSendSideDropBefore) | |
| 145 OnSentPacket(packet); | |
| 146 } | |
| 147 | |
| 148 rtcp::TransportFeedback feedback; | |
| 149 feedback.SetBase(packets[0].sequence_number, | |
| 150 packets[0].arrival_time_ms * 1000); | |
| 151 | |
| 152 for (const PacketInfo& packet : packets) { | |
| 153 if (packet.sequence_number <= kReceiveSideDropAfter) { | |
| 154 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | |
| 155 packet.arrival_time_ms * 1000)); | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 feedback.Build(); | |
| 160 | |
| 161 std::vector<PacketInfo> expected_packets( | |
| 162 packets.begin() + kSendSideDropBefore, | |
| 163 packets.begin() + kReceiveSideDropAfter + 1); | |
| 164 | |
| 165 adapter_->OnTransportFeedback(feedback); | |
| 166 ComparePacketVectors(expected_packets, | |
| 167 adapter_->GetTransportFeedbackVector()); | |
| 168 } | |
| 169 | |
| 170 TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { | |
| 171 int64_t kHighArrivalTimeMs = rtcp::TransportFeedback::kDeltaScaleFactor * | |
| 172 static_cast<int64_t>(1 << 8) * | |
| 173 static_cast<int64_t>((1 << 23) - 1) / 1000; | |
| 174 std::vector<PacketInfo> packets; | |
| 175 packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, | |
| 176 PacketInfo::kNotAProbe)); | |
| 177 packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, | |
| 178 PacketInfo::kNotAProbe)); | |
| 179 packets.push_back( | |
| 180 PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacketInfo::kNotAProbe)); | |
| 181 | |
| 182 for (const PacketInfo& packet : packets) | |
| 183 OnSentPacket(packet); | |
| 184 | |
| 185 for (size_t i = 0; i < packets.size(); ++i) { | |
| 186 std::unique_ptr<rtcp::TransportFeedback> feedback( | |
| 187 new rtcp::TransportFeedback()); | |
| 188 feedback->SetBase(packets[i].sequence_number, | |
| 189 packets[i].arrival_time_ms * 1000); | |
| 190 | |
| 191 EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number, | |
| 192 packets[i].arrival_time_ms * 1000)); | |
| 193 | |
| 194 rtc::Buffer raw_packet = feedback->Build(); | |
| 195 feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), | |
| 196 raw_packet.size()); | |
| 197 | |
| 198 std::vector<PacketInfo> expected_packets; | |
| 199 expected_packets.push_back(packets[i]); | |
| 200 | |
| 201 adapter_->OnTransportFeedback(*feedback.get()); | |
| 202 ComparePacketVectors(expected_packets, | |
| 203 adapter_->GetTransportFeedbackVector()); | |
| 204 } | |
| 205 } | |
| 206 | |
| 207 TEST_F(TransportFeedbackAdapterTest, HandlesReordering) { | |
| 208 std::vector<PacketInfo> packets; | |
| 209 packets.push_back(PacketInfo(120, 200, 0, 1500, 0)); | |
| 210 packets.push_back(PacketInfo(110, 210, 1, 1500, 0)); | |
| 211 packets.push_back(PacketInfo(100, 220, 2, 1500, 0)); | |
| 212 std::vector<PacketInfo> expected_packets; | |
| 213 expected_packets.push_back(packets[2]); | |
| 214 expected_packets.push_back(packets[1]); | |
| 215 expected_packets.push_back(packets[0]); | |
| 216 | |
| 217 for (const PacketInfo& packet : packets) | |
| 218 OnSentPacket(packet); | |
| 219 | |
| 220 rtcp::TransportFeedback feedback; | |
| 221 feedback.SetBase(packets[0].sequence_number, | |
| 222 packets[0].arrival_time_ms * 1000); | |
| 223 | |
| 224 for (const PacketInfo& packet : packets) { | |
| 225 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | |
| 226 packet.arrival_time_ms * 1000)); | |
| 227 } | |
| 228 | |
| 229 feedback.Build(); | |
| 230 | |
| 231 adapter_->OnTransportFeedback(feedback); | |
| 232 ComparePacketVectors(expected_packets, | |
| 233 adapter_->GetTransportFeedbackVector()); | |
| 234 } | |
| 235 | |
| 236 TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) { | |
| 237 std::vector<PacketInfo> sent_packets; | |
| 238 const int64_t kSmallDeltaUs = | |
| 239 rtcp::TransportFeedback::kDeltaScaleFactor * ((1 << 8) - 1); | |
| 240 const int64_t kLargePositiveDeltaUs = | |
| 241 rtcp::TransportFeedback::kDeltaScaleFactor * | |
| 242 std::numeric_limits<int16_t>::max(); | |
| 243 const int64_t kLargeNegativeDeltaUs = | |
| 244 rtcp::TransportFeedback::kDeltaScaleFactor * | |
| 245 std::numeric_limits<int16_t>::min(); | |
| 246 | |
| 247 PacketInfo info(100, 200, 0, 1500, true, PacketInfo::kNotAProbe); | |
| 248 sent_packets.push_back(info); | |
| 249 | |
| 250 info.send_time_ms += kSmallDeltaUs / 1000; | |
| 251 info.arrival_time_ms += kSmallDeltaUs / 1000; | |
| 252 ++info.sequence_number; | |
| 253 sent_packets.push_back(info); | |
| 254 | |
| 255 info.send_time_ms += kLargePositiveDeltaUs / 1000; | |
| 256 info.arrival_time_ms += kLargePositiveDeltaUs / 1000; | |
| 257 ++info.sequence_number; | |
| 258 sent_packets.push_back(info); | |
| 259 | |
| 260 info.send_time_ms += kLargeNegativeDeltaUs / 1000; | |
| 261 info.arrival_time_ms += kLargeNegativeDeltaUs / 1000; | |
| 262 ++info.sequence_number; | |
| 263 sent_packets.push_back(info); | |
| 264 | |
| 265 // Too large, delta - will need two feedback messages. | |
| 266 info.send_time_ms += (kLargePositiveDeltaUs + 1000) / 1000; | |
| 267 info.arrival_time_ms += (kLargePositiveDeltaUs + 1000) / 1000; | |
| 268 ++info.sequence_number; | |
| 269 | |
| 270 // Packets will be added to send history. | |
| 271 for (const PacketInfo& packet : sent_packets) | |
| 272 OnSentPacket(packet); | |
| 273 OnSentPacket(info); | |
| 274 | |
| 275 // Create expected feedback and send into adapter. | |
| 276 std::unique_ptr<rtcp::TransportFeedback> feedback( | |
| 277 new rtcp::TransportFeedback()); | |
| 278 feedback->SetBase(sent_packets[0].sequence_number, | |
| 279 sent_packets[0].arrival_time_ms * 1000); | |
| 280 | |
| 281 for (const PacketInfo& packet : sent_packets) { | |
| 282 EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number, | |
| 283 packet.arrival_time_ms * 1000)); | |
| 284 } | |
| 285 EXPECT_FALSE(feedback->AddReceivedPacket(info.sequence_number, | |
| 286 info.arrival_time_ms * 1000)); | |
| 287 | |
| 288 rtc::Buffer raw_packet = feedback->Build(); | |
| 289 feedback = | |
| 290 rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); | |
| 291 | |
| 292 std::vector<PacketInfo> received_feedback; | |
| 293 | |
| 294 EXPECT_TRUE(feedback.get() != nullptr); | |
| 295 adapter_->OnTransportFeedback(*feedback.get()); | |
| 296 { | |
| 297 // Expected to be ordered on arrival time when the feedback message has been | |
| 298 // parsed. | |
| 299 std::vector<PacketInfo> expected_packets; | |
| 300 expected_packets.push_back(sent_packets[0]); | |
| 301 expected_packets.push_back(sent_packets[3]); | |
| 302 expected_packets.push_back(sent_packets[1]); | |
| 303 expected_packets.push_back(sent_packets[2]); | |
| 304 ComparePacketVectors(expected_packets, | |
| 305 adapter_->GetTransportFeedbackVector()); | |
| 306 } | |
| 307 | |
| 308 // Create a new feedback message and add the trailing item. | |
| 309 feedback.reset(new rtcp::TransportFeedback()); | |
| 310 feedback->SetBase(info.sequence_number, info.arrival_time_ms * 1000); | |
| 311 EXPECT_TRUE(feedback->AddReceivedPacket(info.sequence_number, | |
| 312 info.arrival_time_ms * 1000)); | |
| 313 raw_packet = feedback->Build(); | |
| 314 feedback = | |
| 315 rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); | |
| 316 | |
| 317 EXPECT_TRUE(feedback.get() != nullptr); | |
| 318 adapter_->OnTransportFeedback(*feedback.get()); | |
| 319 { | |
| 320 std::vector<PacketInfo> expected_packets; | |
| 321 expected_packets.push_back(info); | |
| 322 ComparePacketVectors(expected_packets, | |
| 323 adapter_->GetTransportFeedbackVector()); | |
| 324 } | |
| 325 } | |
| 326 | |
| 327 } // namespace test | |
| 328 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2377303002:
Revert of Fix race / crash in OnNetworkRouteChanged(). (Closed)
