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

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

Issue 387933005: Cast: Refactor RTCP handling (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: fix test Created 6 years, 5 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 | Annotate | Revision Log
« no previous file with comments | « media/cast/net/rtcp/rtcp_receiver.cc ('k') | media/cast/net/rtcp/rtcp_sender.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 "base/memory/scoped_ptr.h" 5 #include "base/memory/scoped_ptr.h"
6 #include "base/test/simple_test_tick_clock.h" 6 #include "base/test/simple_test_tick_clock.h"
7 #include "media/cast/cast_environment.h" 7 #include "media/cast/cast_environment.h"
8 #include "media/cast/net/cast_transport_defines.h" 8 #include "media/cast/net/cast_transport_defines.h"
9 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h" 9 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h"
10 #include "media/cast/net/rtcp/mock_rtcp_sender_feedback.h"
11 #include "media/cast/net/rtcp/rtcp_receiver.h" 10 #include "media/cast/net/rtcp/rtcp_receiver.h"
12 #include "media/cast/net/rtcp/rtcp_utility.h" 11 #include "media/cast/net/rtcp/rtcp_utility.h"
13 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h" 12 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
14 #include "media/cast/test/fake_single_thread_task_runner.h" 13 #include "media/cast/test/fake_single_thread_task_runner.h"
15 #include "testing/gmock/include/gmock/gmock.h" 14 #include "testing/gmock/include/gmock/gmock.h"
16 15
17 namespace media { 16 namespace media {
18 namespace cast { 17 namespace cast {
19 18
20 using testing::_; 19 using testing::_;
21 20
22 static const uint32 kSenderSsrc = 0x10203; 21 static const uint32 kSenderSsrc = 0x10203;
23 static const uint32 kSourceSsrc = 0x40506; 22 static const uint32 kSourceSsrc = 0x40506;
24 static const uint32 kUnknownSsrc = 0xDEAD; 23 static const uint32 kUnknownSsrc = 0xDEAD;
25 static const base::TimeDelta kTargetDelay = 24 static const base::TimeDelta kTargetDelay =
26 base::TimeDelta::FromMilliseconds(100); 25 base::TimeDelta::FromMilliseconds(100);
27 static const std::string kCName("test@10.1.1.1"); 26 static const std::string kCName("test@10.1.1.1");
28 27
29 namespace { 28 namespace {
30 class SenderFeedbackCastVerification : public RtcpSenderFeedback { 29
30 class RtcpMessageVerification : public MockRtcpReceiverFeedback {
31 public: 31 public:
32 SenderFeedbackCastVerification() : called_(false) {} 32 RtcpMessageVerification()
33
34 virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_feedback)
35 OVERRIDE {
36 EXPECT_EQ(cast_feedback.media_ssrc_, kSenderSsrc);
37 EXPECT_EQ(cast_feedback.ack_frame_id_, kAckFrameId);
38
39 MissingFramesAndPacketsMap::const_iterator frame_it =
40 cast_feedback.missing_frames_and_packets_.begin();
41
42 EXPECT_TRUE(frame_it != cast_feedback.missing_frames_and_packets_.end());
43 EXPECT_EQ(kLostFrameId, frame_it->first);
44 EXPECT_EQ(frame_it->second.size(), 1UL);
45 EXPECT_EQ(*frame_it->second.begin(), kRtcpCastAllPacketsLost);
46 ++frame_it;
47 EXPECT_TRUE(frame_it != cast_feedback.missing_frames_and_packets_.end());
48 EXPECT_EQ(kFrameIdWithLostPackets, frame_it->first);
49 EXPECT_EQ(3UL, frame_it->second.size());
50 PacketIdSet::const_iterator packet_it = frame_it->second.begin();
51 EXPECT_EQ(kLostPacketId1, *packet_it);
52 ++packet_it;
53 EXPECT_EQ(kLostPacketId2, *packet_it);
54 ++packet_it;
55 EXPECT_EQ(kLostPacketId3, *packet_it);
56 ++frame_it;
57 EXPECT_EQ(frame_it, cast_feedback.missing_frames_and_packets_.end());
58 called_ = true;
59 }
60
61 bool called() const { return called_; }
62
63 private:
64 bool called_;
65
66 DISALLOW_COPY_AND_ASSIGN(SenderFeedbackCastVerification);
67 };
68
69 class RtcpReceiverCastLogVerification : public RtcpReceiverFeedback {
70 public:
71 RtcpReceiverCastLogVerification()
72 : called_on_received_sender_log_(false), 33 : called_on_received_sender_log_(false),
73 called_on_received_receiver_log_(false) {} 34 called_on_received_receiver_log_(false),
74 35 called_on_received_cast_message_(false) {}
75 virtual void OnReceivedSenderReport(
76 const RtcpSenderInfo& remote_sender_info) OVERRIDE{};
77
78 virtual void OnReceiverReferenceTimeReport(
79 const RtcpReceiverReferenceTimeReport& remote_time_report) OVERRIDE{};
80
81 virtual void OnReceivedSendReportRequest() OVERRIDE{};
82 36
83 virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log) 37 virtual void OnReceivedReceiverLog(const RtcpReceiverLogMessage& receiver_log)
84 OVERRIDE { 38 OVERRIDE {
85 EXPECT_EQ(expected_receiver_log_.size(), receiver_log.size()); 39 EXPECT_EQ(expected_receiver_log_.size(), receiver_log.size());
86 RtcpReceiverLogMessage::const_iterator expected_it = 40 RtcpReceiverLogMessage::const_iterator expected_it =
87 expected_receiver_log_.begin(); 41 expected_receiver_log_.begin();
88 RtcpReceiverLogMessage::const_iterator incoming_it = receiver_log.begin(); 42 RtcpReceiverLogMessage::const_iterator incoming_it = receiver_log.begin();
89 for (; incoming_it != receiver_log.end(); ++incoming_it) { 43 for (; incoming_it != receiver_log.end(); ++incoming_it) {
90 EXPECT_EQ(expected_it->rtp_timestamp_, incoming_it->rtp_timestamp_); 44 EXPECT_EQ(expected_it->rtp_timestamp_, incoming_it->rtp_timestamp_);
91 EXPECT_EQ(expected_it->event_log_messages_.size(), 45 EXPECT_EQ(expected_it->event_log_messages_.size(),
(...skipping 14 matching lines...) Expand all
106 EXPECT_EQ(event_expected_it->delay_delta, 60 EXPECT_EQ(event_expected_it->delay_delta,
107 event_incoming_it->delay_delta); 61 event_incoming_it->delay_delta);
108 } 62 }
109 } 63 }
110 expected_receiver_log_.pop_front(); 64 expected_receiver_log_.pop_front();
111 expected_it = expected_receiver_log_.begin(); 65 expected_it = expected_receiver_log_.begin();
112 } 66 }
113 called_on_received_receiver_log_ = true; 67 called_on_received_receiver_log_ = true;
114 } 68 }
115 69
116 bool OnReceivedReceiverLogCalled() { 70 virtual void OnReceivedCastFeedback(const RtcpCastMessage& cast_message)
71 OVERRIDE {
72 EXPECT_EQ(cast_message.media_ssrc, kSenderSsrc);
73 EXPECT_EQ(cast_message.ack_frame_id, kAckFrameId);
74
75 MissingFramesAndPacketsMap::const_iterator frame_it =
76 cast_message.missing_frames_and_packets.begin();
77
78 EXPECT_TRUE(frame_it != cast_message.missing_frames_and_packets.end());
79 EXPECT_EQ(kLostFrameId, frame_it->first);
80 EXPECT_EQ(frame_it->second.size(), 1UL);
81 EXPECT_EQ(*frame_it->second.begin(), kRtcpCastAllPacketsLost);
82 ++frame_it;
83 EXPECT_TRUE(frame_it != cast_message.missing_frames_and_packets.end());
84 EXPECT_EQ(kFrameIdWithLostPackets, frame_it->first);
85 EXPECT_EQ(3UL, frame_it->second.size());
86 PacketIdSet::const_iterator packet_it = frame_it->second.begin();
87 EXPECT_EQ(kLostPacketId1, *packet_it);
88 ++packet_it;
89 EXPECT_EQ(kLostPacketId2, *packet_it);
90 ++packet_it;
91 EXPECT_EQ(kLostPacketId3, *packet_it);
92 ++frame_it;
93 EXPECT_EQ(frame_it, cast_message.missing_frames_and_packets.end());
94 called_on_received_cast_message_ = true;
95 }
96
97 bool OnReceivedReceiverLogCalled() const {
117 return called_on_received_receiver_log_ && expected_receiver_log_.empty(); 98 return called_on_received_receiver_log_ && expected_receiver_log_.empty();
118 } 99 }
119 100
101 bool OnReceivedCastFeedbackCalled() const {
102 return called_on_received_cast_message_;
103 }
104
120 void SetExpectedReceiverLog(const RtcpReceiverLogMessage& receiver_log) { 105 void SetExpectedReceiverLog(const RtcpReceiverLogMessage& receiver_log) {
121 expected_receiver_log_ = receiver_log; 106 expected_receiver_log_ = receiver_log;
122 } 107 }
123 108
124 private: 109 private:
125 RtcpReceiverLogMessage expected_receiver_log_; 110 RtcpReceiverLogMessage expected_receiver_log_;
126 bool called_on_received_sender_log_; 111 bool called_on_received_sender_log_;
127 bool called_on_received_receiver_log_; 112 bool called_on_received_receiver_log_;
113 bool called_on_received_cast_message_;
128 114
129 DISALLOW_COPY_AND_ASSIGN(RtcpReceiverCastLogVerification); 115 DISALLOW_COPY_AND_ASSIGN(RtcpMessageVerification);
130 }; 116 };
131 117
132 } // namespace 118 } // namespace
133 119
134 class RtcpReceiverTest : public ::testing::Test { 120 class RtcpReceiverTest : public ::testing::Test {
135 protected: 121 protected:
136 RtcpReceiverTest() 122 RtcpReceiverTest()
137 : testing_clock_(new base::SimpleTestTickClock()), 123 : testing_clock_(new base::SimpleTestTickClock()),
138 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), 124 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
139 cast_environment_(new CastEnvironment( 125 rtcp_receiver_(new RtcpReceiver(&mock_receiver_feedback_,
140 scoped_ptr<base::TickClock>(testing_clock_).Pass(),
141 task_runner_,
142 task_runner_,
143 task_runner_)),
144 rtcp_receiver_(new RtcpReceiver(cast_environment_,
145 &mock_sender_feedback_,
146 &mock_receiver_feedback_,
147 &mock_rtt_feedback_,
148 kSourceSsrc)) { 126 kSourceSsrc)) {
149 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0); 127 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0);
150 EXPECT_CALL(mock_receiver_feedback_, OnReceiverReferenceTimeReport(_)) 128 EXPECT_CALL(mock_receiver_feedback_, OnReceiverReferenceTimeReport(_))
151 .Times(0); 129 .Times(0);
152 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSendReportRequest()) 130 EXPECT_CALL(mock_receiver_feedback_, OnReceivedCastFeedback(_)).Times(0);
153 .Times(0); 131 EXPECT_CALL(mock_receiver_feedback_, OnReceivedDelaySinceLastReport(_, _))
154 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0);
155 EXPECT_CALL(mock_rtt_feedback_, OnReceivedDelaySinceLastReport(_, _, _))
156 .Times(0); 132 .Times(0);
157 133
158 expected_sender_info_.ntp_seconds = kNtpHigh; 134 expected_sender_info_.ntp_seconds = kNtpHigh;
159 expected_sender_info_.ntp_fraction = kNtpLow; 135 expected_sender_info_.ntp_fraction = kNtpLow;
160 expected_sender_info_.rtp_timestamp = kRtpTimestamp; 136 expected_sender_info_.rtp_timestamp = kRtpTimestamp;
161 expected_sender_info_.send_packet_count = kSendPacketCount; 137 expected_sender_info_.send_packet_count = kSendPacketCount;
162 expected_sender_info_.send_octet_count = kSendOctetCount; 138 expected_sender_info_.send_octet_count = kSendOctetCount;
163 139
164 expected_report_block_.remote_ssrc = kSenderSsrc; 140 expected_report_block_.remote_ssrc = kSenderSsrc;
165 expected_report_block_.media_ssrc = kSourceSsrc; 141 expected_report_block_.media_ssrc = kSourceSsrc;
(...skipping 11 matching lines...) Expand all
177 virtual ~RtcpReceiverTest() {} 153 virtual ~RtcpReceiverTest() {}
178 154
179 // Injects an RTCP packet into the receiver. 155 // Injects an RTCP packet into the receiver.
180 void InjectRtcpPacket(const uint8* packet, uint16 length) { 156 void InjectRtcpPacket(const uint8* packet, uint16 length) {
181 RtcpParser rtcp_parser(packet, length); 157 RtcpParser rtcp_parser(packet, length);
182 rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser); 158 rtcp_receiver_->IncomingRtcpPacket(&rtcp_parser);
183 } 159 }
184 160
185 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. 161 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment.
186 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; 162 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
187 scoped_refptr<CastEnvironment> cast_environment_;
188 MockRtcpReceiverFeedback mock_receiver_feedback_; 163 MockRtcpReceiverFeedback mock_receiver_feedback_;
189 MockRtcpRttFeedback mock_rtt_feedback_;
190 MockRtcpSenderFeedback mock_sender_feedback_;
191 scoped_ptr<RtcpReceiver> rtcp_receiver_; 164 scoped_ptr<RtcpReceiver> rtcp_receiver_;
192 RtcpSenderInfo expected_sender_info_; 165 RtcpSenderInfo expected_sender_info_;
193 RtcpReportBlock expected_report_block_; 166 RtcpReportBlock expected_report_block_;
194 RtcpReceiverReferenceTimeReport expected_receiver_reference_report_; 167 RtcpReceiverReferenceTimeReport expected_receiver_reference_report_;
195 168
196 DISALLOW_COPY_AND_ASSIGN(RtcpReceiverTest); 169 DISALLOW_COPY_AND_ASSIGN(RtcpReceiverTest);
197 }; 170 };
198 171
199 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { 172 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) {
200 const uint8 bad_packet[] = {0, 0, 0, 0}; 173 const uint8 bad_packet[] = {0, 0, 0, 0};
(...skipping 18 matching lines...) Expand all
219 192
220 TEST_F(RtcpReceiverTest, InjectReceiveReportPacket) { 193 TEST_F(RtcpReceiverTest, InjectReceiveReportPacket) {
221 TestRtcpPacketBuilder p1; 194 TestRtcpPacketBuilder p1;
222 p1.AddRr(kSenderSsrc, 1); 195 p1.AddRr(kSenderSsrc, 1);
223 p1.AddRb(kUnknownSsrc); 196 p1.AddRb(kUnknownSsrc);
224 197
225 // Expected to be ignored since the source ssrc does not match our 198 // Expected to be ignored since the source ssrc does not match our
226 // local ssrc. 199 // local ssrc.
227 InjectRtcpPacket(p1.Data(), p1.Length()); 200 InjectRtcpPacket(p1.Data(), p1.Length());
228 201
229 EXPECT_CALL(mock_rtt_feedback_, 202 EXPECT_CALL(mock_receiver_feedback_,
230 OnReceivedDelaySinceLastReport( 203 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
231 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
232 204
233 TestRtcpPacketBuilder p2; 205 TestRtcpPacketBuilder p2;
234 p2.AddRr(kSenderSsrc, 1); 206 p2.AddRr(kSenderSsrc, 1);
235 p2.AddRb(kSourceSsrc); 207 p2.AddRb(kSourceSsrc);
236 208
237 // Expected to be pass through since the sender ssrc match our local ssrc. 209 // Expected to be pass through since the sender ssrc match our local ssrc.
238 InjectRtcpPacket(p2.Data(), p2.Length()); 210 InjectRtcpPacket(p2.Data(), p2.Length());
239 } 211 }
240 212
241 TEST_F(RtcpReceiverTest, InjectSenderReportWithReportBlockPacket) { 213 TEST_F(RtcpReceiverTest, InjectSenderReportWithReportBlockPacket) {
(...skipping 11 matching lines...) Expand all
253 OnReceivedSenderReport(expected_sender_info_)).Times(1); 225 OnReceivedSenderReport(expected_sender_info_)).Times(1);
254 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 226 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
255 227
256 // Sender report expected to be pass through since the sender ssrc match our 228 // Sender report expected to be pass through since the sender ssrc match our
257 // remote ssrc. 229 // remote ssrc.
258 // Report block expected to be ignored since the source ssrc does not match 230 // Report block expected to be ignored since the source ssrc does not match
259 // our local ssrc. 231 // our local ssrc.
260 InjectRtcpPacket(p1.Data(), p1.Length()); 232 InjectRtcpPacket(p1.Data(), p1.Length());
261 233
262 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0); 234 EXPECT_CALL(mock_receiver_feedback_, OnReceivedSenderReport(_)).Times(0);
263 EXPECT_CALL(mock_rtt_feedback_, 235 EXPECT_CALL(mock_receiver_feedback_,
264 OnReceivedDelaySinceLastReport( 236 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
265 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
266 237
267 rtcp_receiver_->SetRemoteSSRC(0); 238 rtcp_receiver_->SetRemoteSSRC(0);
268 239
269 TestRtcpPacketBuilder p2; 240 TestRtcpPacketBuilder p2;
270 p2.AddSr(kSenderSsrc, 1); 241 p2.AddSr(kSenderSsrc, 1);
271 p2.AddRb(kSourceSsrc); 242 p2.AddRb(kSourceSsrc);
272 243
273 // Sender report expected to be ignored since the sender ssrc does not match 244 // Sender report expected to be ignored since the sender ssrc does not match
274 // our remote ssrc. 245 // our remote ssrc.
275 // Receiver report expected to be pass through since the sender ssrc match 246 // Receiver report expected to be pass through since the sender ssrc match
276 // our local ssrc. 247 // our local ssrc.
277 InjectRtcpPacket(p2.Data(), p2.Length()); 248 InjectRtcpPacket(p2.Data(), p2.Length());
278 249
279 EXPECT_CALL(mock_receiver_feedback_, 250 EXPECT_CALL(mock_receiver_feedback_,
280 OnReceivedSenderReport(expected_sender_info_)).Times(1); 251 OnReceivedSenderReport(expected_sender_info_)).Times(1);
281 EXPECT_CALL(mock_rtt_feedback_, 252 EXPECT_CALL(mock_receiver_feedback_,
282 OnReceivedDelaySinceLastReport( 253 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
283 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
284 254
285 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 255 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
286 256
287 // Sender report expected to be pass through since the sender ssrc match our 257 // Sender report expected to be pass through since the sender ssrc match our
288 // remote ssrc. 258 // remote ssrc.
289 // Receiver report expected to be pass through since the sender ssrc match 259 // Receiver report expected to be pass through since the sender ssrc match
290 // our local ssrc. 260 // our local ssrc.
291 InjectRtcpPacket(p2.Data(), p2.Length()); 261 InjectRtcpPacket(p2.Data(), p2.Length());
292 } 262 }
293 263
294 TEST_F(RtcpReceiverTest, InjectSenderReportPacketWithDlrr) { 264 TEST_F(RtcpReceiverTest, InjectSenderReportPacketWithDlrr) {
295 TestRtcpPacketBuilder p; 265 TestRtcpPacketBuilder p;
296 p.AddSr(kSenderSsrc, 0); 266 p.AddSr(kSenderSsrc, 0);
297 p.AddXrHeader(kSenderSsrc); 267 p.AddXrHeader(kSenderSsrc);
298 p.AddXrUnknownBlock(); 268 p.AddXrUnknownBlock();
299 p.AddXrExtendedDlrrBlock(kSenderSsrc); 269 p.AddXrExtendedDlrrBlock(kSenderSsrc);
300 p.AddXrUnknownBlock(); 270 p.AddXrUnknownBlock();
301 p.AddSdesCname(kSenderSsrc, kCName); 271 p.AddSdesCname(kSenderSsrc, kCName);
302 272
303 // Expected to be ignored since the source ssrc does not match our 273 // Expected to be ignored since the source ssrc does not match our
304 // local ssrc. 274 // local ssrc.
305 InjectRtcpPacket(p.Data(), p.Length()); 275 InjectRtcpPacket(p.Data(), p.Length());
306 276
307 EXPECT_CALL(mock_receiver_feedback_, 277 EXPECT_CALL(mock_receiver_feedback_,
308 OnReceivedSenderReport(expected_sender_info_)).Times(1); 278 OnReceivedSenderReport(expected_sender_info_)).Times(1);
309 EXPECT_CALL(mock_rtt_feedback_, 279 EXPECT_CALL(mock_receiver_feedback_,
310 OnReceivedDelaySinceLastReport( 280 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
311 kSenderSsrc, kLastSr, kDelayLastSr)).Times(1);
312 281
313 // Enable receiving sender report. 282 // Enable receiving sender report.
314 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 283 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
315 284
316 // Expected to be pass through since the sender ssrc match our local ssrc. 285 // Expected to be pass through since the sender ssrc match our local ssrc.
317 InjectRtcpPacket(p.Data(), p.Length()); 286 InjectRtcpPacket(p.Data(), p.Length());
318 } 287 }
319 288
320 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithRrtr) { 289 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithRrtr) {
321 TestRtcpPacketBuilder p1; 290 TestRtcpPacketBuilder p1;
322 p1.AddRr(kSenderSsrc, 1); 291 p1.AddRr(kSenderSsrc, 1);
323 p1.AddRb(kUnknownSsrc); 292 p1.AddRb(kUnknownSsrc);
324 p1.AddXrHeader(kSenderSsrc); 293 p1.AddXrHeader(kSenderSsrc);
325 p1.AddXrRrtrBlock(); 294 p1.AddXrRrtrBlock();
326 295
327 // Expected to be ignored since the source ssrc does not match our 296 // Expected to be ignored since the source ssrc does not match our
328 // local ssrc. 297 // local ssrc.
329 InjectRtcpPacket(p1.Data(), p1.Length()); 298 InjectRtcpPacket(p1.Data(), p1.Length());
330 299
331 EXPECT_CALL(mock_rtt_feedback_, 300 EXPECT_CALL(mock_receiver_feedback_,
332 OnReceivedDelaySinceLastReport( 301 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
333 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
334 EXPECT_CALL(mock_receiver_feedback_, 302 EXPECT_CALL(mock_receiver_feedback_,
335 OnReceiverReferenceTimeReport( 303 OnReceiverReferenceTimeReport(
336 expected_receiver_reference_report_)).Times(1); 304 expected_receiver_reference_report_)).Times(1);
337 305
338 // Enable receiving reference time report. 306 // Enable receiving reference time report.
339 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 307 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
340 308
341 TestRtcpPacketBuilder p2; 309 TestRtcpPacketBuilder p2;
342 p2.AddRr(kSenderSsrc, 1); 310 p2.AddRr(kSenderSsrc, 1);
343 p2.AddRb(kSourceSsrc); 311 p2.AddRb(kSourceSsrc);
344 p2.AddXrHeader(kSenderSsrc); 312 p2.AddXrHeader(kSenderSsrc);
345 p2.AddXrRrtrBlock(); 313 p2.AddXrRrtrBlock();
346 314
347 // Expected to be pass through since the sender ssrc match our local ssrc. 315 // Expected to be pass through since the sender ssrc match our local ssrc.
348 InjectRtcpPacket(p2.Data(), p2.Length()); 316 InjectRtcpPacket(p2.Data(), p2.Length());
349 } 317 }
350 318
351 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithIntraFrameRequest) { 319 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithIntraFrameRequest) {
352 TestRtcpPacketBuilder p1; 320 TestRtcpPacketBuilder p1;
353 p1.AddRr(kSenderSsrc, 1); 321 p1.AddRr(kSenderSsrc, 1);
354 p1.AddRb(kUnknownSsrc); 322 p1.AddRb(kUnknownSsrc);
355 p1.AddPli(kSenderSsrc, kUnknownSsrc); 323 p1.AddPli(kSenderSsrc, kUnknownSsrc);
356 324
357 // Expected to be ignored since the source ssrc does not match our 325 // Expected to be ignored since the source ssrc does not match our
358 // local ssrc. 326 // local ssrc.
359 InjectRtcpPacket(p1.Data(), p1.Length()); 327 InjectRtcpPacket(p1.Data(), p1.Length());
360 328
361 EXPECT_CALL(mock_rtt_feedback_, 329 EXPECT_CALL(mock_receiver_feedback_,
362 OnReceivedDelaySinceLastReport( 330 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
363 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
364 331
365 TestRtcpPacketBuilder p2; 332 TestRtcpPacketBuilder p2;
366 p2.AddRr(kSenderSsrc, 1); 333 p2.AddRr(kSenderSsrc, 1);
367 p2.AddRb(kSourceSsrc); 334 p2.AddRb(kSourceSsrc);
368 p2.AddPli(kSenderSsrc, kSourceSsrc); 335 p2.AddPli(kSenderSsrc, kSourceSsrc);
369 336
370 // Expected to be pass through since the sender ssrc match our local ssrc. 337 // Expected to be pass through since the sender ssrc match our local ssrc.
371 InjectRtcpPacket(p2.Data(), p2.Length()); 338 InjectRtcpPacket(p2.Data(), p2.Length());
372 } 339 }
373 340
374 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastFeedback) { 341 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastFeedback) {
375 TestRtcpPacketBuilder p1; 342 TestRtcpPacketBuilder p1;
376 p1.AddRr(kSenderSsrc, 1); 343 p1.AddRr(kSenderSsrc, 1);
377 p1.AddRb(kUnknownSsrc); 344 p1.AddRb(kUnknownSsrc);
378 p1.AddCast(kSenderSsrc, kUnknownSsrc, kTargetDelay); 345 p1.AddCast(kSenderSsrc, kUnknownSsrc, kTargetDelay);
379 346
380 // Expected to be ignored since the source ssrc does not match our 347 // Expected to be ignored since the source ssrc does not match our
381 // local ssrc. 348 // local ssrc.
382 InjectRtcpPacket(p1.Data(), p1.Length()); 349 InjectRtcpPacket(p1.Data(), p1.Length());
383 350
384 EXPECT_CALL(mock_rtt_feedback_, 351 EXPECT_CALL(mock_receiver_feedback_,
385 OnReceivedDelaySinceLastReport( 352 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
386 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1); 353 EXPECT_CALL(mock_receiver_feedback_, OnReceivedCastFeedback(_)).Times(1);
387 EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(1);
388 354
389 // Enable receiving the cast feedback. 355 // Enable receiving the cast feedback.
390 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); 356 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc);
391 357
392 TestRtcpPacketBuilder p2; 358 TestRtcpPacketBuilder p2;
393 p2.AddRr(kSenderSsrc, 1); 359 p2.AddRr(kSenderSsrc, 1);
394 p2.AddRb(kSourceSsrc); 360 p2.AddRb(kSourceSsrc);
395 p2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay); 361 p2.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
396 362
397 // Expected to be pass through since the sender ssrc match our local ssrc. 363 // Expected to be pass through since the sender ssrc match our local ssrc.
398 InjectRtcpPacket(p2.Data(), p2.Length()); 364 InjectRtcpPacket(p2.Data(), p2.Length());
399 } 365 }
400 366
401 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastVerification) { 367 TEST_F(RtcpReceiverTest, InjectReceiverReportPacketWithCastVerification) {
402 SenderFeedbackCastVerification sender_feedback_cast_verification; 368 RtcpMessageVerification verification;
403 RtcpReceiver rtcp_receiver(cast_environment_, 369 RtcpReceiver rtcp_receiver(&verification, kSourceSsrc);
404 &sender_feedback_cast_verification,
405 &mock_receiver_feedback_,
406 &mock_rtt_feedback_,
407 kSourceSsrc);
408 370
409 EXPECT_CALL(mock_rtt_feedback_, 371 EXPECT_CALL(verification,
410 OnReceivedDelaySinceLastReport( 372 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
411 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
412 373
413 // Enable receiving the cast feedback. 374 // Enable receiving the cast feedback.
414 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); 375 rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
415 376
416 TestRtcpPacketBuilder p; 377 TestRtcpPacketBuilder p;
417 p.AddRr(kSenderSsrc, 1); 378 p.AddRr(kSenderSsrc, 1);
418 p.AddRb(kSourceSsrc); 379 p.AddRb(kSourceSsrc);
419 p.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay); 380 p.AddCast(kSenderSsrc, kSourceSsrc, kTargetDelay);
420 381
421 // Expected to be pass through since the sender ssrc match our local ssrc. 382 // Expected to be pass through since the sender ssrc match our local ssrc.
422 RtcpParser rtcp_parser(p.Data(), p.Length()); 383 RtcpParser rtcp_parser(p.Data(), p.Length());
423 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); 384 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
424 385
425 EXPECT_TRUE(sender_feedback_cast_verification.called()); 386 EXPECT_TRUE(verification.OnReceivedCastFeedbackCalled());
426 } 387 }
427 388
428 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) { 389 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationBase) {
429 static const uint32 kTimeBaseMs = 12345678; 390 static const uint32 kTimeBaseMs = 12345678;
430 static const uint32 kTimeDelayMs = 10; 391 static const uint32 kTimeDelayMs = 10;
431 static const uint32 kDelayDeltaMs = 123; 392 static const uint32 kDelayDeltaMs = 123;
432 base::SimpleTestTickClock testing_clock; 393 base::SimpleTestTickClock testing_clock;
433 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); 394 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
434 395
435 RtcpReceiverCastLogVerification cast_log_verification; 396 RtcpMessageVerification verification;
436 RtcpReceiver rtcp_receiver(cast_environment_, 397 RtcpReceiver rtcp_receiver(&verification,
437 &mock_sender_feedback_,
438 &cast_log_verification,
439 &mock_rtt_feedback_,
440 kSourceSsrc); 398 kSourceSsrc);
441 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); 399 rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
442 rtcp_receiver.SetCastReceiverEventHistorySize(100); 400 rtcp_receiver.SetCastReceiverEventHistorySize(100);
443 401
444 RtcpReceiverLogMessage receiver_log; 402 RtcpReceiverLogMessage receiver_log;
445 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); 403 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
446 RtcpReceiverEventLogMessage event_log; 404 RtcpReceiverEventLogMessage event_log;
447 405
448 event_log.type = FRAME_ACK_SENT; 406 event_log.type = FRAME_ACK_SENT;
449 event_log.event_timestamp = testing_clock.NowTicks(); 407 event_log.event_timestamp = testing_clock.NowTicks();
450 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); 408 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
451 frame_log.event_log_messages_.push_back(event_log); 409 frame_log.event_log_messages_.push_back(event_log);
452 410
453 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); 411 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
454 event_log.type = PACKET_RECEIVED; 412 event_log.type = PACKET_RECEIVED;
455 event_log.event_timestamp = testing_clock.NowTicks(); 413 event_log.event_timestamp = testing_clock.NowTicks();
456 event_log.packet_id = kLostPacketId1; 414 event_log.packet_id = kLostPacketId1;
457 frame_log.event_log_messages_.push_back(event_log); 415 frame_log.event_log_messages_.push_back(event_log);
458 416
459 event_log.type = PACKET_RECEIVED; 417 event_log.type = PACKET_RECEIVED;
460 event_log.event_timestamp = testing_clock.NowTicks(); 418 event_log.event_timestamp = testing_clock.NowTicks();
461 event_log.packet_id = kLostPacketId2; 419 event_log.packet_id = kLostPacketId2;
462 frame_log.event_log_messages_.push_back(event_log); 420 frame_log.event_log_messages_.push_back(event_log);
463 421
464 receiver_log.push_back(frame_log); 422 receiver_log.push_back(frame_log);
465 423
466 cast_log_verification.SetExpectedReceiverLog(receiver_log); 424 verification.SetExpectedReceiverLog(receiver_log);
467 425
468 TestRtcpPacketBuilder p; 426 TestRtcpPacketBuilder p;
469 p.AddRr(kSenderSsrc, 1); 427 p.AddRr(kSenderSsrc, 1);
470 p.AddRb(kSourceSsrc); 428 p.AddRb(kSourceSsrc);
471 p.AddReceiverLog(kSenderSsrc); 429 p.AddReceiverLog(kSenderSsrc);
472 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); 430 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs);
473 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); 431 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
474 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); 432 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
475 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); 433 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs);
476 434
477 // Adds duplicated receiver event. 435 // Adds duplicated receiver event.
478 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs); 436 p.AddReceiverFrameLog(kRtpTimestamp, 3, kTimeBaseMs);
479 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); 437 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
480 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); 438 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs);
481 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs); 439 p.AddReceiverEventLog(kLostPacketId2, PACKET_RECEIVED, kTimeDelayMs);
482 440
483 EXPECT_CALL(mock_rtt_feedback_, 441 EXPECT_CALL(verification,
484 OnReceivedDelaySinceLastReport( 442 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
485 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
486 443
487 RtcpParser rtcp_parser(p.Data(), p.Length()); 444 RtcpParser rtcp_parser(p.Data(), p.Length());
488 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); 445 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
489 446
490 EXPECT_TRUE(cast_log_verification.OnReceivedReceiverLogCalled()); 447 EXPECT_TRUE(verification.OnReceivedReceiverLogCalled());
491 } 448 }
492 449
493 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) { 450 TEST_F(RtcpReceiverTest, InjectReceiverReportWithReceiverLogVerificationMulti) {
494 static const uint32 kTimeBaseMs = 12345678; 451 static const uint32 kTimeBaseMs = 12345678;
495 static const uint32 kTimeDelayMs = 10; 452 static const uint32 kTimeDelayMs = 10;
496 static const uint32 kDelayDeltaMs = 123; 453 static const uint32 kDelayDeltaMs = 123;
497 base::SimpleTestTickClock testing_clock; 454 base::SimpleTestTickClock testing_clock;
498 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); 455 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
499 456
500 RtcpReceiverCastLogVerification cast_log_verification; 457 RtcpMessageVerification verification;
501 RtcpReceiver rtcp_receiver(cast_environment_, 458 RtcpReceiver rtcp_receiver(&verification,
502 &mock_sender_feedback_,
503 &cast_log_verification,
504 &mock_rtt_feedback_,
505 kSourceSsrc); 459 kSourceSsrc);
506 rtcp_receiver.SetRemoteSSRC(kSenderSsrc); 460 rtcp_receiver.SetRemoteSSRC(kSenderSsrc);
507 461
508 RtcpReceiverLogMessage receiver_log; 462 RtcpReceiverLogMessage receiver_log;
509 463
510 for (int j = 0; j < 100; ++j) { 464 for (int j = 0; j < 100; ++j) {
511 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp); 465 RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
512 RtcpReceiverEventLogMessage event_log; 466 RtcpReceiverEventLogMessage event_log;
513 event_log.type = FRAME_ACK_SENT; 467 event_log.type = FRAME_ACK_SENT;
514 event_log.event_timestamp = testing_clock.NowTicks(); 468 event_log.event_timestamp = testing_clock.NowTicks();
515 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs); 469 event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
516 frame_log.event_log_messages_.push_back(event_log); 470 frame_log.event_log_messages_.push_back(event_log);
517 receiver_log.push_back(frame_log); 471 receiver_log.push_back(frame_log);
518 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); 472 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
519 } 473 }
520 474
521 cast_log_verification.SetExpectedReceiverLog(receiver_log); 475 verification.SetExpectedReceiverLog(receiver_log);
522 476
523 TestRtcpPacketBuilder p; 477 TestRtcpPacketBuilder p;
524 p.AddRr(kSenderSsrc, 1); 478 p.AddRr(kSenderSsrc, 1);
525 p.AddRb(kSourceSsrc); 479 p.AddRb(kSourceSsrc);
526 p.AddReceiverLog(kSenderSsrc); 480 p.AddReceiverLog(kSenderSsrc);
527 for (int i = 0; i < 100; ++i) { 481 for (int i = 0; i < 100; ++i) {
528 p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs); 482 p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs + i * kTimeDelayMs);
529 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0); 483 p.AddReceiverEventLog(kDelayDeltaMs, FRAME_ACK_SENT, 0);
530 } 484 }
531 485
532 EXPECT_CALL(mock_rtt_feedback_, 486 EXPECT_CALL(verification,
533 OnReceivedDelaySinceLastReport( 487 OnReceivedDelaySinceLastReport(kLastSr, kDelayLastSr)).Times(1);
534 kSourceSsrc, kLastSr, kDelayLastSr)).Times(1);
535 488
536 RtcpParser rtcp_parser(p.Data(), p.Length()); 489 RtcpParser rtcp_parser(p.Data(), p.Length());
537 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser); 490 rtcp_receiver.IncomingRtcpPacket(&rtcp_parser);
538 491
539 EXPECT_TRUE(cast_log_verification.OnReceivedReceiverLogCalled()); 492 EXPECT_TRUE(verification.OnReceivedReceiverLogCalled());
540 } 493 }
541 494
542 } // namespace cast 495 } // namespace cast
543 } // namespace media 496 } // namespace media
OLDNEW
« no previous file with comments | « media/cast/net/rtcp/rtcp_receiver.cc ('k') | media/cast/net/rtcp/rtcp_sender.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698