text: // Copyright (c) 2012 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // QuicTime represents one point in time, stored in microsecond resolution.
  // QuicTime is monotonically increasing, even across system clock adjustments.
  // The epoch (time 0) of QuicTime is unspecified.
  //
  // This implementation wraps the classes base::TimeTicks and base::TimeDelta.
  
  #ifndef NET_QUIC_QUIC_TIME_H_
  #define NET_QUIC_QUIC_TIME_H_
  
  #include "base/basictypes.h"
  #include "base/time/time.h"
  #include "net/base/net_export.h"
  
  namespace net {
  
  static const uint64 kNumMicrosPerSecond = base::Time::kMicrosecondsPerSecond;
  
  // A QuicTime is a purely relative time. QuicTime values from different clocks
  // cannot be compared to each other. If you need an absolute time, see
  // QuicWallTime, below.
  class NET_EXPORT_PRIVATE QuicTime {
   public:
    // A QuicTime::Delta represents the signed difference between two points in
    // time, stored in microsecond resolution.
    class NET_EXPORT_PRIVATE Delta {
     public:
      explicit Delta(base::TimeDelta delta);
  
      // Create a object with an offset of 0.
      static Delta Zero();
  
      // Create a object with infinite offset time.
      static Delta Infinite();
  
      // Converts a number of seconds to a time offset.
      static Delta FromSeconds(int64 secs);
  
      // Converts a number of milliseconds to a time offset.
      static Delta FromMilliseconds(int64 ms);
  
      // Converts a number of microseconds to a time offset.
      static Delta FromMicroseconds(int64 us);
  
      // Converts the time offset to a rounded number of seconds.
      int64 ToSeconds() const;
  
      // Converts the time offset to a rounded number of milliseconds.
      int64 ToMilliseconds() const;
  
      // Converts the time offset to a rounded number of microseconds.
      int64 ToMicroseconds() const;
  
      Delta Add(const Delta& delta) const;
  
      Delta Subtract(const Delta& delta) const;
  
      bool IsZero() const;
  
      bool IsInfinite() const;
  
     private:
      base::TimeDelta delta_;
  
      friend class QuicTime;
      friend class QuicClock;
    };
  
    explicit QuicTime(base::TimeTicks ticks);
  
    // Creates a new QuicTime with an internal value of 0.  IsInitialized()
    // will return false for these times.
    static QuicTime Zero();
  
    // Produce the internal value to be used when logging.  This value
    // represents the number of microseconds since some epoch.  It may
    // be the UNIX epoch on some platforms.  On others, it may
    // be a CPU ticks based value.
    int64 ToDebuggingValue() const;
  
    bool IsInitialized() const;
  
    QuicTime Add(const Delta& delta) const;
  
    QuicTime Subtract(const Delta& delta) const;
  
    Delta Subtract(const QuicTime& other) const;
  
   private:
    friend bool operator==(QuicTime lhs, QuicTime rhs);
    friend bool operator<(QuicTime lhs, QuicTime rhs);
  
    friend class QuicClock;
    friend class QuicClockTest;
  
    base::TimeTicks ticks_;
  };
  
  // A QuicWallTime represents an absolute time that is globally consistent. It
  // provides, at most, one second granularity and, in practice, clock-skew means
  // that you shouldn't even depend on that.
  class NET_EXPORT_PRIVATE QuicWallTime {
   public:
    // FromUNIXSeconds constructs a QuicWallTime from a count of the seconds
    // since the UNIX epoch.
    static QuicWallTime FromUNIXSeconds(uint64 seconds);
  
    // Zero returns a QuicWallTime set to zero. IsZero will return true for this
    // value.
    static QuicWallTime Zero();
  
    // ToUNIXSeconds converts a QuicWallTime into a count of seconds since the
    // UNIX epoch.
    uint64 ToUNIXSeconds() const;
  
    bool IsAfter(QuicWallTime other) const;
    bool IsBefore(QuicWallTime other) const;
  
    // IsZero returns true if this object is the result of calling |Zero|.
    bool IsZero() const;
  
    // AbsoluteDifference returns the absolute value of the time difference
    // between |this| and |other|.
    QuicTime::Delta AbsoluteDifference(QuicWallTime other) const;
  
    // Add returns a new QuicWallTime that represents the time of |this| plus
    // |delta|.
    QuicWallTime Add(QuicTime::Delta delta) const;
  
    // Subtract returns a new QuicWallTime that represents the time of |this|
    // minus |delta|.
    QuicWallTime Subtract(QuicTime::Delta delta) const;
  
   private:
    explicit QuicWallTime(uint64 seconds);
  
    uint64 seconds_;
  };
  
  // Non-member relational operators for QuicTime::Delta.
  inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs) {
    return lhs.ToMicroseconds() == rhs.ToMicroseconds();
  }
  inline bool operator!=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
    return !(lhs == rhs);
  }
  inline bool operator<(QuicTime::Delta lhs, QuicTime::Delta rhs) {
    return lhs.ToMicroseconds() < rhs.ToMicroseconds();
  }
  inline bool operator>(QuicTime::Delta lhs, QuicTime::Delta rhs) {
    return rhs < lhs;
  }
  inline bool operator<=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
    return !(rhs < lhs);
  }
  inline bool operator>=(QuicTime::Delta lhs, QuicTime::Delta rhs) {
    return !(lhs < rhs);
  }
  // Non-member relational operators for QuicTime.
  inline bool operator==(QuicTime lhs, QuicTime rhs) {
    return lhs.ticks_ == rhs.ticks_;
  }
  inline bool operator!=(QuicTime lhs, QuicTime rhs) {
    return !(lhs == rhs);
  }
  inline bool operator<(QuicTime lhs, QuicTime rhs) {
    return lhs.ticks_ < rhs.ticks_;
  }
  inline bool operator>(QuicTime lhs, QuicTime rhs) {
    return rhs < lhs;
  }
  inline bool operator<=(QuicTime lhs, QuicTime rhs) {
    return !(rhs < lhs);
  }
  inline bool operator>=(QuicTime lhs, QuicTime rhs) {
    return !(lhs < rhs);
  }
  
  }  // namespace net
  
  #endif  // NET_QUIC_QUIC_TIME_H_
  