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

Side by Side Diff: media/cast/net/rtcp/rtcp_unittest.cc

Issue 1878883003: Refactor: simplify interface of SenderRtcpSession and CastTransport. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: 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 <stddef.h> 5 #include <stddef.h>
6 #include <stdint.h> 6 #include <stdint.h>
7 #include <vector> 7 #include <vector>
8 8
9 #include "base/bind.h" 9 #include "base/bind.h"
10 #include "base/macros.h" 10 #include "base/macros.h"
11 #include "base/memory/ptr_util.h"
11 #include "base/test/simple_test_tick_clock.h" 12 #include "base/test/simple_test_tick_clock.h"
12 #include "media/cast/net/cast_transport_config.h" 13 #include "media/cast/net/cast_transport_config.h"
13 #include "media/cast/net/pacing/paced_sender.h" 14 #include "media/cast/net/pacing/paced_sender.h"
14 #include "media/cast/net/rtcp/receiver_rtcp_session.h" 15 #include "media/cast/net/rtcp/receiver_rtcp_session.h"
15 #include "media/cast/net/rtcp/rtcp_builder.h" 16 #include "media/cast/net/rtcp/rtcp_builder.h"
16 #include "media/cast/net/rtcp/rtcp_session.h" 17 #include "media/cast/net/rtcp/rtcp_session.h"
17 #include "media/cast/net/rtcp/rtcp_utility.h" 18 #include "media/cast/net/rtcp/rtcp_utility.h"
18 #include "media/cast/net/rtcp/sender_rtcp_session.h" 19 #include "media/cast/net/rtcp/sender_rtcp_session.h"
19 #include "media/cast/test/skewed_tick_clock.h" 20 #include "media/cast/test/skewed_tick_clock.h"
20 #include "testing/gmock/include/gmock/gmock.h" 21 #include "testing/gmock/include/gmock/gmock.h"
21 22
22 namespace media { 23 namespace media {
23 namespace cast { 24 namespace cast {
24 25
26 class RtcpTest;
27
25 namespace { 28 namespace {
26 29
27 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) { 30 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) {
28 media::cast::RtcpTimeData ret; 31 media::cast::RtcpTimeData ret;
29 ret.timestamp = now; 32 ret.timestamp = now;
30 media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction); 33 media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction);
31 return ret; 34 return ret;
32 } 35 }
33 36
37 class RtcpClient : public SenderRtcpSession::Client {
38 public:
39 explicit RtcpClient(RtcpTest* rtcp_test) : rtcp_test_(rtcp_test) {}
40
41 void OnCastMessageReceived(const RtcpCastMessage& cast_message) override;
42 void OnRttReceived(base::TimeDelta round_trip_time) override;
43 void OnReceiverLogReceived(const RtcpReceiverLogMessage& log) override;
44 void OnPliReceived() override;
45
46 private:
47 RtcpTest* const rtcp_test_;
48
49 DISALLOW_COPY_AND_ASSIGN(RtcpClient);
50 };
51
34 } // namespace 52 } // namespace
35 53
36 using testing::_; 54 using testing::_;
37 55
38 static const uint32_t kSenderSsrc = 0x10203; 56 static const uint32_t kSenderSsrc = 0x10203;
39 static const uint32_t kReceiverSsrc = 0x40506; 57 static const uint32_t kReceiverSsrc = 0x40506;
40 static const int kInitialReceiverClockOffsetSeconds = -5; 58 static const int kInitialReceiverClockOffsetSeconds = -5;
41 static const uint16_t kTargetDelayMs = 100; 59 static const uint16_t kTargetDelayMs = 100;
42 60
43 class FakeRtcpTransport : public PacedPacketSender { 61 class FakeRtcpTransport : public PacedPacketSender {
(...skipping 25 matching lines...) Expand all
69 87
70 private: 88 private:
71 base::SimpleTestTickClock* const clock_; 89 base::SimpleTestTickClock* const clock_;
72 base::TimeDelta packet_delay_; 90 base::TimeDelta packet_delay_;
73 RtcpSession* rtcp_session_; // RTCP destination. 91 RtcpSession* rtcp_session_; // RTCP destination.
74 92
75 DISALLOW_COPY_AND_ASSIGN(FakeRtcpTransport); 93 DISALLOW_COPY_AND_ASSIGN(FakeRtcpTransport);
76 }; 94 };
77 95
78 class RtcpTest : public ::testing::Test { 96 class RtcpTest : public ::testing::Test {
79 protected: 97 public:
80 RtcpTest()
81 : sender_clock_(new base::SimpleTestTickClock()),
82 receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
83 rtp_sender_pacer_(sender_clock_.get()),
84 rtp_receiver_pacer_(sender_clock_.get()),
85 rtcp_at_rtp_sender_(
86 base::Bind(&RtcpTest::OnReceivedCastFeedback,
87 base::Unretained(this)),
88 base::Bind(&RtcpTest::OnMeasuredRoundTripTime,
89 base::Unretained(this)),
90 base::Bind(&RtcpTest::OnReceivedLogs, base::Unretained(this)),
91 base::Bind(&RtcpTest::OnReceivedPli, base::Unretained(this)),
92 sender_clock_.get(),
93 &rtp_sender_pacer_,
94 kSenderSsrc,
95 kReceiverSsrc),
96 rtcp_at_rtp_receiver_(receiver_clock_.get(),
97 kReceiverSsrc,
98 kSenderSsrc),
99 received_pli_(false) {
100 sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
101 receiver_clock_->SetSkew(
102 1.0, // No skew.
103 base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds));
104
105 rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_);
106 rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_);
107 }
108
109 ~RtcpTest() override {}
110
111 void OnReceivedCastFeedback(const RtcpCastMessage& cast_message) { 98 void OnReceivedCastFeedback(const RtcpCastMessage& cast_message) {
112 last_cast_message_ = cast_message; 99 last_cast_message_ = cast_message;
113 } 100 }
114 101
115 void OnMeasuredRoundTripTime(base::TimeDelta rtt) { 102 void OnMeasuredRoundTripTime(base::TimeDelta rtt) {
116 current_round_trip_time_ = rtt; 103 current_round_trip_time_ = rtt;
117 } 104 }
118 105
119 void OnReceivedLogs(const RtcpReceiverLogMessage& receiver_logs) { 106 void OnReceivedLogs(const RtcpReceiverLogMessage& receiver_logs) {
120 RtcpReceiverLogMessage().swap(last_logs_); 107 RtcpReceiverLogMessage().swap(last_logs_);
121 108
122 // Make a copy of the logs. 109 // Make a copy of the logs.
123 for (const RtcpReceiverFrameLogMessage& frame_log_msg : receiver_logs) { 110 for (const RtcpReceiverFrameLogMessage& frame_log_msg : receiver_logs) {
124 last_logs_.push_back( 111 last_logs_.push_back(
125 RtcpReceiverFrameLogMessage(frame_log_msg.rtp_timestamp_)); 112 RtcpReceiverFrameLogMessage(frame_log_msg.rtp_timestamp_));
126 for (const RtcpReceiverEventLogMessage& event_log_msg : 113 for (const RtcpReceiverEventLogMessage& event_log_msg :
127 frame_log_msg.event_log_messages_) { 114 frame_log_msg.event_log_messages_) {
128 RtcpReceiverEventLogMessage event_log; 115 RtcpReceiverEventLogMessage event_log;
129 event_log.type = event_log_msg.type; 116 event_log.type = event_log_msg.type;
130 event_log.event_timestamp = event_log_msg.event_timestamp; 117 event_log.event_timestamp = event_log_msg.event_timestamp;
131 event_log.delay_delta = event_log_msg.delay_delta; 118 event_log.delay_delta = event_log_msg.delay_delta;
132 event_log.packet_id = event_log_msg.packet_id; 119 event_log.packet_id = event_log_msg.packet_id;
133 last_logs_.back().event_log_messages_.push_back(event_log); 120 last_logs_.back().event_log_messages_.push_back(event_log);
134 } 121 }
135 } 122 }
136 } 123 }
137 124
125 void OnReceivedPli() { received_pli_ = true; }
126
127 protected:
128 RtcpTest()
129 : sender_clock_(new base::SimpleTestTickClock()),
130 receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
131 rtp_sender_pacer_(sender_clock_.get()),
132 rtp_receiver_pacer_(sender_clock_.get()),
133 rtcp_at_rtp_sender_(base::WrapUnique(new RtcpClient(this)),
134 sender_clock_.get(),
135 &rtp_sender_pacer_,
136 kSenderSsrc,
137 kReceiverSsrc),
138 rtcp_at_rtp_receiver_(receiver_clock_.get(),
139 kReceiverSsrc,
140 kSenderSsrc),
141 received_pli_(false) {
142 sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
143 receiver_clock_->SetSkew(
144 1.0, // No skew.
145 base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds));
146
147 rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_);
148 rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_);
149 }
150
151 ~RtcpTest() override {}
152
138 PacketRef BuildRtcpPacketFromRtpReceiver( 153 PacketRef BuildRtcpPacketFromRtpReceiver(
139 const RtcpTimeData& time_data, 154 const RtcpTimeData& time_data,
140 const RtcpCastMessage* cast_message, 155 const RtcpCastMessage* cast_message,
141 const RtcpPliMessage* pli_message, 156 const RtcpPliMessage* pli_message,
142 base::TimeDelta target_delay, 157 base::TimeDelta target_delay,
143 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, 158 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
144 const RtpReceiverStatistics* rtp_receiver_statistics) { 159 const RtpReceiverStatistics* rtp_receiver_statistics) {
145 RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc()); 160 RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc());
146 builder.Start(); 161 builder.Start();
147 RtcpReceiverReferenceTimeReport rrtr; 162 RtcpReceiverReferenceTimeReport rrtr;
(...skipping 27 matching lines...) Expand all
175 } 190 }
176 if (cast_message) 191 if (cast_message)
177 builder.AddCast(*cast_message, target_delay); 192 builder.AddCast(*cast_message, target_delay);
178 if (pli_message) 193 if (pli_message)
179 builder.AddPli(*pli_message); 194 builder.AddPli(*pli_message);
180 if (rtcp_events) 195 if (rtcp_events)
181 builder.AddReceiverLog(*rtcp_events); 196 builder.AddReceiverLog(*rtcp_events);
182 return builder.Finish(); 197 return builder.Finish();
183 } 198 }
184 199
185 void OnReceivedPli() { received_pli_ = true; } 200 std::unique_ptr<base::SimpleTestTickClock> sender_clock_;
186 201 std::unique_ptr<test::SkewedTickClock> receiver_clock_;
187 scoped_ptr<base::SimpleTestTickClock> sender_clock_;
188 scoped_ptr<test::SkewedTickClock> receiver_clock_;
189 FakeRtcpTransport rtp_sender_pacer_; 202 FakeRtcpTransport rtp_sender_pacer_;
190 FakeRtcpTransport rtp_receiver_pacer_; 203 FakeRtcpTransport rtp_receiver_pacer_;
191 SenderRtcpSession rtcp_at_rtp_sender_; 204 SenderRtcpSession rtcp_at_rtp_sender_;
192 ReceiverRtcpSession rtcp_at_rtp_receiver_; 205 ReceiverRtcpSession rtcp_at_rtp_receiver_;
193 206
194 base::TimeDelta current_round_trip_time_; 207 base::TimeDelta current_round_trip_time_;
195 RtcpCastMessage last_cast_message_; 208 RtcpCastMessage last_cast_message_;
196 RtcpReceiverLogMessage last_logs_; 209 RtcpReceiverLogMessage last_logs_;
197 bool received_pli_; 210 bool received_pli_;
198 211
199 private: 212 private:
200 DISALLOW_COPY_AND_ASSIGN(RtcpTest); 213 DISALLOW_COPY_AND_ASSIGN(RtcpTest);
201 }; 214 };
202 215
216 namespace {
217
218 void RtcpClient::OnCastMessageReceived(const RtcpCastMessage& cast_message) {
219 rtcp_test_->OnReceivedCastFeedback(cast_message);
220 }
221
222 void RtcpClient::OnRttReceived(base::TimeDelta round_trip_time) {
223 rtcp_test_->OnMeasuredRoundTripTime(round_trip_time);
224 }
225
226 void RtcpClient::OnReceiverLogReceived(const RtcpReceiverLogMessage& log) {
227 rtcp_test_->OnReceivedLogs(log);
228 }
229
230 void RtcpClient::OnPliReceived() {
231 rtcp_test_->OnReceivedPli();
232 }
233
234 } // namespace
235
203 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) { 236 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) {
204 // Initially, expect no lip-sync info receiver-side without having first 237 // Initially, expect no lip-sync info receiver-side without having first
205 // received a RTCP packet. 238 // received a RTCP packet.
206 base::TimeTicks reference_time; 239 base::TimeTicks reference_time;
207 RtpTimeTicks rtp_timestamp; 240 RtpTimeTicks rtp_timestamp;
208 ASSERT_FALSE(rtcp_at_rtp_receiver_.GetLatestLipSyncTimes(&rtp_timestamp, 241 ASSERT_FALSE(rtcp_at_rtp_receiver_.GetLatestLipSyncTimes(&rtp_timestamp,
209 &reference_time)); 242 &reference_time));
210 243
211 // Send a Sender Report to the receiver. 244 // Send a Sender Report to the receiver.
212 const base::TimeTicks reference_time_sent = sender_clock_->NowTicks(); 245 const base::TimeTicks reference_time_sent = sender_clock_->NowTicks();
(...skipping 156 matching lines...) Expand 10 before | Expand all | Expand 10 after
369 // Only 24 bits of event timestamp sent on wire. 402 // Only 24 bits of event timestamp sent on wire.
370 uint32_t event_ts = 403 uint32_t event_ts =
371 (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; 404 (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff;
372 uint32_t log_msg_ts = 405 uint32_t log_msg_ts =
373 (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; 406 (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff;
374 EXPECT_EQ(log_msg_ts, event_ts); 407 EXPECT_EQ(log_msg_ts, event_ts);
375 } 408 }
376 409
377 } // namespace cast 410 } // namespace cast
378 } // namespace media 411 } // namespace media
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698