Remove clock calibration logic from QuicClock. It's been unused since all of the Quartc code got removed. PiperOrigin-RevId: 443490482

diff --git a/quiche/quic/core/quic_clock.cc b/quiche/quic/core/quic_clock.cc
index 94ca72f..571dc59 100644
--- a/quiche/quic/core/quic_clock.cc
+++ b/quiche/quic/core/quic_clock.cc

@@ -10,46 +10,8 @@
 
 namespace quic {
 
-QuicClock::QuicClock()
-    : is_calibrated_(false), calibration_offset_(QuicTime::Delta::Zero()) {}
-
-QuicClock::~QuicClock() {}
-
-QuicTime::Delta QuicClock::ComputeCalibrationOffset() const {
-  // In the ideal world, all we need to do is to return the difference of
-  // WallNow() and Now(). In the real world, things like context switch may
-  // happen between the calls to WallNow() and Now(), causing their difference
-  // to be arbitrarily large, so we repeat the calculation many times and use
-  // the one with the minimum difference as the true offset.
-  int64_t min_offset_us = std::numeric_limits<int64_t>::max();
-
-  for (int i = 0; i < 128; ++i) {
-    int64_t now_in_us = (Now() - QuicTime::Zero()).ToMicroseconds();
-    int64_t wallnow_in_us =
-        static_cast<int64_t>(WallNow().ToUNIXMicroseconds());
-
-    int64_t offset_us = wallnow_in_us - now_in_us;
-    if (offset_us < min_offset_us) {
-      min_offset_us = offset_us;
-    }
-  }
-
-  return QuicTime::Delta::FromMicroseconds(min_offset_us);
-}
-
-void QuicClock::SetCalibrationOffset(QuicTime::Delta offset) {
-  QUICHE_DCHECK(!is_calibrated_) << "A clock should only be calibrated once";
-  calibration_offset_ = offset;
-  is_calibrated_ = true;
-}
-
 QuicTime QuicClock::ConvertWallTimeToQuicTime(
     const QuicWallTime& walltime) const {
-  if (is_calibrated_) {
-    int64_t time_in_us = static_cast<int64_t>(walltime.ToUNIXMicroseconds()) -
-                         calibration_offset_.ToMicroseconds();
-    return QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(time_in_us);
-  }
 
   //     ..........................
   //     |            |           |

diff --git a/quiche/quic/core/quic_clock.h b/quiche/quic/core/quic_clock.h
index f128f9e..69aed4e 100644
--- a/quiche/quic/core/quic_clock.h
+++ b/quiche/quic/core/quic_clock.h

@@ -18,25 +18,12 @@
 // Interface for retrieving the current time.
 class QUIC_EXPORT_PRIVATE QuicClock {
  public:
-  QuicClock();
-  virtual ~QuicClock();
+  QuicClock() = default;
+  virtual ~QuicClock() = default;
 
   QuicClock(const QuicClock&) = delete;
   QuicClock& operator=(const QuicClock&) = delete;
 
-  // Compute the offset between this clock with the Unix Epoch clock.
-  // Return the calibrated offset between WallNow() and Now(), in the form of
-  // (wallnow_in_us - now_in_us).
-  // The return value can be used by SetCalibrationOffset() to actually
-  // calibrate the clock, or all instances of this clock type.
-  QuicTime::Delta ComputeCalibrationOffset() const;
-
-  // Calibrate this clock. A calibrated clock guarantees that the
-  // ConvertWallTimeToQuicTime() function always return the same result for the
-  // same walltime.
-  // Should not be called more than once for each QuicClock.
-  void SetCalibrationOffset(QuicTime::Delta offset);
-
   // Returns the approximate current time as a QuicTime object.
   virtual QuicTime ApproximateNow() const = 0;
 
@@ -57,14 +44,6 @@
   QuicTime CreateTimeFromMicroseconds(uint64_t time_us) const {
     return QuicTime(time_us);
   }
-
- private:
-  // True if |calibration_offset_| is valid.
-  bool is_calibrated_;
-  // If |is_calibrated_|, |calibration_offset_| is the (fixed) offset between
-  // the Unix Epoch clock and this clock.
-  // In other words, the offset between WallNow() and Now().
-  QuicTime::Delta calibration_offset_;
 };
 
 }  // namespace quic

diff --git a/quiche/quic/core/quic_epoll_clock_test.cc b/quiche/quic/core/quic_epoll_clock_test.cc
index e501fc4..617230f 100644
--- a/quiche/quic/core/quic_epoll_clock_test.cc
+++ b/quiche/quic/core/quic_epoll_clock_test.cc

@@ -44,70 +44,6 @@
   EXPECT_EQ(1000005, (clock.Now() - QuicTime::Zero()).ToMicroseconds());
 }
 
