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

net/quic/congestion_control/rtt_stats_test.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 <vector>
+
 #include "base/logging.h"
+#include "net/test/scoped_mock_log.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using logging::LOG_WARNING;
+using std::vector;
+using testing::HasSubstr;
+using testing::Message;
+using testing::_;
+
 namespace net {
 namespace test {
 
 class RttStatsPeer {
  public:
   static QuicTime::Delta GetHalfWindowRtt(const RttStats* rtt_stats) {
     return rtt_stats->half_window_rtt_.rtt;
   }
 
   static QuicTime::Delta GetQuarterWindowRtt(const RttStats* rtt_stats) {
     return rtt_stats->quarter_window_rtt_.rtt;
   }
 };
 
 class RttStatsTest : public ::testing::Test {
  protected:
   RttStats rtt_stats_;
 };
 
 TEST_F(RttStatsTest, DefaultsBeforeUpdate) {
   EXPECT_LT(0u, rtt_stats_.initial_rtt_us());
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us()),
             rtt_stats_.MinRtt());
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us()),
             rtt_stats_.SmoothedRtt());
 }
 
+TEST_F(RttStatsTest, SmoothedRtt) {
+  // Verify that ack_delay is corrected for in Smoothed RTT.
+  rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(300),
+                       QuicTime::Delta::FromMilliseconds(100),
+                       QuicTime::Zero());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.SmoothedRtt());
+  // Verify that effective RTT of zero does not change Smoothed RTT.
+  rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
+                       QuicTime::Delta::FromMilliseconds(200),
+                       QuicTime::Zero());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.SmoothedRtt());
+  // Verify that large erroneous ack_delay does not change Smoothed RTT.
+  rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
+                       QuicTime::Delta::FromMilliseconds(300),
+                       QuicTime::Zero());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.SmoothedRtt());
+}
+
 TEST_F(RttStatsTest, MinRtt) {
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
                        QuicTime::Delta::Zero(),
                        QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.MinRtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
             rtt_stats_.recent_min_rtt());
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(10),
                        QuicTime::Delta::Zero(),
                        QuicTime::Zero().Add(
@@ skipping 11 matching lines @@
                        QuicTime::Zero().Add(
                            QuicTime::Delta::FromMilliseconds(30)));
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(50),
                        QuicTime::Delta::Zero(),
                        QuicTime::Zero().Add(
                            QuicTime::Delta::FromMilliseconds(40)));
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
+  // Verify that ack_delay does not go into recording of min_rtt_.
+  rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(7),
+                       QuicTime::Delta::FromMilliseconds(2),
+                       QuicTime::Zero().Add(
+                           QuicTime::Delta::FromMilliseconds(50)));
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(7), rtt_stats_.MinRtt());
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(7), rtt_stats_.recent_min_rtt());
 }
 
 TEST_F(RttStatsTest, RecentMinRtt) {
   rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(10),
                        QuicTime::Delta::Zero(),
                        QuicTime::Zero());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
 
   rtt_stats_.SampleNewRecentMinRtt(4);
@@ skipping 104 matching lines @@
   EXPECT_EQ(initial_rtt.Multiply(0.875), rtt_stats_.mean_deviation());
 
   // Now go back down to 5ms and expire the smoothed metrics, and ensure the
   // mean deviation increases to 15ms.
   QuicTime::Delta half_rtt = initial_rtt.Multiply(0.5);
   rtt_stats_.UpdateRtt(half_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
   EXPECT_GT(doubled_rtt, rtt_stats_.SmoothedRtt());
   EXPECT_LT(initial_rtt, rtt_stats_.mean_deviation());
 }
 
+TEST_F(RttStatsTest, UpdateRttWithBadSendDeltas) {
+  // Make sure we ignore bad RTTs.
+  ScopedMockLog log;
+
+  QuicTime::Delta initial_rtt = QuicTime::Delta::FromMilliseconds(10);
+  rtt_stats_.UpdateRtt(initial_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
+  EXPECT_EQ(initial_rtt, rtt_stats_.MinRtt());
+  EXPECT_EQ(initial_rtt, rtt_stats_.recent_min_rtt());
+  EXPECT_EQ(initial_rtt, rtt_stats_.SmoothedRtt());
+
+  vector<QuicTime::Delta> bad_send_deltas;
+  bad_send_deltas.push_back(QuicTime::Delta::Zero());
+  bad_send_deltas.push_back(QuicTime::Delta::Infinite());
+  bad_send_deltas.push_back(QuicTime::Delta::FromMicroseconds(-1000));
+  log.StartCapturingLogs();
+
+  for (QuicTime::Delta bad_send_delta : bad_send_deltas) {
+    SCOPED_TRACE(Message() << "bad_send_delta = "
+                 << bad_send_delta.ToMicroseconds());
+    EXPECT_CALL(log, Log(LOG_WARNING, _,  _, _, HasSubstr("Ignoring")));
+    rtt_stats_.UpdateRtt(bad_send_delta,
+                         QuicTime::Delta::Zero(),
+                         QuicTime::Zero());
+    EXPECT_EQ(initial_rtt, rtt_stats_.MinRtt());
+    EXPECT_EQ(initial_rtt, rtt_stats_.recent_min_rtt());
+    EXPECT_EQ(initial_rtt, rtt_stats_.SmoothedRtt());
+  }
+}
+
 }  // namespace test
 }  // namespace net