Change to calculate the real NTP in TimeTicks.

media/cast/cast_defines.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MEDIA_CAST_CAST_DEFINES_H_
 #define MEDIA_CAST_CAST_DEFINES_H_
 
 #include <map>
 #include <set>
 
@@ skipping 36 matching lines @@
 const size_t kMinLengthOfRtp = 12 + 6;
 
 // Each uint16 represents one packet id within a cast frame.
 typedef std::set<uint16> PacketIdSet;
 // Each uint8 represents one cast frame.
 typedef std::map<uint8, PacketIdSet> MissingFramesAndPacketsMap;
 
 // TODO(pwestin): Re-factor the functions bellow into a class with static
 // methods.
 
+// January 1970, in NTP seconds.
+// Network Time Protocol (NTP), which is in seconds relative to 0h UTC on
+// 1 January 1900.
+static const int64 kUnixEpochInNtpSeconds = GG_INT64_C(2208988800);
+
 // Magic fractional unit. Used to convert time (in microseconds) to/from
 // fractional NTP seconds.
 static const double kMagicFractionalUnit = 4.294967296E3;
 
-// Network Time Protocol (NTP), which is in seconds relative to 0h UTC on
-// 1 January 1900.
-static const int64 kNtpEpochDeltaSeconds = GG_INT64_C(9435484800);
-static const int64 kNtpEpochDeltaMicroseconds =
-    kNtpEpochDeltaSeconds * base::Time::kMicrosecondsPerSecond;
-
 inline bool IsNewerFrameId(uint8 frame_id, uint8 prev_frame_id) {
   return (frame_id != prev_frame_id) &&
       static_cast<uint8>(frame_id - prev_frame_id) < 0x80;
 }
 
 inline bool IsOlderFrameId(uint8 frame_id, uint8 prev_frame_id) {
   return (frame_id == prev_frame_id) || IsNewerFrameId(prev_frame_id, frame_id);
 }
 
 inline bool IsNewerPacketId(uint16 packet_id, uint16 prev_packet_id) {
@@ skipping 23 matching lines @@
 
 inline void ConvertTimeToFractions(int64 time_us,
                                    uint32* seconds,
                                    uint32* fractions) {
   DCHECK_GE(time_us, 0) << "Time must NOT be negative";
   *seconds = static_cast<uint32>(time_us / base::Time::kMicrosecondsPerSecond);
   *fractions = static_cast<uint32>(
       (time_us % base::Time::kMicrosecondsPerSecond) * kMagicFractionalUnit);
 }
 
-inline void ConvertTimeToNtp(const base::TimeTicks& time,
-                             uint32* ntp_seconds,
-                             uint32* ntp_fractions) {
-  int64 time_us = time.ToInternalValue() - kNtpEpochDeltaMicroseconds;
-  ConvertTimeToFractions(time_us, ntp_seconds, ntp_fractions);
+inline void ConvertTimeTicksToNtp(const base::TimeTicks& time,
+                                  uint32* ntp_seconds,
+                                  uint32* ntp_fractions) {
+  base::TimeDelta elapsed_since_unix_epoch =
+      time - base::TimeTicks::UnixEpoch();
+
+  int64 ntp_time_us = elapsed_since_unix_epoch.InMicroseconds() +
+      (kUnixEpochInNtpSeconds * base::Time::kMicrosecondsPerSecond);
+
+  ConvertTimeToFractions(ntp_time_us, ntp_seconds, ntp_fractions);
 }
 
-inline base::TimeTicks ConvertNtpToTime(uint32 ntp_seconds,
-                                        uint32 ntp_fractions) {
+inline base::TimeTicks ConvertNtpToTimeTicks(uint32 ntp_seconds,
+                                             uint32 ntp_fractions) {
   int64 ntp_time_us = static_cast<int64>(ntp_seconds) *
-       base::Time::kMicrosecondsPerSecond;
+      base::Time::kMicrosecondsPerSecond;
   ntp_time_us += static_cast<int64>(ntp_fractions) / kMagicFractionalUnit;
-  return base::TimeTicks::FromInternalValue(ntp_time_us +
-      kNtpEpochDeltaMicroseconds);
+  return base::TimeTicks() + base::TimeDelta::FromMicroseconds(ntp_time_us);

[miu, 2013/10/30 19:33:35]

This reverse conversion needs to map NTP time back to UNIX time, and then
convert to TimeTicks using TimeTicks::UnixEpoch().  Something like:

  base::TimeDelta elapsed_since_unix_epoch = base::TimeDelta::FromMicroseconds(
      ntp_time_us - (kUnixEpochInNtpSeconds *
base::Time::kMicrosecondsPerSecond));
  return base::TimeTicks::UnixEpoch() + elapsed_since_unix_epoch;

It would be helpful if there was a unit test somewhere that demonstrated these
functions are inverses of each other.  RtcpTest.NtpAndTime only tests that the
deltas are computed correctly.

[pwestin, 2013/10/30 23:14:30]

Done.

 }
 
 }  // namespace cast
 }  // namespace media
 
 #endif  // MEDIA_CAST_CAST_DEFINES_H_