src/media/cast/net/rtcp/rtcp_unittest.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include <stdint.h>
   6
   7 #include "base/test/simple_test_tick_clock.h"
   8 #include "media/cast/cast_defines.h"
   9 #include "media/cast/net/cast_transport_config.h"
  10 #include "media/cast/net/cast_transport_sender_impl.h"
  11 #include "media/cast/net/pacing/paced_sender.h"
  12 #include "media/cast/net/rtcp/mock_rtcp_receiver_feedback.h"
  13 #include "media/cast/net/rtcp/rtcp.h"
  14 #include "media/cast/net/rtcp/test_rtcp_packet_builder.h"
  15 #include "media/cast/test/fake_single_thread_task_runner.h"
  16 #include "testing/gmock/include/gmock/gmock.h"
  17
  18 namespace media {
  19 namespace cast {
  20
  21 using testing::_;
  22
  23 static const uint32 kSenderSsrc = 0x10203;
  24 static const uint32 kReceiverSsrc = 0x40506;
  25 static const int64 kAddedDelay = 123;
  26 static const int64 kAddedShortDelay = 100;
  27
  28 class RtcpTestPacketSender : public PacketSender {
  29  public:
  30   explicit RtcpTestPacketSender(base::SimpleTestTickClock* testing_clock)
  31       : drop_packets_(false),
  32         short_delay_(false),
  33         rtcp_receiver_(NULL),
  34         testing_clock_(testing_clock) {}
  35   virtual ~RtcpTestPacketSender() {}
  36   // Packet lists imply a RTP packet.
  37   void set_rtcp_receiver(Rtcp* rtcp) { rtcp_receiver_ = rtcp; }
  38
  39   void set_short_delay() { short_delay_ = true; }
  40
  41   void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; }
  42
  43   // A singular packet implies a RTCP packet.
  44   virtual bool SendPacket(PacketRef packet,
  45                           const base::Closure& cb) OVERRIDE {
  46     if (short_delay_) {
  47       testing_clock_->Advance(
  48           base::TimeDelta::FromMilliseconds(kAddedShortDelay));
  49     } else {
  50       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay));
  51     }
  52     if (drop_packets_)
  53       return true;
  54
  55     rtcp_receiver_->IncomingRtcpPacket(&packet->data[0], packet->data.size());
  56     return true;
  57   }
  58
  59  private:
  60   bool drop_packets_;
  61   bool short_delay_;
  62   Rtcp* rtcp_receiver_;
  63   base::SimpleTestTickClock* testing_clock_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(RtcpTestPacketSender);
  66 };
  67
  68 class LocalRtcpTransport : public PacedPacketSender {
  69  public:
  70   explicit LocalRtcpTransport(base::SimpleTestTickClock* testing_clock)
  71       : drop_packets_(false),
  72         short_delay_(false),
  73         testing_clock_(testing_clock) {}
  74
  75   void set_rtcp_receiver(Rtcp* rtcp) { rtcp_ = rtcp; }
  76
  77   void set_short_delay() { short_delay_ = true; }
  78
  79   void set_drop_packets(bool drop_packets) { drop_packets_ = drop_packets; }
  80
  81   virtual bool SendRtcpPacket(uint32 ssrc,
  82                               PacketRef packet) OVERRIDE {
  83     if (short_delay_) {
  84       testing_clock_->Advance(
  85           base::TimeDelta::FromMilliseconds(kAddedShortDelay));
  86     } else {
  87       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(kAddedDelay));
  88     }
  89     if (drop_packets_)
  90       return true;
  91
  92     rtcp_->IncomingRtcpPacket(&packet->data[0], packet->data.size());
  93     return true;
  94   }
  95
  96   virtual bool SendPackets(
  97       const SendPacketVector& packets) OVERRIDE {
  98     return false;
  99   }
 100
 101   virtual bool ResendPackets(
 102       const SendPacketVector& packets,
 103       base::TimeDelta dedupe_window) OVERRIDE {
 104     return false;
 105   }
 106
 107   virtual void CancelSendingPacket(
 108       const PacketKey& packet_key) OVERRIDE {
 109   }
 110
 111  private:
 112   bool drop_packets_;
 113   bool short_delay_;
 114   Rtcp* rtcp_;
 115   base::SimpleTestTickClock* testing_clock_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(LocalRtcpTransport);
 118 };
 119
 120 class MockReceiverStats : public RtpReceiverStatistics {
 121  public:
 122   MockReceiverStats() {}
 123   virtual ~MockReceiverStats() {}
 124
 125   virtual void GetStatistics(uint8* fraction_lost,
 126                              uint32* cumulative_lost,
 127                              uint32* extended_high_sequence_number,
 128                              uint32* jitter) OVERRIDE {
 129     *fraction_lost = 0;
 130     *cumulative_lost = 0;
 131     *extended_high_sequence_number = 0;
 132     *jitter = 0;
 133   }
 134
 135  private:
 136   DISALLOW_COPY_AND_ASSIGN(MockReceiverStats);
 137 };
 138
 139 class MockFrameSender {
 140  public:
 141   MockFrameSender() {}
 142   virtual ~MockFrameSender() {}
 143
 144   MOCK_METHOD1(OnReceivedCastFeedback,
 145                void(const RtcpCastMessage& cast_message));
 146   MOCK_METHOD4(OnReceivedRtt,
 147                void(base::TimeDelta rtt,
 148                     base::TimeDelta avg_rtt,
 149                     base::TimeDelta min_rtt,
 150                     base::TimeDelta max_rtt));
 151  private:
 152   DISALLOW_COPY_AND_ASSIGN(MockFrameSender);
 153 };
 154
 155 class RtcpTest : public ::testing::Test {
 156  protected:
 157   RtcpTest()
 158       : testing_clock_(new base::SimpleTestTickClock()),
 159         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
 160         sender_to_receiver_(testing_clock_),
 161         receiver_to_sender_(testing_clock_) {
 162     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
 163   }
 164
 165   virtual ~RtcpTest() {}
 166
 167   static void UpdateCastTransportStatus(CastTransportStatus status) {
 168     bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
 169                    status == TRANSPORT_VIDEO_INITIALIZED);
 170     EXPECT_TRUE(result);
 171   }
 172
 173   void RunTasks(int during_ms) {
 174     for (int i = 0; i < during_ms; ++i) {
 175       // Call process the timers every 1 ms.
 176       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1));
 177       task_runner_->RunTasks();
 178     }
 179   }
 180
 181   base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
 182   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
 183   LocalRtcpTransport sender_to_receiver_;
 184   LocalRtcpTransport receiver_to_sender_;
 185   MockFrameSender mock_frame_sender_;
 186   MockReceiverStats stats_;
 187
 188   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 189 };
 190
 191 TEST_F(RtcpTest, BasicSenderReport) {
 192   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
 193                        base::Unretained(&mock_frame_sender_)),
 194             base::Bind(&MockFrameSender::OnReceivedRtt,
 195                        base::Unretained(&mock_frame_sender_)),
 196             RtcpLogMessageCallback(),
 197             testing_clock_,
 198             &sender_to_receiver_,
 199             kSenderSsrc,
 200             kReceiverSsrc);
 201   sender_to_receiver_.set_rtcp_receiver(&rtcp);
 202   rtcp.SendRtcpFromRtpSender(base::TimeTicks(), 0, 1, 1);
 203 }
 204
 205 TEST_F(RtcpTest, BasicReceiverReport) {
 206   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
 207                        base::Unretained(&mock_frame_sender_)),
 208             base::Bind(&MockFrameSender::OnReceivedRtt,
 209                        base::Unretained(&mock_frame_sender_)),
 210             RtcpLogMessageCallback(),
 211             testing_clock_,
 212             &receiver_to_sender_,
 213             kSenderSsrc,
 214             kReceiverSsrc);
 215   receiver_to_sender_.set_rtcp_receiver(&rtcp);
 216   rtcp.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 217 }
 218
 219 TEST_F(RtcpTest, BasicCast) {
 220   EXPECT_CALL(mock_frame_sender_, OnReceivedCastFeedback(_)).Times(1);
 221
 222   // Media sender.
 223   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
 224                        base::Unretained(&mock_frame_sender_)),
 225             base::Bind(&MockFrameSender::OnReceivedRtt,
 226                        base::Unretained(&mock_frame_sender_)),
 227             RtcpLogMessageCallback(),
 228             testing_clock_,
 229             &receiver_to_sender_,
 230             kSenderSsrc,
 231             kSenderSsrc);
 232   receiver_to_sender_.set_rtcp_receiver(&rtcp);
 233   RtcpCastMessage cast_message(kSenderSsrc);
 234   cast_message.ack_frame_id = kAckFrameId;
 235   PacketIdSet missing_packets;
 236   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 237
 238   missing_packets.insert(kLostPacketId1);
 239   missing_packets.insert(kLostPacketId2);
 240   missing_packets.insert(kLostPacketId3);
 241   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
 242       missing_packets;
 243   rtcp.SendRtcpFromRtpReceiver(&cast_message, base::TimeDelta(), NULL, NULL);
 244 }
 245
 246 TEST_F(RtcpTest, RttReducedSizeRtcp) {
 247   // Media receiver.
 248   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
 249                      RtcpRttCallback(),
 250                      RtcpLogMessageCallback(),
 251                      testing_clock_,
 252                      &receiver_to_sender_,
 253                      kReceiverSsrc,
 254                      kSenderSsrc);
 255
 256   // Media sender.
 257   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
 258                               base::Unretained(&mock_frame_sender_)),
 259                    base::Bind(&MockFrameSender::OnReceivedRtt,
 260                               base::Unretained(&mock_frame_sender_)),
 261                    RtcpLogMessageCallback(),
 262                    testing_clock_,
 263                    &sender_to_receiver_,
 264                    kSenderSsrc,
 265                    kReceiverSsrc);
 266
 267   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 268   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
 269
 270   base::TimeDelta rtt;
 271   base::TimeDelta avg_rtt;
 272   base::TimeDelta min_rtt;
 273   base::TimeDelta max_rtt;
 274   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 275   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 276
 277   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1);
 278   RunTasks(33);
 279   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 280   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 281   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 282   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
 283   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
 284   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
 285   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 286   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2, 1, 1);
 287   RunTasks(33);
 288   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 289
 290   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
 291   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
 292   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
 293   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 294 }
 295
 296 TEST_F(RtcpTest, Rtt) {
 297   // Media receiver.
 298   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
 299                      RtcpRttCallback(),
 300                      RtcpLogMessageCallback(),
 301                      testing_clock_,
 302                      &receiver_to_sender_,
 303                      kReceiverSsrc,
 304                      kSenderSsrc);
 305
 306   // Media sender.
 307   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
 308                               base::Unretained(&mock_frame_sender_)),
 309                    base::Bind(&MockFrameSender::OnReceivedRtt,
 310                               base::Unretained(&mock_frame_sender_)),
 311                    RtcpLogMessageCallback(),
 312                    testing_clock_,
 313                    &sender_to_receiver_,
 314                    kSenderSsrc,
 315                    kReceiverSsrc);
 316
 317   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
 318   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 319
 320   base::TimeDelta rtt;
 321   base::TimeDelta avg_rtt;
 322   base::TimeDelta min_rtt;
 323   base::TimeDelta max_rtt;
 324   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 325   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 326
 327   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1);
 328   RunTasks(33);
 329   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 330
 331   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 332   RunTasks(33);
 333
 334   EXPECT_FALSE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 335   RunTasks(33);
 336
 337   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
 338   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
 339   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
 340   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 341
 342   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 2, 1, 1);
 343   RunTasks(33);
 344   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 345   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 2);
 346   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
 347   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
 348   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 349
 350   receiver_to_sender_.set_short_delay();
 351   sender_to_receiver_.set_short_delay();
 352   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 353   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 354   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2);
 355   EXPECT_NEAR(
 356       (kAddedShortDelay + 3 * kAddedDelay) / 2, avg_rtt.InMilliseconds(), 2);
 357   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, min_rtt.InMilliseconds(), 2);
 358   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 359
 360   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 3, 1, 1);
 361   RunTasks(33);
 362   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 363   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 1);
 364   EXPECT_NEAR((2 * kAddedShortDelay + 2 * kAddedDelay) / 2,
 365               avg_rtt.InMilliseconds(),
 366               1);
 367   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2);
 368   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 369
 370   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 371   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 372   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2);
 373   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2);
 374   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 375
 376   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 377   EXPECT_TRUE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 378   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2);
 379   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2);
 380   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 381 }
 382
 383 TEST_F(RtcpTest, RttWithPacketLoss) {
 384   // Media receiver.
 385   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
 386                      RtcpRttCallback(),
 387                      RtcpLogMessageCallback(),
 388                      testing_clock_,
 389                      &receiver_to_sender_,
 390                      kReceiverSsrc,
 391                      kSenderSsrc);
 392
 393   // Media sender.
 394   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
 395                               base::Unretained(&mock_frame_sender_)),
 396                    base::Bind(&MockFrameSender::OnReceivedRtt,
 397                               base::Unretained(&mock_frame_sender_)),
 398                    RtcpLogMessageCallback(),
 399                    testing_clock_,
 400                    &sender_to_receiver_,
 401                    kSenderSsrc,
 402                    kReceiverSsrc);
 403
 404   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
 405   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 406
 407   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 408   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 0, 1, 1);
 409   RunTasks(33);
 410
 411   base::TimeDelta rtt;
 412   base::TimeDelta avg_rtt;
 413   base::TimeDelta min_rtt;
 414   base::TimeDelta max_rtt;
 415   EXPECT_FALSE(rtcp_sender.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 416   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 417   EXPECT_NEAR(2 * kAddedDelay, rtt.InMilliseconds(), 1);
 418   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 1);
 419   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 1);
 420   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 1);
 421
 422   receiver_to_sender_.set_short_delay();
 423   sender_to_receiver_.set_short_delay();
 424   receiver_to_sender_.set_drop_packets(true);
 425
 426   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 427   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 1, 1, 1);
 428   RunTasks(33);
 429
 430   EXPECT_TRUE(rtcp_receiver.Rtt(&rtt, &avg_rtt, &min_rtt, &max_rtt));
 431   EXPECT_NEAR(kAddedDelay + kAddedShortDelay, rtt.InMilliseconds(), 2);
 432 }
 433
 434 TEST_F(RtcpTest, NtpAndTime) {
 435   const int64 kSecondsbetweenYear1900and2010 = INT64_C(40176 * 24 * 60 * 60);
 436   const int64 kSecondsbetweenYear1900and2030 = INT64_C(47481 * 24 * 60 * 60);
 437
 438   uint32 ntp_seconds_1 = 0;
 439   uint32 ntp_fraction_1 = 0;
 440   base::TimeTicks input_time = base::TimeTicks::Now();
 441   ConvertTimeTicksToNtp(input_time, &ntp_seconds_1, &ntp_fraction_1);
 442
 443   // Verify absolute value.
 444   EXPECT_GT(ntp_seconds_1, kSecondsbetweenYear1900and2010);
 445   EXPECT_LT(ntp_seconds_1, kSecondsbetweenYear1900and2030);
 446
 447   base::TimeTicks out_1 = ConvertNtpToTimeTicks(ntp_seconds_1, ntp_fraction_1);
 448   EXPECT_EQ(input_time, out_1);  // Verify inverse.
 449
 450   base::TimeDelta time_delta = base::TimeDelta::FromMilliseconds(1000);
 451   input_time += time_delta;
 452
 453   uint32 ntp_seconds_2 = 0;
 454   uint32 ntp_fraction_2 = 0;
 455
 456   ConvertTimeTicksToNtp(input_time, &ntp_seconds_2, &ntp_fraction_2);
 457   base::TimeTicks out_2 = ConvertNtpToTimeTicks(ntp_seconds_2, ntp_fraction_2);
 458   EXPECT_EQ(input_time, out_2);  // Verify inverse.
 459
 460   // Verify delta.
 461   EXPECT_EQ((out_2 - out_1), time_delta);
 462   EXPECT_EQ((ntp_seconds_2 - ntp_seconds_1), UINT32_C(1));
 463   EXPECT_NEAR(ntp_fraction_2, ntp_fraction_1, 1);
 464
 465   time_delta = base::TimeDelta::FromMilliseconds(500);
 466   input_time += time_delta;
 467
 468   uint32 ntp_seconds_3 = 0;
 469   uint32 ntp_fraction_3 = 0;
 470
 471   ConvertTimeTicksToNtp(input_time, &ntp_seconds_3, &ntp_fraction_3);
 472   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3);
 473   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 474
 475   // Verify delta.
 476   EXPECT_EQ((out_3 - out_2), time_delta);
 477   EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1);
 478 }
 479
 480 }  // namespace cast
 481 }  // namespace media