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