-TEST_F(QuicEpollClockTest, CalibrateRealEpollClock) {
-  QuicEpollServer epoll_server;
-
-  QuicEpollClock uncalibrated_clock(&epoll_server);
-  QuicEpollClock calibrated_clock(&epoll_server);
-  EXPECT_TRUE(calibrated_clock.ComputeCalibrationOffset().IsZero());
-
-  for (int i = 0; i < 100; ++i) {
-    QuicWallTime wallnow = uncalibrated_clock.WallNow();
-    EXPECT_EQ(uncalibrated_clock.ConvertWallTimeToQuicTime(wallnow),
-              calibrated_clock.ConvertWallTimeToQuicTime(wallnow));
-  }
-}
-
-// ClockWithOffset is a clock whose offset(WallNow() - Now() at any instant) is
-// given at construction time.
-class ClockWithOffset : public QuicEpollClock {
- public:
-  ClockWithOffset(QuicEpollServer* epoll_server, QuicTime::Delta offset)
-      : QuicEpollClock(epoll_server), offset_(offset) {}
-
-  QuicTime Now() const override { return QuicEpollClock::Now() - offset_; }
-
-  // QuicEpollClock disables ConvertWallTimeToQuicTime since it always have a
-  // zero offset. We need to re-enable it here in order to test the calibration
-  // and conversion code in QuicClock.
-  QuicTime ConvertWallTimeToQuicTime(
-      const QuicWallTime& walltime) const override {
-    return QuicClock::ConvertWallTimeToQuicTime(walltime);
-  }
-
- private:
-  QuicTime::Delta offset_;
-};
-
-TEST_F(QuicEpollClockTest, CalibrateClockWithOffset) {
-  QuicEpollServer epoll_server;
-
-  for (const QuicTime::Delta& offset : {QuicTime::Delta::FromSeconds(5000),
-                                        QuicTime::Delta::FromSeconds(-8000)}) {
-    ClockWithOffset clock(&epoll_server, offset);
-    ASSERT_EQ(offset, clock.ComputeCalibrationOffset())
-        << "offset (us): " << offset.ToMicroseconds();
-    // Test fails without this.
-    clock.SetCalibrationOffset(offset);
-
-    QuicWallTime last_walltime = clock.WallNow();
-    QuicTime last_time = clock.ConvertWallTimeToQuicTime(last_walltime);
-
-    for (int i = 0; i < 1e5; ++i) {
-      QuicWallTime wallnow = clock.WallNow();
-      QuicTime now = clock.ConvertWallTimeToQuicTime(wallnow);
-
-      if (wallnow.IsAfter(last_walltime)) {
-        ASSERT_LT(0, (now - last_time).ToMicroseconds())
-            << "offset (us): " << offset.ToMicroseconds();
-
-        last_walltime = wallnow;
-        last_time = now;
-      }
-    }
-  }
-}
-
 TEST_F(QuicEpollClockTest, MonotonicityWithRealEpollClock) {
   QuicEpollServer epoll_server;
   QuicEpollClock clock(&epoll_server);