media/cast/rtcp/rtcp_unittest.cc

   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/cast_defines.h"
   7 #include "media/cast/cast_environment.h"
   8 #include "media/cast/rtcp/mock_rtcp_receiver_feedback.h"
   9 #include "media/cast/rtcp/mock_rtcp_sender_feedback.h"
  10 #include "media/cast/rtcp/rtcp.h"
  11 #include "media/cast/rtcp/test_rtcp_packet_builder.h"
  12 #include "media/cast/test/fake_task_runner.h"
  13 #include "media/cast/transport/pacing/paced_sender.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15
  16 namespace media {
  17 namespace cast {
  18
  19 using testing::_;
  20
  21 static const uint32 kSenderSsrc = 0x10203;
  22 static const uint32 kReceiverSsrc = 0x40506;
  23 static const std::string kCName("test@10.1.1.1");
  24 static const uint32 kRtcpIntervalMs = 500;
  25 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
  26 static const int64 kAddedDelay = 123;
  27 static const int64 kAddedShortDelay= 100;
  28
  29 class LocalRtcpTransport : public transport::PacedPacketSender {
  30  public:
  31   explicit LocalRtcpTransport(scoped_refptr<CastEnvironment> cast_environment,
  32                               base::SimpleTestTickClock* testing_clock)
  33       : drop_packets_(false),
  34         short_delay_(false),
  35         testing_clock_(testing_clock) {}
  36
  37   void SetRtcpReceiver(Rtcp* rtcp) { rtcp_ = rtcp; }
  38
  39   void SetShortDelay() { short_delay_ = true; }
  40
  41   void SetDropPackets(bool drop_packets) { drop_packets_ = drop_packets; }
  42
  43
  44   virtual bool SendRtcpPacket(const std::vector<uint8>& packet) OVERRIDE {
  45     if (short_delay_) {
  46       testing_clock_->Advance(
  47           base::TimeDelta::FromMilliseconds(kAddedShortDelay));
  48     } else {
  49       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay));
  50     }
  51     if (drop_packets_) return true;
  52
  53     rtcp_->IncomingRtcpPacket(&(packet[0]), packet.size());
  54     return true;
  55   }
  56
  57   virtual bool SendPackets(const PacketList& packets) OVERRIDE {
  58     return false;
  59   }
  60
  61   virtual bool ResendPackets(const PacketList& packets) OVERRIDE {
  62     return false;
  63   }
  64
  65  private:
  66   bool drop_packets_;
  67   bool short_delay_;
  68   Rtcp* rtcp_;
  69   base::SimpleTestTickClock* testing_clock_;
  70   scoped_refptr<CastEnvironment> cast_environment_;
  71 };
  72
  73 class RtcpPeer : public Rtcp {
  74  public:
  75   RtcpPeer(scoped_refptr<CastEnvironment> cast_environment,
  76            RtcpSenderFeedback* sender_feedback,
  77            transport::PacedPacketSender* const paced_packet_sender,
  78            RtpSenderStatistics* rtp_sender_statistics,
  79            RtpReceiverStatistics* rtp_receiver_statistics,
  80            RtcpMode rtcp_mode,
  81            const base::TimeDelta& rtcp_interval,
  82            uint32 local_ssrc,
  83            uint32 remote_ssrc,
  84            const std::string& c_name)
  85       : Rtcp(cast_environment,
  86              sender_feedback,
  87              paced_packet_sender,
  88              rtp_sender_statistics,
  89              rtp_receiver_statistics,
  90              rtcp_mode,
  91              rtcp_interval,
  92              local_ssrc,
  93              remote_ssrc,
  94              c_name) {
  95   }
  96
  97   using Rtcp::CheckForWrapAround;
  98   using Rtcp::OnReceivedLipSyncInfo;
  99 };
 100
 101 class RtcpTest : public ::testing::Test {
 102  protected:
 103   RtcpTest()
 104       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
 105         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
 106             task_runner_, task_runner_, task_runner_, task_runner_,
 107             task_runner_, GetDefaultCastLoggingConfig())),
 108         transport_(cast_environment_, &testing_clock_) {
 109     testing_clock_.Advance(
 110         base::TimeDelta::FromMilliseconds(kStartMillisecond));
 111   }
 112
 113   virtual ~RtcpTest() {}
 114
 115   virtual void SetUp() {
 116     EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(0);
 117   }
 118
 119   base::SimpleTestTickClock testing_clock_;
 120   scoped_refptr<test::FakeTaskRunner> task_runner_;
 121   scoped_refptr<CastEnvironment> cast_environment_;
 122   LocalRtcpTransport transport_;
 123   MockRtcpSenderFeedback mock_sender_feedback_;
 124 };
 125
 126 TEST_F(RtcpTest, TimeToSend) {
 127   base::TimeTicks start_time;
 128   start_time += base::TimeDelta::FromMilliseconds(kStartMillisecond);
 129   Rtcp rtcp(cast_environment_,
 130             &mock_sender_feedback_,
 131             &transport_,
 132             NULL,
 133             NULL,
 134             kRtcpCompound,
 135             base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 136             kSenderSsrc,
 137             kReceiverSsrc,
 138             kCName);
 139   transport_.SetRtcpReceiver(&rtcp);
 140   EXPECT_LE(start_time, rtcp.TimeToSendNextRtcpReport());
 141   EXPECT_GE(start_time + base::TimeDelta::FromMilliseconds(
 142                 kRtcpIntervalMs * 3 / 2),
 143             rtcp.TimeToSendNextRtcpReport());
 144   base::TimeDelta delta = rtcp.TimeToSendNextRtcpReport() - start_time;
 145   testing_clock_.Advance(delta);
 146   EXPECT_EQ(testing_clock_.NowTicks(), rtcp.TimeToSendNextRtcpReport());
 147 }
 148
 149 TEST_F(RtcpTest, BasicSenderReport) {
 150   Rtcp rtcp(cast_environment_,
 151             &mock_sender_feedback_,
 152             &transport_,
 153             NULL,
 154             NULL,
 155             kRtcpCompound,
 156             base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 157             kSenderSsrc,
 158             kReceiverSsrc,
 159             kCName);
 160   transport_.SetRtcpReceiver(&rtcp);
 161   rtcp.SendRtcpFromRtpSender(NULL);
 162 }
 163
 164 TEST_F(RtcpTest, BasicReceiverReport) {
 165   Rtcp rtcp(cast_environment_,
 166             &mock_sender_feedback_,
 167             &transport_,
 168             NULL,
 169             NULL,
 170             kRtcpCompound,
 171             base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 172             kSenderSsrc,
 173             kReceiverSsrc,
 174             kCName);
 175   transport_.SetRtcpReceiver(&rtcp);
 176   rtcp.SendRtcpFromRtpReceiver(NULL, NULL);
 177 }
 178
 179 TEST_F(RtcpTest, BasicCast) {
 180   EXPECT_CALL(mock_sender_feedback_, OnReceivedCastFeedback(_)).Times(1);
 181
 182   // Media receiver.
 183   Rtcp rtcp(cast_environment_,
 184             &mock_sender_feedback_,
 185             &transport_,
 186             NULL,
 187             NULL,
 188             kRtcpReducedSize,
 189             base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 190             kSenderSsrc,
 191             kSenderSsrc,
 192             kCName);
 193   transport_.SetRtcpReceiver(&rtcp);
 194   RtcpCastMessage cast_message(kSenderSsrc);
 195   cast_message.ack_frame_id_ = kAckFrameId;
 196   PacketIdSet missing_packets;
 197   cast_message.missing_frames_and_packets_[
 198       kLostFrameId] = missing_packets;
 199
 200   missing_packets.insert(kLostPacketId1);
 201   missing_packets.insert(kLostPacketId2);
 202   missing_packets.insert(kLostPacketId3);
 203   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 204       missing_packets;
 205   rtcp.SendRtcpFromRtpReceiver(&cast_message, NULL);
 206 }
 207
 208 TEST_F(RtcpTest, RttReducedSizeRtcp) {
 209   // Media receiver.
 210   LocalRtcpTransport receiver_transport(cast_environment_, &testing_clock_);
 211   Rtcp rtcp_receiver(cast_environment_,
 212                      &mock_sender_feedback_,
 213                      &receiver_transport,
 214                      NULL,
 215                      NULL,
 216                      kRtcpReducedSize,
 217                      base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 218                      kReceiverSsrc,
 219                      kSenderSsrc,
 220                      kCName);
 221
 222   // Media sender.
 223   LocalRtcpTransport sender_transport(cast_environment_, &testing_clock_);
 224   Rtcp rtcp_sender(cast_environment_,
 225                    &mock_sender_feedback_,
 226                    &sender_transport,
 227                    NULL,
 228                    NULL,
 229                    kRtcpReducedSize,
 230                    base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 231                    kSenderSsrc,
 232                    kReceiverSsrc,
 233                    kCName);
 234
 235   receiver_transport.SetRtcpReceiver(&rtcp_sender);
 236   sender_transport.SetRtcpReceiver(&rtcp_receiver);
 237
 238   base::TimeDelta rtt;
 239   base::TimeDelta avg_rtt;
 240   base::TimeDelta min_rtt;
 241   base::TimeDelta max_rtt;
 242   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 243   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 244
 245   rtcp_sender.SendRtcpFromRtpSender(NULL);
 246   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 247   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 248   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 249   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
 250   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
 251   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
 252   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 253   rtcp_sender.SendRtcpFromRtpSender(NULL);
 254   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 255
 256   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
 257   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
 258   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
 259   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 260 }
 261
 262 TEST_F(RtcpTest, Rtt) {
 263   // Media receiver.
 264   LocalRtcpTransport receiver_transport(cast_environment_, &testing_clock_);
 265   Rtcp rtcp_receiver(cast_environment_,
 266                      &mock_sender_feedback_,
 267                      &receiver_transport,
 268                      NULL,
 269                      NULL,
 270                      kRtcpCompound,
 271                      base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 272                      kReceiverSsrc,
 273                      kSenderSsrc,
 274                      kCName);
 275
 276   // Media sender.
 277   LocalRtcpTransport sender_transport(cast_environment_, &testing_clock_);
 278   Rtcp rtcp_sender(cast_environment_,
 279                    &mock_sender_feedback_,
 280                    &sender_transport,
 281                    NULL,
 282                    NULL,
 283                    kRtcpCompound,
 284                    base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 285                    kSenderSsrc,
 286                    kReceiverSsrc,
 287                    kCName);
 288
 289   receiver_transport.SetRtcpReceiver(&rtcp_sender);
 290   sender_transport.SetRtcpReceiver(&rtcp_receiver);
 291
 292   base::TimeDelta rtt;
 293   base::TimeDelta avg_rtt;
 294   base::TimeDelta min_rtt;
 295   base::TimeDelta max_rtt;
 296   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 297   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 298
 299   rtcp_sender.SendRtcpFromRtpSender(NULL);
 300   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 301   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 302   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 303   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
 304   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
 305   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
 306   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 307
 308   rtcp_sender.SendRtcpFromRtpSender(NULL);
 309   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 310   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
 311   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
 312   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
 313   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 314
 315   receiver_transport.SetShortDelay();
 316   sender_transport.SetShortDelay();
 317   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 318   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 319   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 1);
 320   EXPECT_NEAR((kAddedShortDelay + 3 * kAddedDelay) / 2,
 321                avg_rtt.InMilliseconds(),
 322                1);
 323   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, min_rtt.InMilliseconds(), 1);
 324   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 325
 326   rtcp_sender.SendRtcpFromRtpSender(NULL);
 327   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 328   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1);
 329   EXPECT_NEAR((2 * kAddedShortDelay + 2 * kAddedDelay) / 2,
 330                avg_rtt.InMilliseconds(),
 331                1);
 332   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 1);
 333   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 334
 335   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 336   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 337   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1);
 338   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 1);
 339   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 340
 341   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 342   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 343   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1);
 344   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 1);
 345   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 346 }
 347
 348 TEST_F(RtcpTest, RttWithPacketLoss) {
 349   // Media receiver.
 350   LocalRtcpTransport receiver_transport(cast_environment_, &testing_clock_);
 351   Rtcp rtcp_receiver(cast_environment_,
 352                      &mock_sender_feedback_,
 353                      &receiver_transport,
 354                      NULL,
 355                      NULL,
 356                      kRtcpReducedSize,
 357                      base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 358                      kSenderSsrc,
 359                      kReceiverSsrc,
 360                      kCName);
 361
 362   // Media sender.
 363   LocalRtcpTransport sender_transport(cast_environment_, &testing_clock_);
 364   Rtcp rtcp_sender(cast_environment_,
 365                    &mock_sender_feedback_,
 366                    &sender_transport,
 367                    NULL,
 368                    NULL,
 369                    kRtcpReducedSize,
 370                    base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 371                    kReceiverSsrc,
 372                    kSenderSsrc,
 373                    kCName);
 374
 375   receiver_transport.SetRtcpReceiver(&rtcp_sender);
 376   sender_transport.SetRtcpReceiver(&rtcp_receiver);
 377
 378   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 379   rtcp_sender.SendRtcpFromRtpSender(NULL);
 380
 381   base::TimeDelta rtt;
 382   base::TimeDelta avg_rtt;
 383   base::TimeDelta min_rtt;
 384   base::TimeDelta max_rtt;
 385   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 386   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 387   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
 388   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
 389   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
 390   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 391
 392   receiver_transport.SetShortDelay();
 393   sender_transport.SetShortDelay();
 394   receiver_transport.SetDropPackets(true);
 395
 396   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, NULL);
 397   rtcp_sender.SendRtcpFromRtpSender(NULL);
 398
 399   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt,  &max_rtt));
 400   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 1);
 401 }
 402
 403 TEST_F(RtcpTest, NtpAndTime) {
 404   const int64 kSecondsbetweenYear1900and2010 = GG_INT64_C(40176 * 24 * 60 * 60);
 405   const int64 kSecondsbetweenYear1900and2030 = GG_INT64_C(47481 * 24 * 60 * 60);
 406
 407   uint32 ntp_seconds_1 = 0;
 408   uint32 ntp_fractions_1 = 0;
 409   base::TimeTicks input_time = base::TimeTicks::Now();
 410   ConvertTimeTicksToNtp(input_time, &ntp_seconds_1, &ntp_fractions_1);
 411
 412   // Verify absolute value.
 413   EXPECT_GT(ntp_seconds_1, kSecondsbetweenYear1900and2010);
 414   EXPECT_LT(ntp_seconds_1, kSecondsbetweenYear1900and2030);
 415
 416   base::TimeTicks out_1 = ConvertNtpToTimeTicks(ntp_seconds_1, ntp_fractions_1);
 417   EXPECT_EQ(input_time, out_1);  // Verify inverse.
 418
 419   base::TimeDelta time_delta = base::TimeDelta::FromMilliseconds(1000);
 420   input_time += time_delta;
 421
 422   uint32 ntp_seconds_2 = 0;
 423   uint32 ntp_fractions_2 = 0;
 424
 425   ConvertTimeTicksToNtp(input_time, &ntp_seconds_2, &ntp_fractions_2);
 426   base::TimeTicks out_2 = ConvertNtpToTimeTicks(ntp_seconds_2, ntp_fractions_2);
 427   EXPECT_EQ(input_time, out_2);  // Verify inverse.
 428
 429   // Verify delta.
 430   EXPECT_EQ((out_2 - out_1), time_delta);
 431   EXPECT_EQ((ntp_seconds_2 - ntp_seconds_1), GG_UINT32_C(1));
 432   EXPECT_NEAR(ntp_fractions_2, ntp_fractions_1, 1);
 433
 434   time_delta = base::TimeDelta::FromMilliseconds(500);
 435   input_time += time_delta;
 436
 437   uint32 ntp_seconds_3 = 0;
 438   uint32 ntp_fractions_3 = 0;
 439
 440   ConvertTimeTicksToNtp(input_time, &ntp_seconds_3, &ntp_fractions_3);
 441   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fractions_3);
 442   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 443
 444   // Verify delta.
 445   EXPECT_EQ((out_3 - out_2), time_delta);
 446   EXPECT_NEAR((ntp_fractions_3 - ntp_fractions_2), 0xffffffff / 2, 1);
 447 }
 448
 449 TEST_F(RtcpTest, WrapAround) {
 450   RtcpPeer rtcp_peer(cast_environment_,
 451                      &mock_sender_feedback_,
 452                      NULL,
 453                      NULL,
 454                      NULL,
 455                      kRtcpReducedSize,
 456                      base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 457                      kReceiverSsrc,
 458                      kSenderSsrc,
 459                      kCName);
 460   uint32 new_timestamp = 0;
 461   uint32 old_timestamp = 0;
 462   EXPECT_EQ(0, rtcp_peer.CheckForWrapAround(new_timestamp, old_timestamp));
 463   new_timestamp = 1234567890;
 464   old_timestamp = 1234567000;
 465   EXPECT_EQ(0, rtcp_peer.CheckForWrapAround(new_timestamp, old_timestamp));
 466   new_timestamp = 1234567000;
 467   old_timestamp = 1234567890;
 468   EXPECT_EQ(0, rtcp_peer.CheckForWrapAround(new_timestamp, old_timestamp));
 469   new_timestamp = 123;
 470   old_timestamp = 4234567890u;
 471   EXPECT_EQ(1, rtcp_peer.CheckForWrapAround(new_timestamp, old_timestamp));
 472   new_timestamp = 4234567890u;
 473   old_timestamp = 123;
 474   EXPECT_EQ(-1, rtcp_peer.CheckForWrapAround(new_timestamp, old_timestamp));
 475 }
 476
 477 TEST_F(RtcpTest, RtpTimestampInSenderTime) {
 478   RtcpPeer rtcp_peer(cast_environment_,
 479                      &mock_sender_feedback_,
 480                      NULL,
 481                      NULL,
 482                      NULL,
 483                      kRtcpReducedSize,
 484                      base::TimeDelta::FromMilliseconds(kRtcpIntervalMs),
 485                      kReceiverSsrc,
 486                      kSenderSsrc,
 487                      kCName);
 488   int frequency = 32000;
 489   uint32 rtp_timestamp = 64000;
 490   base::TimeTicks rtp_timestamp_in_ticks;
 491
 492   // Test fail before we get a OnReceivedLipSyncInfo.
 493   EXPECT_FALSE(rtcp_peer.RtpTimestampInSenderTime(frequency, rtp_timestamp,
 494                                                    &rtp_timestamp_in_ticks));
 495
 496   uint32 ntp_seconds = 0;
 497   uint32 ntp_fractions = 0;
 498   uint64 input_time_us = 12345678901000LL;
 499   base::TimeTicks input_time;
 500   input_time += base::TimeDelta::FromMicroseconds(input_time_us);
 501
 502   // Test exact match.
 503   ConvertTimeTicksToNtp(input_time, &ntp_seconds, &ntp_fractions);
 504   rtcp_peer.OnReceivedLipSyncInfo(rtp_timestamp, ntp_seconds, ntp_fractions);
 505   EXPECT_TRUE(rtcp_peer.RtpTimestampInSenderTime(frequency, rtp_timestamp,
 506                                                  &rtp_timestamp_in_ticks));
 507   EXPECT_EQ(input_time, rtp_timestamp_in_ticks);
 508
 509   // Test older rtp_timestamp.
 510   rtp_timestamp = 32000;
 511   EXPECT_TRUE(rtcp_peer.RtpTimestampInSenderTime(frequency, rtp_timestamp,
 512                                                  &rtp_timestamp_in_ticks));
 513   EXPECT_EQ(input_time - base::TimeDelta::FromMilliseconds(1000),
 514             rtp_timestamp_in_ticks);
 515
 516   // Test older rtp_timestamp with wrap.
 517   rtp_timestamp = 4294903296u;
 518   EXPECT_TRUE(rtcp_peer.RtpTimestampInSenderTime(frequency, rtp_timestamp,
 519                                                  &rtp_timestamp_in_ticks));
 520   EXPECT_EQ(input_time - base::TimeDelta::FromMilliseconds(4000),
 521             rtp_timestamp_in_ticks);
 522
 523   // Test newer rtp_timestamp.
 524   rtp_timestamp = 128000;
 525   EXPECT_TRUE(rtcp_peer.RtpTimestampInSenderTime(frequency, rtp_timestamp,
 526                                                  &rtp_timestamp_in_ticks));
 527   EXPECT_EQ(input_time + base::TimeDelta::FromMilliseconds(2000),
 528             rtp_timestamp_in_ticks);
 529
 530   // Test newer rtp_timestamp with wrap.
 531   rtp_timestamp = 4294903296u;
 532   rtcp_peer.OnReceivedLipSyncInfo(rtp_timestamp, ntp_seconds, ntp_fractions);
 533   rtp_timestamp = 64000;
 534   EXPECT_TRUE(rtcp_peer.RtpTimestampInSenderTime(frequency, rtp_timestamp,
 535                                                  &rtp_timestamp_in_ticks));
 536   EXPECT_EQ(input_time + base::TimeDelta::FromMilliseconds(4000),
 537             rtp_timestamp_in_ticks);
 538 }
 539
 540 }  // namespace cast
 541 }  // namespace media