Use NtpTime in RTCPSender::RtcpContext instead of pair of uint32_t

webrtc/modules/rtp_rtcp/source/rtcp_sender.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 112 matching lines @@
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(PacketContainer);
 };
 
 class RTCPSender::RtcpContext {
  public:
   RtcpContext(const FeedbackState& feedback_state,
               int32_t nack_size,
               const uint16_t* nack_list,
               bool repeat,
               uint64_t picture_id,
-              uint32_t ntp_sec,
-              uint32_t ntp_frac)
+              NtpTime now)
       : feedback_state_(feedback_state),
         nack_size_(nack_size),
         nack_list_(nack_list),
         repeat_(repeat),
         picture_id_(picture_id),
-        ntp_sec_(ntp_sec),
-        ntp_frac_(ntp_frac) {}
+        now_(now) {}
 
   const FeedbackState& feedback_state_;
   const int32_t nack_size_;
   const uint16_t* nack_list_;
   const bool repeat_;
   const uint64_t picture_id_;
-  const uint32_t ntp_sec_;
-  const uint32_t ntp_frac_;
+  const NtpTime now_;
 };
 
 RTCPSender::RTCPSender(
     bool audio,
     Clock* clock,
     ReceiveStatistics* receive_statistics,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcEventLog* event_log,
     Transport* outgoing_transport)
     : audio_(audio),
@@ skipping 286 matching lines @@
   // timestamp as the last frame's timestamp + the time since the last frame
   // was captured.
   uint32_t rtp_rate =
       (audio_ ? kBogusRtpRateForAudioRtcp : kVideoPayloadTypeFrequency) / 1000;
   uint32_t rtp_timestamp =
       timestamp_offset_ + last_rtp_timestamp_ +
       (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) * rtp_rate;
 
   rtcp::SenderReport* report = new rtcp::SenderReport();
   report->SetSenderSsrc(ssrc_);
-  report->SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+  report->SetNtp(ctx.now_);
   report->SetRtpTimestamp(rtp_timestamp);
   report->SetPacketCount(ctx.feedback_state_.packets_sent);
   report->SetOctetCount(ctx.feedback_state_.media_bytes_sent);
 
   for (auto it : report_blocks_)
     report->AddReportBlock(it.second);
 
   report_blocks_.clear();
 
   return std::unique_ptr<rtcp::RtcpPacket>(report);
@@ skipping 228 matching lines @@
   return std::unique_ptr<rtcp::RtcpPacket>(bye);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildExtendedReports(
     const RtcpContext& ctx) {
   std::unique_ptr<rtcp::ExtendedReports> xr(new rtcp::ExtendedReports());
   xr->SetSenderSsrc(ssrc_);
 
   if (!sending_ && xr_send_receiver_reference_time_enabled_) {
     rtcp::Rrtr rrtr;
-    rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+    rrtr.SetNtp(ctx.now_);
     xr->SetRrtr(rrtr);
   }
 
   if (ctx.feedback_state_.has_last_xr_rr) {
     xr->AddDlrrItem(ctx.feedback_state_.last_xr_rr);
   }
 
   if (video_bitrate_allocation_) {
     rtcp::TargetBitrate target_bitrate;
 
@@ skipping 64 matching lines @@
       if (sending_ && method_ == RtcpMode::kCompound) {
         // Not allowed to send any RTCP packet without sender report.
         return -1;
       }
     }
 
     if (packet_type_counter_.first_packet_time_ms == -1)
       packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
 
     // We need to send our NTP even if we haven't received any reports.
-    uint32_t ntp_sec;
-    uint32_t ntp_frac;
-    clock_->CurrentNtp(ntp_sec, ntp_frac);
     RtcpContext context(feedback_state, nack_size, nack_list, repeat, pictureID,
-                        ntp_sec, ntp_frac);
+                        NtpTime(*clock_));
 
     PrepareReport(feedback_state);
 
     std::unique_ptr<rtcp::RtcpPacket> packet_bye;
 
     auto it = report_flags_.begin();
     while (it != report_flags_.end()) {
       auto builder_it = builders_.find(it->type);
       RTC_DCHECK(builder_it != builders_.end())
           << "Could not find builder for packet type " << it->type;
@@ skipping 250 matching lines @@
     // but we can't because of an incorrect warning (C4822) in MVS 2013.
   } sender(transport_, event_log_);
 
   RTC_DCHECK_LE(max_payload_length_, IP_PACKET_SIZE);
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc