Land Recent QUIC changes

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.
 
 #ifndef NET_QUIC_QUIC_TIME_H_
 #define NET_QUIC_QUIC_TIME_H_
 
 #include "base/basictypes.h"
 #include "base/time.h"
 #include "net/base/net_export.h"
 
 namespace net {
 
 static const uint64 kNumMicrosPerSecond = base::Time::kMicrosecondsPerSecond;
 
+// A QuicTime is a purely relative time. QuicTime values from different clocks
+// cannot be compared to each other. If you need an absolute time, see
+// QuicWallTime, below.
 class NET_EXPORT_PRIVATE QuicTime {
  public:
   // A QuicTime::Delta represents the signed difference between two points in
   // time, stored in microsecond resolution.
   class NET_EXPORT_PRIVATE Delta {
    public:
     explicit Delta(base::TimeDelta delta);
 
     // Create a object with an offset of 0.
     static Delta Zero();
@@ skipping 57 matching lines @@
  private:
   friend bool operator==(QuicTime lhs, QuicTime rhs);
   friend bool operator<(QuicTime lhs, QuicTime rhs);
 
   friend class QuicClock;
   friend class QuicClockTest;
 
   base::TimeTicks ticks_;
 };
 
+// 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.
+class NET_EXPORT_PRIVATE QuicWallTime {
+ public:
+  // FromUNIXSeconds constructs a QuicWallTime from a count of the seconds
+  // since the UNIX epoch.
+  static QuicWallTime FromUNIXSeconds(uint64 seconds);
+
+  // ToUNIXSeconds converts a QuicWallTime into a count of seconds since the
+  // UNIX epoch.
+  uint64 ToUNIXSeconds() const;
+
+  bool IsAfter(QuicWallTime other) const;
+  bool IsBefore(QuicWallTime other) 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;
+
+  // Subtract returns a new QuicWallTime that represents the time of |this|
+  // minus |delta|.
+  QuicWallTime Subtract(QuicTime::Delta delta) const;
+
+ private:
+  explicit QuicWallTime(uint64 seconds);
+
+  uint64 seconds_;
+};
+
 // Non-member relational operators for QuicTime::Delta.
 inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs) {
   return lhs.ToMicroseconds() == rhs.ToMicroseconds();
 }
 inline bool operator!=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
   return !(lhs == rhs);
 }
 inline bool operator<(QuicTime::Delta lhs, QuicTime::Delta rhs) {
   return lhs.ToMicroseconds() < rhs.ToMicroseconds();
 }
@@ skipping 22 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_