Use clock_gettime instead of base::TimeTicks::Now() in QUIC

net/quic/core/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.
 
 #ifndef NET_QUIC_CORE_QUIC_TIME_H_
 #define NET_QUIC_CORE_QUIC_TIME_H_
 
 #include <cmath>
 #include <cstdint>
 #include <limits>
 #include <ostream>
 
 #include "base/compiler_specific.h"
 #include "base/time/time.h"
 #include "net/quic/platform/api/quic_export.h"
 
 #define QUICTIME_CONSTEXPR inline
 
 namespace net {
 
+class QuicClock;
+
 // 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 QUIC_EXPORT_PRIVATE QuicTime {
  public:
   // A QuicTime::Delta represents the signed difference between two points in
   // time, stored in microsecond resolution.
   class QUIC_EXPORT_PRIVATE Delta {
    public:
     explicit Delta(base::TimeDelta delta);
@@ skipping 60 matching lines @@
         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()) {}
-
   // Creates a new QuicTime with an internal value of 0.  IsInitialized()
   // will return false for these times.
   static QUICTIME_CONSTEXPR QuicTime Zero() { return QuicTime(0); }
 
   // Creates a new QuicTime with an infinite time.
   static QUICTIME_CONSTEXPR QuicTime Infinite() {
     return QuicTime(Delta::kQuicInfiniteTimeUs);
   }
 
   // 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_; }
 
  private:
+  friend class QuicClock;
+
   friend inline bool operator==(QuicTime lhs, QuicTime rhs);
   friend inline bool operator<(QuicTime lhs, QuicTime 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);
 
   explicit QUICTIME_CONSTEXPR QuicTime(int64_t time) : time_(time) {}
 
   int64_t time_;
 };
@@ skipping 128 matching lines @@
 
 // Override stream output operator for gtest.
 inline std::ostream& operator<<(std::ostream& output,
                                 const QuicTime::Delta delta) {
   output << delta.ToDebugValue();
   return output;
 }
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_TIME_H_