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

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: 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 <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
25 namespace { 26 namespace {
26 27
27 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) { 28 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) {
28 media::cast::RtcpTimeData ret; 29 media::cast::RtcpTimeData ret;
29 ret.timestamp = now; 30 ret.timestamp = now;
30 media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction); 31 media::cast::ConvertTimeTicksToNtp(now, &ret.ntp_seconds, &ret.ntp_fraction);
31 return ret; 32 return ret;
32 } 33 }
33 34
34 } // namespace
35
36 using testing::_; 35 using testing::_;
37 36
38 static const uint32_t kSenderSsrc = 0x10203; 37 static const uint32_t kSenderSsrc = 0x10203;
39 static const uint32_t kReceiverSsrc = 0x40506; 38 static const uint32_t kReceiverSsrc = 0x40506;
40 static const int kInitialReceiverClockOffsetSeconds = -5; 39 static const int kInitialReceiverClockOffsetSeconds = -5;
41 static const uint16_t kTargetDelayMs = 100; 40 static const uint16_t kTargetDelayMs = 100;
42 41
43 class FakeRtcpTransport : public PacedPacketSender { 42 class FakeRtcpTransport : public PacedPacketSender {
44 public: 43 public:
45 explicit FakeRtcpTransport(base::SimpleTestTickClock* clock) 44 explicit FakeRtcpTransport(base::SimpleTestTickClock* clock)
(...skipping 22 matching lines...) Expand all
68 void CancelSendingPacket(const PacketKey& packet_key) final {} 67 void CancelSendingPacket(const PacketKey& packet_key) final {}
69 68
70 private: 69 private:
71 base::SimpleTestTickClock* const clock_; 70 base::SimpleTestTickClock* const clock_;
72 base::TimeDelta packet_delay_; 71 base::TimeDelta packet_delay_;
73 RtcpSession* rtcp_session_; // RTCP destination. 72 RtcpSession* rtcp_session_; // RTCP destination.
74 73
75 DISALLOW_COPY_AND_ASSIGN(FakeRtcpTransport); 74 DISALLOW_COPY_AND_ASSIGN(FakeRtcpTransport);
76 }; 75 };
77 76
77 } // namespace
78
78 class RtcpTest : public ::testing::Test { 79 class RtcpTest : public ::testing::Test {
79 protected: 80 protected:
81 class RtcpObserver : public SenderRtcpObserver {
miu 2016/04/25 23:23:53 Seems like you only need this class because Sender
xjz 2016/04/29 19:15:49 Done.
82 public:
83 explicit RtcpObserver(RtcpTest* rtcp_test) : rtcp_test_(rtcp_test) {}
84
85 void OnCastMessageReceived(const RtcpCastMessage& cast_message) override;
86 void OnRttReceived(base::TimeDelta round_trip_time) override;
87 void OnReceiverLogReceived(const RtcpReceiverLogMessage& log) override;
88 void OnPliReceived() override;
89
90 private:
91 RtcpTest* const rtcp_test_;
92
93 DISALLOW_COPY_AND_ASSIGN(RtcpObserver);
94 };
95
80 RtcpTest() 96 RtcpTest()
81 : sender_clock_(new base::SimpleTestTickClock()), 97 : sender_clock_(new base::SimpleTestTickClock()),
82 receiver_clock_(new test::SkewedTickClock(sender_clock_.get())), 98 receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
83 rtp_sender_pacer_(sender_clock_.get()), 99 rtp_sender_pacer_(sender_clock_.get()),
84 rtp_receiver_pacer_(sender_clock_.get()), 100 rtp_receiver_pacer_(sender_clock_.get()),
85 rtcp_at_rtp_sender_( 101 rtcp_at_rtp_sender_(base::WrapUnique(new RtcpObserver(this)),
86 base::Bind(&RtcpTest::OnReceivedCastFeedback, 102 sender_clock_.get(),
87 base::Unretained(this)), 103 &rtp_sender_pacer_,
88 base::Bind(&RtcpTest::OnMeasuredRoundTripTime, 104 kSenderSsrc,
89 base::Unretained(this)), 105 kReceiverSsrc),
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(), 106 rtcp_at_rtp_receiver_(receiver_clock_.get(),
97 kReceiverSsrc, 107 kReceiverSsrc,
98 kSenderSsrc), 108 kSenderSsrc),
99 received_pli_(false) { 109 received_pli_(false) {
100 sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks()); 110 sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
101 receiver_clock_->SetSkew( 111 receiver_clock_->SetSkew(
102 1.0, // No skew. 112 1.0, // No skew.
103 base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds)); 113 base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds));
104 114
105 rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_); 115 rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_);
(...skipping 22 matching lines...) Expand all
128 RtcpReceiverEventLogMessage event_log; 138 RtcpReceiverEventLogMessage event_log;
129 event_log.type = event_log_msg.type; 139 event_log.type = event_log_msg.type;
130 event_log.event_timestamp = event_log_msg.event_timestamp; 140 event_log.event_timestamp = event_log_msg.event_timestamp;
131 event_log.delay_delta = event_log_msg.delay_delta; 141 event_log.delay_delta = event_log_msg.delay_delta;
132 event_log.packet_id = event_log_msg.packet_id; 142 event_log.packet_id = event_log_msg.packet_id;
133 last_logs_.back().event_log_messages_.push_back(event_log); 143 last_logs_.back().event_log_messages_.push_back(event_log);
134 } 144 }
135 } 145 }
136 } 146 }
137 147
148 void OnReceivedPli() { received_pli_ = true; }
149
138 PacketRef BuildRtcpPacketFromRtpReceiver( 150 PacketRef BuildRtcpPacketFromRtpReceiver(
139 const RtcpTimeData& time_data, 151 const RtcpTimeData& time_data,
140 const RtcpCastMessage* cast_message, 152 const RtcpCastMessage* cast_message,
141 const RtcpPliMessage* pli_message, 153 const RtcpPliMessage* pli_message,
142 base::TimeDelta target_delay, 154 base::TimeDelta target_delay,
143 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, 155 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events,
144 const RtpReceiverStatistics* rtp_receiver_statistics) { 156 const RtpReceiverStatistics* rtp_receiver_statistics) {
145 RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc()); 157 RtcpBuilder builder(rtcp_at_rtp_receiver_.local_ssrc());
146 builder.Start(); 158 builder.Start();
147 RtcpReceiverReferenceTimeReport rrtr; 159 RtcpReceiverReferenceTimeReport rrtr;
(...skipping 27 matching lines...) Expand all
175 } 187 }
176 if (cast_message) 188 if (cast_message)
177 builder.AddCast(*cast_message, target_delay); 189 builder.AddCast(*cast_message, target_delay);
178 if (pli_message) 190 if (pli_message)
179 builder.AddPli(*pli_message); 191 builder.AddPli(*pli_message);
180 if (rtcp_events) 192 if (rtcp_events)
181 builder.AddReceiverLog(*rtcp_events); 193 builder.AddReceiverLog(*rtcp_events);
182 return builder.Finish(); 194 return builder.Finish();
183 } 195 }
184 196
185 void OnReceivedPli() { received_pli_ = true; } 197 std::unique_ptr<base::SimpleTestTickClock> sender_clock_;
186 198 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_; 199 FakeRtcpTransport rtp_sender_pacer_;
190 FakeRtcpTransport rtp_receiver_pacer_; 200 FakeRtcpTransport rtp_receiver_pacer_;
191 SenderRtcpSession rtcp_at_rtp_sender_; 201 SenderRtcpSession rtcp_at_rtp_sender_;
192 ReceiverRtcpSession rtcp_at_rtp_receiver_; 202 ReceiverRtcpSession rtcp_at_rtp_receiver_;
193 203
194 base::TimeDelta current_round_trip_time_; 204 base::TimeDelta current_round_trip_time_;
195 RtcpCastMessage last_cast_message_; 205 RtcpCastMessage last_cast_message_;
196 RtcpReceiverLogMessage last_logs_; 206 RtcpReceiverLogMessage last_logs_;
197 bool received_pli_; 207 bool received_pli_;
198 208
199 private: 209 private:
200 DISALLOW_COPY_AND_ASSIGN(RtcpTest); 210 DISALLOW_COPY_AND_ASSIGN(RtcpTest);
201 }; 211 };
202 212
213 void RtcpTest::RtcpObserver::OnCastMessageReceived(
miu 2016/04/25 23:23:53 Feel free to inline these methods in the class def
xjz 2016/04/29 19:15:49 Done.
214 const RtcpCastMessage& cast_message) {
215 rtcp_test_->OnReceivedCastFeedback(cast_message);
216 }
217
218 void RtcpTest::RtcpObserver::OnRttReceived(base::TimeDelta round_trip_time) {
219 rtcp_test_->OnMeasuredRoundTripTime(round_trip_time);
220 }
221
222 void RtcpTest::RtcpObserver::OnReceiverLogReceived(
223 const RtcpReceiverLogMessage& log) {
224 rtcp_test_->OnReceivedLogs(log);
225 }
226
227 void RtcpTest::RtcpObserver::OnPliReceived() {
228 rtcp_test_->OnReceivedPli();
229 }
230
203 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) { 231 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) {
204 // Initially, expect no lip-sync info receiver-side without having first 232 // Initially, expect no lip-sync info receiver-side without having first
205 // received a RTCP packet. 233 // received a RTCP packet.
206 base::TimeTicks reference_time; 234 base::TimeTicks reference_time;
207 RtpTimeTicks rtp_timestamp; 235 RtpTimeTicks rtp_timestamp;
208 ASSERT_FALSE(rtcp_at_rtp_receiver_.GetLatestLipSyncTimes(&rtp_timestamp, 236 ASSERT_FALSE(rtcp_at_rtp_receiver_.GetLatestLipSyncTimes(&rtp_timestamp,
209 &reference_time)); 237 &reference_time));
210 238
211 // Send a Sender Report to the receiver. 239 // Send a Sender Report to the receiver.
212 const base::TimeTicks reference_time_sent = sender_clock_->NowTicks(); 240 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. 397 // Only 24 bits of event timestamp sent on wire.
370 uint32_t event_ts = 398 uint32_t event_ts =
371 (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; 399 (event.timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff;
372 uint32_t log_msg_ts = 400 uint32_t log_msg_ts =
373 (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff; 401 (log_msg.event_timestamp - base::TimeTicks()).InMilliseconds() & 0xffffff;
374 EXPECT_EQ(log_msg_ts, event_ts); 402 EXPECT_EQ(log_msg_ts, event_ts);
375 } 403 }
376 404
377 } // namespace cast 405 } // namespace cast
378 } // namespace media 406 } // namespace media
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698