1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 // 5 // QuicTime represents one point in time, stored in microsecond resolution. 6 // QuicTime is monotonically increasing, even across system clock adjustments. 7 // The epoch (time 0) of QuicTime is unspecified. 8 // 9 // This implementation wraps the classes base::TimeTicks and base::TimeDelta. 10 11 #ifndef NET_QUIC_QUIC_TIME_H_ 12 #define NET_QUIC_QUIC_TIME_H_ 13 14 #include "base/basictypes.h" 15 #include "base/time/time.h" 16 #include "net/base/net_export.h" 17 18 namespace net { 19 20 static const uint64 kNumMicrosPerSecond = base::Time::kMicrosecondsPerSecond; 21 22 // A QuicTime is a purely relative time. QuicTime values from different clocks 23 // cannot be compared to each other. If you need an absolute time, see 24 // QuicWallTime, below. 25 class NET_EXPORT_PRIVATE QuicTime { 26 public: 27 // A QuicTime::Delta represents the signed difference between two points in 28 // time, stored in microsecond resolution. 29 class NET_EXPORT_PRIVATE Delta { 30 public: 31 explicit Delta(base::TimeDelta delta); 32 33 // Create a object with an offset of 0. 34 static Delta Zero(); 35 36 // Create a object with infinite offset time. 37 static Delta Infinite(); 38 39 // Converts a number of seconds to a time offset. 40 static Delta FromSeconds(int64 secs); 41 42 // Converts a number of milliseconds to a time offset. 43 static Delta FromMilliseconds(int64 ms); 44 45 // Converts a number of microseconds to a time offset. 46 static Delta FromMicroseconds(int64 us); 47 48 // Converts the time offset to a rounded number of seconds. 49 int64 ToSeconds() const; 50 51 // Converts the time offset to a rounded number of milliseconds. 52 int64 ToMilliseconds() const; 53 54 // Converts the time offset to a rounded number of microseconds. 55 int64 ToMicroseconds() const; 56 57 Delta Add(const Delta& delta) const; 58 59 Delta Subtract(const Delta& delta) const; 60 61 bool IsZero() const; 62 63 bool IsInfinite() const; 64 65 private: 66 base::TimeDelta delta_; 67 68 friend class QuicTime; 69 friend class QuicClock; 70 }; 71 72 explicit QuicTime(base::TimeTicks ticks); 73 74 // Creates a new QuicTime with an internal value of 0. IsInitialized() 75 // will return false for these times. 76 static QuicTime Zero(); 77 78 // Produce the internal value to be used when logging. This value 79 // represents the number of microseconds since some epoch. It may 80 // be the UNIX epoch on some platforms. On others, it may 81 // be a CPU ticks based value. 82 int64 ToDebuggingValue() const; 83 84 bool IsInitialized() const; 85 86 QuicTime Add(const Delta& delta) const; 87 88 QuicTime Subtract(const Delta& delta) const; 89 90 Delta Subtract(const QuicTime& other) const; 91 92 private: 93 friend bool operator==(QuicTime lhs, QuicTime rhs); 94 friend bool operator<(QuicTime lhs, QuicTime rhs); 95 96 friend class QuicClock; 97 friend class QuicClockTest; 98 99 base::TimeTicks ticks_; 100 }; 101 102 // A QuicWallTime represents an absolute time that is globally consistent. It 103 // provides, at most, one second granularity and, in practice, clock-skew means 104 // that you shouldn't even depend on that. 105 class NET_EXPORT_PRIVATE QuicWallTime { 106 public: 107 // FromUNIXSeconds constructs a QuicWallTime from a count of the seconds 108 // since the UNIX epoch. 109 static QuicWallTime FromUNIXSeconds(uint64 seconds); 110 111 // Zero returns a QuicWallTime set to zero. IsZero will return true for this 112 // value. 113 static QuicWallTime Zero(); 114 115 // ToUNIXSeconds converts a QuicWallTime into a count of seconds since the 116 // UNIX epoch. 117 uint64 ToUNIXSeconds() const; 118 119 bool IsAfter(QuicWallTime other) const; 120 bool IsBefore(QuicWallTime other) const; 121 122 // IsZero returns true if this object is the result of calling |Zero|. 123 bool IsZero() const; 124 125 // AbsoluteDifference returns the absolute value of the time difference 126 // between |this| and |other|. 127 QuicTime::Delta AbsoluteDifference(QuicWallTime other) const; 128 129 // Add returns a new QuicWallTime that represents the time of |this| plus 130 // |delta|. 131 QuicWallTime Add(QuicTime::Delta delta) const; 132 133 // Subtract returns a new QuicWallTime that represents the time of |this| 134 // minus |delta|. 135 QuicWallTime Subtract(QuicTime::Delta delta) const; 136 137 private: 138 explicit QuicWallTime(uint64 seconds); 139 140 uint64 seconds_; 141 }; 142 143 // Non-member relational operators for QuicTime::Delta. 144 inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs) { 145 return lhs.ToMicroseconds() == rhs.ToMicroseconds(); 146 } 147 inline bool operator!=(QuicTime::Delta lhs, QuicTime::Delta rhs) { 148 return !(lhs == rhs); 149 } 150 inline bool operator<(QuicTime::Delta lhs, QuicTime::Delta rhs) { 151 return lhs.ToMicroseconds() < rhs.ToMicroseconds(); 152 } 153 inline bool operator>(QuicTime::Delta lhs, QuicTime::Delta rhs) { 154 return rhs < lhs; 155 } 156 inline bool operator<=(QuicTime::Delta lhs, QuicTime::Delta rhs) { 157 return !(rhs < lhs); 158 } 159 inline bool operator>=(QuicTime::Delta lhs, QuicTime::Delta rhs) { 160 return !(lhs < rhs); 161 } 162 // Non-member relational operators for QuicTime. 163 inline bool operator==(QuicTime lhs, QuicTime rhs) { 164 return lhs.ticks_ == rhs.ticks_; 165 } 166 inline bool operator!=(QuicTime lhs, QuicTime rhs) { 167 return !(lhs == rhs); 168 } 169 inline bool operator<(QuicTime lhs, QuicTime rhs) { 170 return lhs.ticks_ < rhs.ticks_; 171 } 172 inline bool operator>(QuicTime lhs, QuicTime rhs) { 173 return rhs < lhs; 174 } 175 inline bool operator<=(QuicTime lhs, QuicTime rhs) { 176 return !(rhs < lhs); 177 } 178 inline bool operator>=(QuicTime lhs, QuicTime rhs) { 179 return !(lhs < rhs); 180 } 181 182 } // namespace net 183 184 #endif // NET_QUIC_QUIC_TIME_H_ 185
