Update from chromium https://crrev.com/302282

net/quic/congestion_control/rtt_stats.cc

 // Copyright 2014 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.
 
 #include "net/quic/congestion_control/rtt_stats.h"
 
 #include <complex>  // std::abs
 
 using std::max;
 
@@ skipping 35 matching lines @@
       max(mean_deviation_,
           QuicTime::Delta::FromMicroseconds(
               std::abs(smoothed_rtt_.Subtract(latest_rtt_).ToMicroseconds())));
   smoothed_rtt_ = max(smoothed_rtt_, latest_rtt_);
 }
 
 // Updates the RTT based on a new sample.
 void RttStats::UpdateRtt(QuicTime::Delta send_delta,
                          QuicTime::Delta ack_delay,
                          QuicTime now) {
-  QuicTime::Delta rtt_sample(QuicTime::Delta::Zero());
-  if (send_delta > ack_delay) {
-    rtt_sample = send_delta.Subtract(ack_delay);
-  } else if (!HasUpdates()) {
-    // Even though we received information from the peer suggesting
-    // an invalid (negative) RTT, we can use the send delta as an
-    // approximation until we get a better estimate.
-    rtt_sample = send_delta;
+  if (send_delta.IsInfinite() || send_delta <= QuicTime::Delta::Zero()) {
+    LOG(WARNING) << "Ignoring measured send_delta, because it's is "
+                 << "either infinite, zero, or negative.  send_delta = "
+                 << send_delta.ToMicroseconds();
+    return;
   }
 
-  if (rtt_sample.IsInfinite() || rtt_sample.IsZero()) {
-    DVLOG(1) << "Ignoring rtt, because it's "
-             << (rtt_sample.IsZero() ? "Zero" : "Infinite");
-    return;
+  // Update min_rtt_ first. min_rtt_ does not use an rtt_sample corrected for
+  // ack_delay but the raw observed send_delta, since poor clock granularity at
+  // the client may cause a high ack_delay to result in underestimation of the
+  // min_rtt_.
+  if (min_rtt_.IsZero() || min_rtt_ > send_delta) {
+    min_rtt_ = send_delta;
   }
-  // RTT can't be non-positive.
-  DCHECK_LT(0, rtt_sample.ToMicroseconds());
+  UpdateRecentMinRtt(send_delta, now);
 
+  // Correct for ack_delay if information received from the peer results in a
+  // positive RTT sample. Otherwise, we use the send_delta as a reasonable
+  // measure for smoothed_rtt.
+  QuicTime::Delta rtt_sample(send_delta);
+  if (rtt_sample > ack_delay) {
+    rtt_sample = rtt_sample.Subtract(ack_delay);
+  }
   latest_rtt_ = rtt_sample;
-  // First time call or link delay decreases.
-  if (min_rtt_.IsZero() || min_rtt_ > rtt_sample) {
-    min_rtt_ = rtt_sample;
-  }
-  UpdateRecentMinRtt(rtt_sample, now);
   // First time call.
   if (!HasUpdates()) {
     smoothed_rtt_ = rtt_sample;
     mean_deviation_ = QuicTime::Delta::FromMicroseconds(
         rtt_sample.ToMicroseconds() / 2);
   } else {
     mean_deviation_ = QuicTime::Delta::FromMicroseconds(
         kOneMinusBeta * mean_deviation_.ToMicroseconds() +
         kBeta * std::abs(smoothed_rtt_.Subtract(rtt_sample).ToMicroseconds()));
     smoothed_rtt_ = smoothed_rtt_.Multiply(kOneMinusAlpha).Add(
@@ skipping 49 matching lines @@
 }
 
 QuicTime::Delta RttStats::MinRtt() const {
   if (!HasUpdates()) {
     return QuicTime::Delta::FromMicroseconds(initial_rtt_us_);
   }
   return min_rtt_;
 }
 
 }  // namespace net