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(
  71       static_cast<int64>(ToMicroseconds() * d));
  72 }
  73
  74 // static
  75 QuicTime::Delta QuicTime::Delta::Max(QuicTime::Delta delta1,
  76                                      QuicTime::Delta delta2) {
  77   return delta1 < delta2 ? delta2 : delta1;
  78 }
  79
  80 bool QuicTime::Delta::IsZero() const {
  81   return delta_.InMicroseconds() == 0;
  82 }
  83
  84 bool QuicTime::Delta::IsInfinite() const {
  85   return delta_.InMicroseconds() == kQuicInfiniteTimeUs;
  86 }
  87
  88 // static
  89 QuicTime QuicTime::Zero() {
  90   return QuicTime(base::TimeTicks());
  91 }
  92
  93 // static
  94 QuicTime QuicTime::Infinite() {
  95   return QuicTime(base::TimeTicks::FromInternalValue(kQuicInfiniteTimeUs));
  96 }
  97
  98 // static
  99 QuicTime QuicTime::Max(QuicTime time1, QuicTime time2) {
 100   return time1 > time2 ? time1 : time2;
 101 }
 102
 103 QuicTime::QuicTime(base::TimeTicks ticks)
 104     : ticks_(ticks) {
 105 }
 106
 107 int64 QuicTime::ToDebuggingValue() const {
 108   return (ticks_ - base::TimeTicks()).InMicroseconds();
 109 }
 110
 111 bool QuicTime::IsInitialized() const {
 112   return ticks_ != base::TimeTicks();
 113 }
 114
 115 QuicTime QuicTime::Add(const Delta& delta) const {
 116   return QuicTime(ticks_ + delta.delta_);
 117 }
 118
 119 QuicTime QuicTime::Subtract(const Delta& delta) const {
 120   return QuicTime(ticks_ - delta.delta_);
 121 }
 122
 123 QuicTime::Delta QuicTime::Subtract(const QuicTime& other) const {
 124   return QuicTime::Delta(ticks_ - other.ticks_);
 125 }
 126
 127 // static
 128 QuicWallTime QuicWallTime::FromUNIXSeconds(uint64 seconds) {
 129   return QuicWallTime(seconds);
 130 }
 131
 132 // static
 133 QuicWallTime QuicWallTime::Zero() {
 134   return QuicWallTime(0);
 135 }
 136
 137 uint64 QuicWallTime::ToUNIXSeconds() const {
 138   return seconds_;
 139 }
 140
 141 bool QuicWallTime::IsAfter(QuicWallTime other) const {
 142   return seconds_ > other.seconds_;
 143 }
 144
 145 bool QuicWallTime::IsBefore(QuicWallTime other) const {
 146   return seconds_ < other.seconds_;
 147 }
 148
 149 bool QuicWallTime::IsZero() const {
 150   return seconds_ == 0;
 151 }
 152
 153 QuicTime::Delta QuicWallTime::AbsoluteDifference(QuicWallTime other) const {
 154   uint64 d;
 155
 156   if (seconds_ > other.seconds_) {
 157     d = seconds_ - other.seconds_;
 158   } else {
 159     d = other.seconds_ - seconds_;
 160   }
 161
 162   if (d > static_cast<uint64>(kint64max)) {
 163     d = kint64max;
 164   }
 165   return QuicTime::Delta::FromSeconds(d);
 166 }
 167
 168 QuicWallTime QuicWallTime::Add(QuicTime::Delta delta) const {
 169   uint64 seconds = seconds_ + delta.ToSeconds();
 170   if (seconds < seconds_) {
 171     seconds = kuint64max;
 172   }
 173   return QuicWallTime(seconds);
 174 }
 175
 176 // TODO(ianswett) Test this.
 177 QuicWallTime QuicWallTime::Subtract(QuicTime::Delta delta) const {
 178   uint64 seconds = seconds_ - delta.ToSeconds();
 179   if (seconds > seconds_) {
 180     seconds = 0;
 181   }
 182   return QuicWallTime(seconds);
 183 }
 184
 185 QuicWallTime::QuicWallTime(uint64 seconds)
 186     : seconds_(seconds) {
 187 }
 188
 189 }  // namespace net