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::Max(QuicTime time1, QuicTime time2) {
  94   return time1 > time2 ? time1 : time2;
  95 }
  96
  97 QuicTime::QuicTime(base::TimeTicks ticks)
  98     : ticks_(ticks) {
  99 }
 100
 101 int64 QuicTime::ToDebuggingValue() const {
 102   return (ticks_ - base::TimeTicks()).InMicroseconds();
 103 }
 104
 105 bool QuicTime::IsInitialized() const {
 106   return ticks_ != base::TimeTicks();
 107 }
 108
 109 QuicTime QuicTime::Add(const Delta& delta) const {
 110   return QuicTime(ticks_ + delta.delta_);
 111 }
 112
 113 QuicTime QuicTime::Subtract(const Delta& delta) const {
 114   return QuicTime(ticks_ - delta.delta_);
 115 }
 116
 117 QuicTime::Delta QuicTime::Subtract(const QuicTime& other) const {
 118   return QuicTime::Delta(ticks_ - other.ticks_);
 119 }
 120
 121 // static
 122 QuicWallTime QuicWallTime::FromUNIXSeconds(uint64 seconds) {
 123   return QuicWallTime(seconds);
 124 }
 125
 126 // static
 127 QuicWallTime QuicWallTime::Zero() {
 128   return QuicWallTime(0);
 129 }
 130
 131 uint64 QuicWallTime::ToUNIXSeconds() const {
 132   return seconds_;
 133 }
 134
 135 bool QuicWallTime::IsAfter(QuicWallTime other) const {
 136   return seconds_ > other.seconds_;
 137 }
 138
 139 bool QuicWallTime::IsBefore(QuicWallTime other) const {
 140   return seconds_ < other.seconds_;
 141 }
 142
 143 bool QuicWallTime::IsZero() const {
 144   return seconds_ == 0;
 145 }
 146
 147 QuicTime::Delta QuicWallTime::AbsoluteDifference(QuicWallTime other) const {
 148   uint64 d;
 149
 150   if (seconds_ > other.seconds_) {
 151     d = seconds_ - other.seconds_;
 152   } else {
 153     d = other.seconds_ - seconds_;
 154   }
 155
 156   if (d > static_cast<uint64>(kint64max)) {
 157     d = kint64max;
 158   }
 159   return QuicTime::Delta::FromSeconds(d);
 160 }
 161
 162 QuicWallTime QuicWallTime::Add(QuicTime::Delta delta) const {
 163   uint64 seconds = seconds_ + delta.ToSeconds();
 164   if (seconds < seconds_) {
 165     seconds = kuint64max;
 166   }
 167   return QuicWallTime(seconds);
 168 }
 169
 170 QuicWallTime QuicWallTime::Subtract(QuicTime::Delta delta) const {
 171   uint64 seconds = seconds_ - delta.ToSeconds();
 172   if (seconds > seconds_) {
 173     seconds = 0;
 174   }
 175   return QuicWallTime(seconds);
 176 }
 177
 178 QuicWallTime::QuicWallTime(uint64 seconds)
 179     : seconds_(seconds) {
 180 }
 181
 182 }  // namespace net