Home | History | Annotate | Download | only in quic 
      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
    183