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 bool QuicTime::Delta::IsZero() const {
  66   return delta_.InMicroseconds() == 0;
  67 }
  68
  69 bool QuicTime::Delta::IsInfinite() const {
  70   return delta_.InMicroseconds() == kQuicInfiniteTimeUs;
  71 }
  72
  73 // static
  74 QuicTime QuicTime::Zero() {
  75   return QuicTime(base::TimeTicks());
  76 }
  77
  78 QuicTime::QuicTime(base::TimeTicks ticks)
  79     : ticks_(ticks) {
  80 }
  81
  82 int64 QuicTime::ToDebuggingValue() const {
  83   return (ticks_ - base::TimeTicks()).InMicroseconds();
  84 }
  85
  86 bool QuicTime::IsInitialized() const {
  87   return ticks_ != base::TimeTicks();
  88 }
  89
  90 QuicTime QuicTime::Add(const Delta& delta) const {
  91   return QuicTime(ticks_ + delta.delta_);
  92 }
  93
  94 QuicTime QuicTime::Subtract(const Delta& delta) const {
  95   return QuicTime(ticks_ - delta.delta_);
  96 }
  97
  98 QuicTime::Delta QuicTime::Subtract(const QuicTime& other) const {
  99   return QuicTime::Delta(ticks_ - other.ticks_);
 100 }
 101
 102 // static
 103 QuicWallTime QuicWallTime::FromUNIXSeconds(uint64 seconds) {
 104   return QuicWallTime(seconds);
 105 }
 106
 107 // static
 108 QuicWallTime QuicWallTime::Zero() {
 109   return QuicWallTime(0);
 110 }
 111
 112 uint64 QuicWallTime::ToUNIXSeconds() const {
 113   return seconds_;
 114 }
 115
 116 bool QuicWallTime::IsAfter(QuicWallTime other) const {
 117   return seconds_ > other.seconds_;
 118 }
 119
 120 bool QuicWallTime::IsBefore(QuicWallTime other) const {
 121   return seconds_ < other.seconds_;
 122 }
 123
 124 bool QuicWallTime::IsZero() const {
 125   return seconds_ == 0;
 126 }
 127
 128 QuicTime::Delta QuicWallTime::AbsoluteDifference(QuicWallTime other) const {
 129   uint64 d;
 130
 131   if (seconds_ > other.seconds_) {
 132     d = seconds_ - other.seconds_;
 133   } else {
 134     d = other.seconds_ - seconds_;
 135   }
 136
 137   if (d > static_cast<uint64>(kint64max)) {
 138     d = kint64max;
 139   }
 140   return QuicTime::Delta::FromSeconds(d);
 141 }
 142
 143 QuicWallTime QuicWallTime::Add(QuicTime::Delta delta) const {
 144   uint64 seconds = seconds_ + delta.ToSeconds();
 145   if (seconds < seconds_) {
 146     seconds = kuint64max;
 147   }
 148   return QuicWallTime(seconds);
 149 }
 150
 151 QuicWallTime QuicWallTime::Subtract(QuicTime::Delta delta) const {
 152   uint64 seconds = seconds_ - delta.ToSeconds();
 153   if (seconds > seconds_) {
 154     seconds = 0;
 155   }
 156   return QuicWallTime(seconds);
 157 }
 158
 159 QuicWallTime::QuicWallTime(uint64 seconds)
 160     : seconds_(seconds) {
 161 }
 162
 163 }  // namespace net