Landing Recent QUIC changes until 2016-07-02 02:45 UTC

net/quic/quic_time.h

 // 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.
 
@@ skipping 52 matching lines @@
 
     // Converts the time offset to a rounded number of seconds.
     inline int64_t ToSeconds() const { return time_offset_ / 1000 / 1000; }
 
     // Converts the time offset to a rounded number of milliseconds.
     inline int64_t ToMilliseconds() const { return time_offset_ / 1000; }
 
     // Converts the time offset to a rounded number of microseconds.
     inline int64_t ToMicroseconds() const { return time_offset_; }
 
-    inline Delta Add(Delta delta) const WARN_UNUSED_RESULT {
-      return Delta(time_offset_ + delta.time_offset_);
-    }
-
-    inline Delta Subtract(Delta delta) const WARN_UNUSED_RESULT {
-      return Delta(time_offset_ - delta.time_offset_);
-    }
-
-    inline Delta Multiply(int i) const WARN_UNUSED_RESULT {
-      return Delta(time_offset_ * i);
-    }
-
-    inline Delta Multiply(double d) const WARN_UNUSED_RESULT {
-      return Delta(time_offset_ * d);
-    }
-
     // Returns the larger delta of time1 and time2.
     static inline Delta Max(Delta delta1, Delta delta2) {
       return delta1 < delta2 ? delta2 : delta1;
     }
 
     // Returns the smaller delta of time1 and time2.
     static inline Delta Min(Delta delta1, Delta delta2) {
       return delta1 < delta2 ? delta1 : delta2;
     }
 
     inline bool IsZero() const { return time_offset_ == 0; }
 
     inline bool IsInfinite() const {
       return time_offset_ == kQuicInfiniteTimeUs;
     }
 
    private:
     base::TimeDelta delta_;
     friend inline bool operator==(QuicTime::Delta lhs, QuicTime::Delta rhs);
     friend inline bool operator<(QuicTime::Delta lhs, QuicTime::Delta rhs);
     friend inline QuicTime::Delta operator<<(QuicTime::Delta lhs, size_t rhs);
     friend inline QuicTime::Delta operator>>(QuicTime::Delta lhs, size_t rhs);
 
-    // Highest number of microseconds that DateTimeOffset can hold.
-    static const int64_t kQuicInfiniteTimeUs = INT64_C(0x7fffffffffffffff) / 10;
+    friend inline QuicTime::Delta operator+(QuicTime::Delta lhs,
+                                            QuicTime::Delta rhs);
+    friend inline QuicTime::Delta operator-(QuicTime::Delta lhs,
+                                            QuicTime::Delta rhs);
+    friend inline QuicTime::Delta operator*(QuicTime::Delta lhs, int rhs);
+    friend inline QuicTime::Delta operator*(QuicTime::Delta lhs, double rhs);
+
+    friend inline QuicTime operator+(QuicTime lhs, QuicTime::Delta rhs);
+    friend inline QuicTime operator-(QuicTime lhs, QuicTime::Delta rhs);
+    friend inline QuicTime::Delta operator-(QuicTime lhs, QuicTime rhs);
+
+    static const int64_t kQuicInfiniteTimeUs =
+        std::numeric_limits<int64_t>::max();
 
     explicit QUICTIME_CONSTEXPR Delta(int64_t time_offset)
         : time_offset_(time_offset) {}
 
     int64_t time_offset_;
     friend class QuicTime;
     friend class QuicClock;
   };
 
   explicit QuicTime(base::TimeTicks ticks) : time_(ticks.ToInternalValue()) {}
@@ skipping 13 matching lines @@
   }
 
   // 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.
   inline int64_t ToDebuggingValue() const { return time_; }
 
   inline bool IsInitialized() const { return 0 != time_; }
 
-  inline QuicTime Add(Delta delta) const WARN_UNUSED_RESULT {
-    return QuicTime(time_ + delta.time_offset_);
-  }
-
-  inline QuicTime Subtract(Delta delta) const WARN_UNUSED_RESULT {
-    return QuicTime(time_ - delta.time_offset_);
-  }
-
-  inline Delta Subtract(QuicTime other) const WARN_UNUSED_RESULT {
-    return Delta(time_ - other.time_);
-  }
-
  private:
   friend inline bool operator==(QuicTime lhs, QuicTime rhs);
   friend inline bool operator<(QuicTime lhs, QuicTime rhs);
-  friend class QuicClock;
-  friend class QuicClockTest;
+  friend inline QuicTime operator+(QuicTime lhs, QuicTime::Delta rhs);
+  friend inline QuicTime operator-(QuicTime lhs, QuicTime::Delta rhs);
+  friend inline QuicTime::Delta operator-(QuicTime lhs, QuicTime rhs);
 
   explicit QUICTIME_CONSTEXPR QuicTime(int64_t time) : time_(time) {}
 
   int64_t time_;
 };
 
 // A QuicWallTime represents an absolute time that is globally consistent. In
 // practice, clock-skew means that comparing values from different machines
-// requires some flexibility in interpretation.
+// requires some flexibility.
 class NET_EXPORT_PRIVATE QuicWallTime {
  public:
   // FromUNIXSeconds constructs a QuicWallTime from a count of the seconds
   // since the UNIX epoch.
   static QUICTIME_CONSTEXPR QuicWallTime FromUNIXSeconds(uint64_t seconds) {
     return QuicWallTime(seconds * 1000000);
   }
 
   static QUICTIME_CONSTEXPR QuicWallTime
   FromUNIXMicroseconds(uint64_t microseconds) {
@@ skipping 73 matching lines @@
 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);
 }
 
+// Non-member arithmetic operators for QuicTime::Delta.
+inline QuicTime::Delta operator+(QuicTime::Delta lhs, QuicTime::Delta rhs) {
+  return QuicTime::Delta(lhs.time_offset_ + rhs.time_offset_);
+}
+inline QuicTime::Delta operator-(QuicTime::Delta lhs, QuicTime::Delta rhs) {
+  return QuicTime::Delta(lhs.time_offset_ - rhs.time_offset_);
+}
+inline QuicTime::Delta operator*(QuicTime::Delta lhs, int rhs) {
+  return QuicTime::Delta(lhs.time_offset_ * rhs);
+}
+inline QuicTime::Delta operator*(QuicTime::Delta lhs, double rhs) {
+  return QuicTime::Delta(lhs.time_offset_ * rhs);
+}
+inline QuicTime::Delta operator*(int lhs, QuicTime::Delta rhs) {
+  return rhs * lhs;
+}
+inline QuicTime::Delta operator*(double lhs, QuicTime::Delta rhs) {
+  return rhs * lhs;
+}
+
+// Non-member arithmetic operators for QuicTime and QuicTime::Delta.
+inline QuicTime operator+(QuicTime lhs, QuicTime::Delta rhs) {
+  return QuicTime(lhs.time_ + rhs.time_offset_);
+}
+inline QuicTime operator-(QuicTime lhs, QuicTime::Delta rhs) {
+  return QuicTime(lhs.time_ - rhs.time_offset_);
+}
+inline QuicTime::Delta operator-(QuicTime lhs, QuicTime rhs) {
+  return QuicTime::Delta(lhs.time_ - rhs.time_);
+}
+
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_TIME_H_