Replace std::chrono::duration_cast<milliseconds> with folly::chrono::ceil in

Summary:
duration_cast round towards zero. The diff uses folly::chrono::ceil
rather than std::chrono::ceil since we still need to compile with c++14

Differential Revision: D22870632

fbshipit-source-id: 18439488e879164807b1676a0105073348800412

quic/api/QuicTransportBase.cpp

@@ -8,6 +8,7 @@
 
 #include <quic/api/QuicTransportBase.h>
 
+#include <folly/Chrono.h>
 #include <folly/ScopeGuard.h>
 #include <quic/api/LoopDetectorCallback.h>
 #include <quic/api/QuicTransportFunctions.h>
@@ -448,7 +449,7 @@ void QuicTransportBase::closeImpl(
     DCHECK(!drainTimeout_.isScheduled());
     getEventBase()->timer().scheduleTimeout(
         &drainTimeout_,
-        std::chrono::duration_cast<std::chrono::milliseconds>(
+        folly::chrono::ceil<std::chrono::milliseconds>(
             kDrainFactor * calculatePTO(*conn_)));
   } else {
     drainTimeoutExpired();
@@ -2413,8 +2414,7 @@ void QuicTransportBase::scheduleAckTimeout() {
           std::chrono::duration_cast<std::chrono::microseconds>(
               wheelTimer.getTickInterval()),
           timeMin(kMaxAckTimeout, factoredRtt));
-      auto timeoutMs =
-          std::chrono::duration_cast<std::chrono::milliseconds>(timeout);
+      auto timeoutMs = folly::chrono::ceil<std::chrono::milliseconds>(timeout);
       VLOG(10) << __func__ << " timeout=" << timeoutMs.count() << "ms"
                << " factoredRtt=" << factoredRtt.count() << "us"
                << " " << *this;
@@ -2459,8 +2459,8 @@ void QuicTransportBase::schedulePathValidationTimeout() {
 
     auto validationTimeout =
         std::max(3 * pto, 6 * conn_->transportSettings.initialRtt);
-    auto timeoutMs = std::chrono::duration_cast<std::chrono::milliseconds>(
-        validationTimeout);
+    auto timeoutMs =
+        folly::chrono::ceil<std::chrono::milliseconds>(validationTimeout);
     VLOG(10) << __func__ << " timeout=" << timeoutMs.count() << "ms " << *this;
     getEventBase()->timer().scheduleTimeout(&pathValidationTimeout_, timeoutMs);
   }

quic/congestion_control/QuicCubic.cpp

@@ -11,6 +11,8 @@
 #include <quic/logging/QLoggerConstants.h>
 #include <quic/state/QuicStateFunctions.h>
 
+#include <folly/Chrono.h>
+
 namespace quic {
 
 Cubic::Cubic(
@@ -174,11 +176,11 @@ void Cubic::setAppIdle(bool idle, TimePoint eventTime) noexcept {
       cubic_appidle,
       conn_,
       idle,
-      std::chrono::duration_cast<std::chrono::milliseconds>(
+      folly::chrono::ceil<std::chrono::milliseconds>(
           eventTime.time_since_epoch())
           .count(),
       steadyState_.lastReductionTime
-          ? std::chrono::duration_cast<std::chrono::milliseconds>(
+          ? folly::chrono::ceil<std::chrono::milliseconds>(
                 steadyState_.lastReductionTime->time_since_epoch())
                 .count()
           : -1);
@@ -192,7 +194,7 @@ void Cubic::setAppIdle(bool idle, TimePoint eventTime) noexcept {
   if (!idle && currentAppIdle && *quiescenceStart_ <= eventTime &&
       steadyState_.lastReductionTime) {
     *steadyState_.lastReductionTime +=
-        std::chrono::duration_cast<std::chrono::milliseconds>(
+        folly::chrono::ceil<std::chrono::milliseconds>(
             eventTime - *quiescenceStart_);
   }
   if (!idle) {
@@ -261,7 +263,7 @@ int64_t Cubic::calculateCubicCwndDelta(TimePoint ackTime) noexcept {
     LOG(WARNING) << "Cubic ackTime earlier than reduction time";
     return 0;
   }
-  auto timeElapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+  auto timeElapsed = folly::chrono::ceil<std::chrono::milliseconds>(
       ackTime - *steadyState_.lastReductionTime);
   int64_t delta = 0;
   double timeElapsedCount = static_cast<double>(timeElapsed.count());

quic/loss/QuicLossFunctions.h

@@ -18,6 +18,7 @@
 #include <quic/state/SimpleFrameFunctions.h>
 #include <quic/state/StateData.h>
 
+#include <folly/Chrono.h>
 #include <folly/Overload.h>
 #include <folly/io/async/AsyncTimeout.h>
 
@@ -85,8 +86,7 @@ calculateAlarmDuration(const QuicConnectionStateBase& conn) {
   // The alarm duration is calculated based on the last packet that was sent
   // rather than the current time.
   if (lastSentPacketTime + alarmDuration > now) {
-    adjustedAlarmDuration =
-        std::chrono::duration_cast<std::chrono::milliseconds>(
+    adjustedAlarmDuration = folly::chrono::ceil<std::chrono::milliseconds>(
         lastSentPacketTime + alarmDuration - now);
   } else {
     auto lastSentPacketNum =

quic/loss/test/QuicLossFunctionsTest.cpp

@@ -1014,8 +1014,7 @@ TEST_F(QuicLossFunctionsTest, LossTimePreemptsCryptoTimer) {
   MockClock::mockNow = [=]() { return sendTime; };
   auto alarm = calculateAlarmDuration<MockClock>(*conn);
   EXPECT_EQ(
-      std::chrono::duration_cast<std::chrono::milliseconds>(
-          expectedDelayUntilLost),
+      folly::chrono::ceil<std::chrono::milliseconds>(expectedDelayUntilLost),
       alarm.first);
   EXPECT_EQ(LossState::AlarmMethod::EarlyRetransmitOrReordering, alarm.second);
   // Manual set lossState. Calling setLossDetectionAlarm requries a Timeout