1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// 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;
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();
// Create a object with infinite offset time.
static Delta Infinite();
// Converts a number of seconds to a time offset.
static Delta FromSeconds(int64 secs);
// Converts a number of milliseconds to a time offset.
static Delta FromMilliseconds(int64 ms);
// Converts a number of microseconds to a time offset.
static Delta FromMicroseconds(int64 us);
// Converts the time offset to a rounded number of seconds.
int64 ToSeconds() const;
// Converts the time offset to a rounded number of milliseconds.
int64 ToMilliseconds() const;
// Converts the time offset to a rounded number of microseconds.
int64 ToMicroseconds() const;
Delta Add(const Delta& delta) const;
Delta Subtract(const Delta& delta) const;
bool IsZero() const;
bool IsInfinite() const;
private:
base::TimeDelta delta_;
friend class QuicTime;
friend class QuicClock;
};
explicit QuicTime(base::TimeTicks ticks);
// Creates a new QuicTime with an internal value of 0. IsInitialized()
// will return false for these times.
static QuicTime Zero();
// Produce the internal value to be used when logging. This value
// represents the number of microseconds since some epoch. It may
// be the UNIX epoch on some platforms. On others, it may
// be a CPU ticks based value.
int64 ToDebuggingValue() const;
bool IsInitialized() const;
QuicTime Add(const Delta& delta) const;
QuicTime Subtract(const Delta& delta) const;
Delta Subtract(const QuicTime& other) const;
private:
friend bool operator==(QuicTime lhs, QuicTime rhs);
friend bool operator<(QuicTime lhs, QuicTime rhs);
friend class QuicClock;
friend class QuicClockTest;
base::TimeTicks ticks_;
};
// 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();
}
inline bool operator>(QuicTime::Delta lhs, QuicTime::Delta rhs) {
return rhs < lhs;
}
inline bool operator<=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
return !(rhs < lhs);
}
inline bool operator>=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
return !(lhs < rhs);
}
// Non-member relational operators for QuicTime.
inline bool operator==(QuicTime lhs, QuicTime rhs) {
return lhs.ticks_ == rhs.ticks_;
}
inline bool operator!=(QuicTime lhs, QuicTime rhs) {
return !(lhs == rhs);
}
inline bool operator<(QuicTime lhs, QuicTime rhs) {
return lhs.ticks_ < rhs.ticks_;
}
inline bool operator>(QuicTime lhs, QuicTime rhs) {
return rhs < lhs;
}
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_
|
