Use NtpTime in RtcpMeasurement instead of uint sec/uint frac.

webrtc/video/stream_synchronization_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 18 matching lines @@
 static const int kSmoothingFilter = 4 * 2;
 
 class Time {
  public:
   explicit Time(int64_t offset)
       : kNtpJan1970(2208988800UL),
         time_now_ms_(offset) {}
 
   RtcpMeasurement GenerateRtcp(int frequency, uint32_t offset) const {
     RtcpMeasurement rtcp;
-    NowNtp(&rtcp.ntp_secs, &rtcp.ntp_frac);
-    rtcp.rtp_timestamp = NowRtp(frequency, offset);
+    rtcp.ntp_time = GetNowNtp();
+    rtcp.rtp_timestamp = GetNowRtp(frequency, offset);
     return rtcp;
   }
 
-  void NowNtp(uint32_t* ntp_secs, uint32_t* ntp_frac) const {
-    *ntp_secs = time_now_ms_ / 1000 + kNtpJan1970;
+  NtpTime GetNowNtp() const {
+    uint32_t ntp_secs = time_now_ms_ / 1000 + kNtpJan1970;
     int64_t remainder_ms = time_now_ms_ % 1000;
-    *ntp_frac = static_cast<uint32_t>(
+    uint32_t ntp_frac = static_cast<uint32_t>(
         static_cast<double>(remainder_ms) * kNtpFracPerMs + 0.5);
+    return NtpTime(ntp_secs, ntp_frac);
   }
 
-  uint32_t NowRtp(int frequency, uint32_t offset) const {
+  uint32_t GetNowRtp(int frequency, uint32_t offset) const {
     return frequency * time_now_ms_ / 1000 + offset;
   }
 
   void IncreaseTimeMs(int64_t inc) {
     time_now_ms_ += inc;
   }
 
   int64_t time_now_ms() const {
     return time_now_ms_;
   }
@@ skipping 36 matching lines @@
     int audio_offset = 0;
     int video_frequency = static_cast<int>(kDefaultVideoFrequency *
                                            video_clock_drift_ + 0.5);
     bool new_sr;
     int video_offset = 0;
     StreamSynchronization::Measurements audio;
     StreamSynchronization::Measurements video;
     // Generate NTP/RTP timestamp pair for both streams corresponding to RTCP.
     RtcpMeasurement rtcp =
         send_time_->GenerateRtcp(audio_frequency, audio_offset);
-    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_secs, rtcp.ntp_frac, rtcp.rtp_timestamp,
+    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_time.seconds(),
+                               rtcp.ntp_time.fractions(), rtcp.rtp_timestamp,
                                &audio.rtcp, &new_sr));
     send_time_->IncreaseTimeMs(100);
     receive_time_->IncreaseTimeMs(100);
     rtcp = send_time_->GenerateRtcp(video_frequency, video_offset);
-    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_secs, rtcp.ntp_frac, rtcp.rtp_timestamp,
+    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_time.seconds(),
+                               rtcp.ntp_time.fractions(), rtcp.rtp_timestamp,
                                &video.rtcp, &new_sr));
     send_time_->IncreaseTimeMs(900);
     receive_time_->IncreaseTimeMs(900);
     rtcp = send_time_->GenerateRtcp(audio_frequency, audio_offset);
-    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_secs, rtcp.ntp_frac, rtcp.rtp_timestamp,
+    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_time.seconds(),
+                               rtcp.ntp_time.fractions(), rtcp.rtp_timestamp,
                                &audio.rtcp, &new_sr));
     send_time_->IncreaseTimeMs(100);
     receive_time_->IncreaseTimeMs(100);
     rtcp = send_time_->GenerateRtcp(video_frequency, video_offset);
-    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_secs, rtcp.ntp_frac, rtcp.rtp_timestamp,
+    EXPECT_TRUE(UpdateRtcpList(rtcp.ntp_time.seconds(),
+                               rtcp.ntp_time.fractions(), rtcp.rtp_timestamp,
                                &video.rtcp, &new_sr));
+
     send_time_->IncreaseTimeMs(900);
     receive_time_->IncreaseTimeMs(900);
 
     // Capture an audio and a video frame at the same time.
-    audio.latest_timestamp = send_time_->NowRtp(audio_frequency,
-                                                audio_offset);
-    video.latest_timestamp = send_time_->NowRtp(video_frequency,
-                                                video_offset);
+    audio.latest_timestamp =
+        send_time_->GetNowRtp(audio_frequency, audio_offset);
+    video.latest_timestamp =
+        send_time_->GetNowRtp(video_frequency, video_offset);
 
     if (audio_delay_ms > video_delay_ms) {
       // Audio later than video.
       receive_time_->IncreaseTimeMs(video_delay_ms);
       video.latest_receive_time_ms = receive_time_->time_now_ms();
       receive_time_->IncreaseTimeMs(audio_delay_ms - video_delay_ms);
       audio.latest_receive_time_ms = receive_time_->time_now_ms();
     } else {
       // Video later than audio.
       receive_time_->IncreaseTimeMs(audio_delay_ms);
@@ skipping 417 matching lines @@
 
 TEST_F(StreamSynchronizationTest,
        BothDelayedVideoLaterVideoClockDriftWithBaseDelay) {
   int base_target_delay_ms = 2000;
   video_clock_drift_ = 1.05;
   sync_->SetTargetBufferingDelay(base_target_delay_ms);
   BothDelayedVideoLaterTest(base_target_delay_ms);
 }
 
 }  // namespace webrtc