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 18namespace net { 19 20static 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. 25class 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 Delta Multiply(int i) const; 62 Delta Multiply(double d) const; 63 64 // Returns the later delta of time1 and time2. 65 static Delta Max(Delta delta1, Delta delta2); 66 67 bool IsZero() const; 68 69 bool IsInfinite() const; 70 71 private: 72 base::TimeDelta delta_; 73 74 friend class QuicTime; 75 friend class QuicClock; 76 }; 77 78 explicit QuicTime(base::TimeTicks ticks); 79 80 // Creates a new QuicTime with an internal value of 0. IsInitialized() 81 // will return false for these times. 82 static QuicTime Zero(); 83 84 // Returns the later time of time1 and time2. 85 static QuicTime Max(QuicTime time1, QuicTime time2); 86 87 // Produce the internal value to be used when logging. This value 88 // represents the number of microseconds since some epoch. It may 89 // be the UNIX epoch on some platforms. On others, it may 90 // be a CPU ticks based value. 91 int64 ToDebuggingValue() const; 92 93 bool IsInitialized() const; 94 95 QuicTime Add(const Delta& delta) const; 96 97 QuicTime Subtract(const Delta& delta) const; 98 99 Delta Subtract(const QuicTime& other) const; 100 101 private: 102 friend bool operator==(QuicTime lhs, QuicTime rhs); 103 friend bool operator<(QuicTime lhs, QuicTime rhs); 104 105 friend class QuicClock; 106 friend class QuicClockTest; 107 108 base::TimeTicks ticks_; 109}; 110 111// A QuicWallTime represents an absolute time that is globally consistent. It 112// provides, at most, one second granularity and, in practice, clock-skew means 113// that you shouldn't even depend on that. 114class NET_EXPORT_PRIVATE QuicWallTime { 115 public: 116 // FromUNIXSeconds constructs a QuicWallTime from a count of the seconds 117 // since the UNIX epoch. 118 static QuicWallTime FromUNIXSeconds(uint64 seconds); 119 120 // Zero returns a QuicWallTime set to zero. IsZero will return true for this 121 // value. 122 static QuicWallTime Zero(); 123 124 // ToUNIXSeconds converts a QuicWallTime into a count of seconds since the 125 // UNIX epoch. 126 uint64 ToUNIXSeconds() const; 127 128 bool IsAfter(QuicWallTime other) const; 129 bool IsBefore(QuicWallTime other) const; 130 131 // IsZero returns true if this object is the result of calling |Zero|. 132 bool IsZero() const; 133 134 // AbsoluteDifference returns the absolute value of the time difference 135 // between |this| and |other|. 136 QuicTime::Delta AbsoluteDifference(QuicWallTime other) const; 137 138 // Add returns a new QuicWallTime that represents the time of |this| plus 139 // |delta|. 140 QuicWallTime Add(QuicTime::Delta delta) const; 141 142 // Subtract returns a new QuicWallTime that represents the time of |this| 143 // minus |delta|. 144 QuicWallTime Subtract(QuicTime::Delta delta) const; 145 146 private: 147 explicit QuicWallTime(uint64 seconds); 148 149 uint64 seconds_; 150}; 151 152// Non-member relational operators for QuicTime::Delta. 153inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs) { 154 return lhs.ToMicroseconds() == rhs.ToMicroseconds(); 155} 156inline bool operator!=(QuicTime::Delta lhs, QuicTime::Delta rhs) { 157 return !(lhs == rhs); 158} 159inline bool operator<(QuicTime::Delta lhs, QuicTime::Delta rhs) { 160 return lhs.ToMicroseconds() < rhs.ToMicroseconds(); 161} 162inline bool operator>(QuicTime::Delta lhs, QuicTime::Delta rhs) { 163 return rhs < lhs; 164} 165inline bool operator<=(QuicTime::Delta lhs, QuicTime::Delta rhs) { 166 return !(rhs < lhs); 167} 168inline bool operator>=(QuicTime::Delta lhs, QuicTime::Delta rhs) { 169 return !(lhs < rhs); 170} 171// Non-member relational operators for QuicTime. 172inline bool operator==(QuicTime lhs, QuicTime rhs) { 173 return lhs.ticks_ == rhs.ticks_; 174} 175inline bool operator!=(QuicTime lhs, QuicTime rhs) { 176 return !(lhs == rhs); 177} 178inline bool operator<(QuicTime lhs, QuicTime rhs) { 179 return lhs.ticks_ < rhs.ticks_; 180} 181inline bool operator>(QuicTime lhs, QuicTime rhs) { 182 return rhs < lhs; 183} 184inline bool operator<=(QuicTime lhs, QuicTime rhs) { 185 return !(rhs < lhs); 186} 187inline bool operator>=(QuicTime lhs, QuicTime rhs) { 188 return !(lhs < rhs); 189} 190 191} // namespace net 192 193#endif // NET_QUIC_QUIC_TIME_H_ 194