Change QuicWallTime to have microsecond granularity.

net/quic/quic_time.h

 // Copyright (c) 2012 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.
 //
 // QuicTime represents one point in time, stored in microsecond resolution.
 // QuicTime is monotonically increasing, even across system clock adjustments.
 // The epoch (time 0) of QuicTime is unspecified.
 //
 // This implementation wraps the classes base::TimeTicks and base::TimeDelta.
 
@@ skipping 141 matching lines @@
   friend inline bool operator==(QuicTime lhs, QuicTime rhs);
   friend inline bool operator<(QuicTime lhs, QuicTime rhs);
   friend class QuicClock;
   friend class QuicClockTest;
 
   explicit QUICTIME_CONSTEXPR QuicTime(int64 time) : time_(time) {}
 
   int64 time_;
 };
 
-// A QuicWallTime represents an absolute time that is globally consistent. It
-// provides, at most, one second granularity and, in practice, clock-skew means
-// that you shouldn't even depend on that.
+// A QuicWallTime represents an absolute time that is globally consistent. In
+// practice, clock-skew means that comparing values from different machines
+// requires some flex

[ramant (doing other things), 2015/11/03 00:33:10]

overly nit: period at the end of sentence.

[Ryan Hamilton, 2015/11/04 04:10:11]

Done.

 class NET_EXPORT_PRIVATE QuicWallTime {
  public:
   // FromUNIXSeconds constructs a QuicWallTime from a count of the seconds
   // since the UNIX epoch.
   static QUICTIME_CONSTEXPR QuicWallTime FromUNIXSeconds(uint64 seconds) {
-    return QuicWallTime(seconds);
+    return QuicWallTime(seconds * 1000000);
+  }
+
+  static QUICTIME_CONSTEXPR QuicWallTime FromUNIXMicroseconds(
+      uint64 microseconds) {
+    return QuicWallTime(microseconds);
   }
 
   // Zero returns a QuicWallTime set to zero. IsZero will return true for this
   // value.
   static QUICTIME_CONSTEXPR QuicWallTime Zero() { return QuicWallTime(0); }
 
-  // ToUNIXSeconds converts a QuicWallTime into a count of seconds since the
-  // UNIX epoch.
+  // Returns the number of seconds since the UNIX epoch.
   uint64 ToUNIXSeconds() const;
+  // Returns the number of microseconds since the UNIX epoch.
+  uint64 ToUNIXMicroseconds() const;
 
   bool IsAfter(QuicWallTime other) const;
   bool IsBefore(QuicWallTime other) const;
 
   // IsZero returns true if this object is the result of calling |Zero|.
   bool IsZero() const;
 
   // AbsoluteDifference returns the absolute value of the time difference
   // between |this| and |other|.
   QuicTime::Delta AbsoluteDifference(QuicWallTime other) const;
 
   // Add returns a new QuicWallTime that represents the time of |this| plus
   // |delta|.
   QuicWallTime Add(QuicTime::Delta delta) const WARN_UNUSED_RESULT;
 
   // Subtract returns a new QuicWallTime that represents the time of |this|
   // minus |delta|.
   QuicWallTime Subtract(QuicTime::Delta delta) const WARN_UNUSED_RESULT;
 
  private:
-  explicit QUICTIME_CONSTEXPR QuicWallTime(uint64 seconds)
-      : seconds_(seconds) {}
+  explicit QUICTIME_CONSTEXPR QuicWallTime(uint64 microseconds)
+      : microseconds_(microseconds) {}
 
-  uint64 seconds_;
+  uint64 microseconds_;
 };
 
 // Non-member relational operators for QuicTime::Delta.
 inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs) {
   return lhs.time_offset_ == rhs.time_offset_;
 }
 inline bool operator!=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
   return !(lhs == rhs);
 }
 inline bool operator<(QuicTime::Delta lhs, QuicTime::Delta rhs) {
@@ skipping 24 matching lines @@
 inline bool operator<=(QuicTime lhs, QuicTime rhs) {
   return !(rhs < lhs);
 }
 inline bool operator>=(QuicTime lhs, QuicTime rhs) {
   return !(lhs < rhs);
 }
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_TIME_H_