src/net/quic/quic_time.cc

   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 #include "net/quic/quic_time.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace net {
  10
  11 // Highest number of microseconds that DateTimeOffset can hold.
  12 const int64 kQuicInfiniteTimeUs = GG_INT64_C(0x7fffffffffffffff) / 10;
  13
  14 QuicTime::Delta::Delta(base::TimeDelta delta)
  15     : delta_(delta) {
  16 }
  17
  18 // static
  19 QuicTime::Delta QuicTime::Delta::Zero() {
  20   return QuicTime::Delta::FromMicroseconds(0);
  21 }
  22
  23 // static
  24 QuicTime::Delta QuicTime::Delta::Infinite() {
  25   return QuicTime::Delta::FromMicroseconds(kQuicInfiniteTimeUs);
  26 }
  27
  28 // static
  29 QuicTime::Delta QuicTime::Delta::FromSeconds(int64 seconds) {
  30   return QuicTime::Delta(base::TimeDelta::FromSeconds(seconds));
  31 }
  32
  33 // static
  34 QuicTime::Delta QuicTime::Delta::FromMilliseconds(int64 ms) {
  35   return QuicTime::Delta(base::TimeDelta::FromMilliseconds(ms));
  36 }
  37
  38 // static
  39 QuicTime::Delta QuicTime::Delta::FromMicroseconds(int64 us) {
  40   return QuicTime::Delta(base::TimeDelta::FromMicroseconds(us));
  41 }
  42
  43 int64 QuicTime::Delta::ToSeconds() const {
  44   return delta_.InSeconds();
  45 }
  46
  47 int64 QuicTime::Delta::ToMilliseconds() const {
  48   return delta_.InMilliseconds();
  49 }
  50
  51 int64 QuicTime::Delta::ToMicroseconds() const {
  52   return delta_.InMicroseconds();
  53 }
  54
  55 QuicTime::Delta QuicTime::Delta::Add(const Delta& delta) const {
  56   return QuicTime::Delta::FromMicroseconds(ToMicroseconds() +
  57                                            delta.ToMicroseconds());
  58 }
  59
  60 QuicTime::Delta QuicTime::Delta::Subtract(const Delta& delta) const {
  61   return QuicTime::Delta::FromMicroseconds(ToMicroseconds() -
  62                                            delta.ToMicroseconds());
  63 }
  64
  65 QuicTime::Delta QuicTime::Delta::Multiply(int i) const {
  66   return QuicTime::Delta::FromMicroseconds(ToMicroseconds() * i);
  67 }
  68
  69 QuicTime::Delta QuicTime::Delta::Multiply(double d) const {
  70   return QuicTime::Delta::FromMicroseconds(ToMicroseconds() * d);
  71 }
  72
  73 // static
  74 QuicTime::Delta QuicTime::Delta::Max(QuicTime::Delta delta1,
  75                                      QuicTime::Delta delta2) {
  76   return delta1 < delta2 ? delta2 : delta1;
  77 }
  78
  79 bool QuicTime::Delta::IsZero() const {
  80   return delta_.InMicroseconds() == 0;
  81 }
  82
  83 bool QuicTime::Delta::IsInfinite() const {
  84   return delta_.InMicroseconds() == kQuicInfiniteTimeUs;
  85 }
  86
  87 // static
  88 QuicTime QuicTime::Zero() {
  89   return QuicTime(base::TimeTicks());
  90 }
  91
  92 // static
  93 QuicTime QuicTime::Infinite() {
  94   return QuicTime(base::TimeTicks::FromInternalValue(kQuicInfiniteTimeUs));
  95 }
  96
  97 // static
  98 QuicTime QuicTime::Max(QuicTime time1, QuicTime time2) {
  99   return time1 > time2 ? time1 : time2;
 100 }
 101
 102 QuicTime::QuicTime(base::TimeTicks ticks)
 103     : ticks_(ticks) {
 104 }
 105
 106 int64 QuicTime::ToDebuggingValue() const {
 107   return (ticks_ - base::TimeTicks()).InMicroseconds();
 108 }
 109
 110 bool QuicTime::IsInitialized() const {
 111   return ticks_ != base::TimeTicks();
 112 }
 113
 114 QuicTime QuicTime::Add(const Delta& delta) const {
 115   return QuicTime(ticks_ + delta.delta_);
 116 }
 117
 118 QuicTime QuicTime::Subtract(const Delta& delta) const {
 119   return QuicTime(ticks_ - delta.delta_);
 120 }
 121
 122 QuicTime::Delta QuicTime::Subtract(const QuicTime& other) const {
 123   return QuicTime::Delta(ticks_ - other.ticks_);
 124 }
 125
 126 // static
 127 QuicWallTime QuicWallTime::FromUNIXSeconds(uint64 seconds) {
 128   return QuicWallTime(seconds);
 129 }
 130
 131 // static
 132 QuicWallTime QuicWallTime::Zero() {
 133   return QuicWallTime(0);
 134 }
 135
 136 uint64 QuicWallTime::ToUNIXSeconds() const {
 137   return seconds_;
 138 }
 139
 140 bool QuicWallTime::IsAfter(QuicWallTime other) const {
 141   return seconds_ > other.seconds_;
 142 }
 143
 144 bool QuicWallTime::IsBefore(QuicWallTime other) const {
 145   return seconds_ < other.seconds_;
 146 }
 147
 148 bool QuicWallTime::IsZero() const {
 149   return seconds_ == 0;
 150 }
 151
 152 QuicTime::Delta QuicWallTime::AbsoluteDifference(QuicWallTime other) const {
 153   uint64 d;
 154
 155   if (seconds_ > other.seconds_) {
 156     d = seconds_ - other.seconds_;
 157   } else {
 158     d = other.seconds_ - seconds_;
 159   }
 160
 161   if (d > static_cast<uint64>(kint64max)) {
 162     d = kint64max;
 163   }
 164   return QuicTime::Delta::FromSeconds(d);
 165 }
 166
 167 QuicWallTime QuicWallTime::Add(QuicTime::Delta delta) const {
 168   uint64 seconds = seconds_ + delta.ToSeconds();
 169   if (seconds < seconds_) {
 170     seconds = kuint64max;
 171   }
 172   return QuicWallTime(seconds);
 173 }
 174
 175 QuicWallTime QuicWallTime::Subtract(QuicTime::Delta delta) const {
 176   uint64 seconds = seconds_ - delta.ToSeconds();
 177   if (seconds > seconds_) {
 178     seconds = 0;
 179   }
 180   return QuicWallTime(seconds);
 181 }
 182
 183 QuicWallTime::QuicWallTime(uint64 seconds)
 184     : seconds_(seconds) {
 185 }
 186
 187 }  // namespace net