Update from https://crrev.com/303153

net/tools/quic/quic_server_session_test.cc

 // Copyright 2013 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/tools/quic/quic_server_session.h"
 
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/source_address_token.h"
 #include "net/quic/quic_connection.h"
@@ skipping 61 matching lines @@
                                        kMaxStreamsForTest);
     config_.SetInitialFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     config_.SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
 
     connection_ =
         new StrictMock<MockConnection>(true, SupportedVersions(GetParam()));
-    session_.reset(new QuicServerSession(config_, connection_, &owner_));
+    session_.reset(new QuicServerSession(config_, connection_, &owner_,
+                                         /*is_secure=*/false));
     MockClock clock;
     handshake_message_.reset(crypto_config_.AddDefaultConfig(
         QuicRandom::GetInstance(), &clock,
         QuicCryptoServerConfig::ConfigOptions()));
     session_->InitializeSession(crypto_config_);
     visitor_ = QuicConnectionPeer::GetVisitor(connection_);
   }
 
   QuicVersion version() const { return connection_->version(); }
 
@@ skipping 29 matching lines @@
   // Open a stream, then reset it.
   // Send two bytes of payload to open it.
   QuicStreamFrame data1(kClientDataStreamId1, false, 0, MakeIOVector("HT"));
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
   session_->OnStreamFrames(frames);
   EXPECT_EQ(1u, session_->GetNumOpenStreams());
 
   // Send a reset (and expect the peer to send a RST in response).
   QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0);
-  EXPECT_CALL(*connection_, SendRstStream(kClientDataStreamId1,
-                                          QUIC_RST_FLOW_CONTROL_ACCOUNTING, 0));
+  EXPECT_CALL(*connection_,
+              SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst1);
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
 
   // Send the same two bytes of payload in a new packet.
   visitor_->OnStreamFrames(frames);
 
   // The stream should not be re-opened.
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionTest, NeverOpenStreamDueToReset) {
   // Send a reset (and expect the peer to send a RST in response).
   QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0);
-  EXPECT_CALL(*connection_, SendRstStream(kClientDataStreamId1,
-                                          QUIC_RST_FLOW_CONTROL_ACCOUNTING, 0));
+  EXPECT_CALL(*connection_,
+              SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst1);
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
 
   // Send two bytes of payload.
   QuicStreamFrame data1(kClientDataStreamId1, false, 0, MakeIOVector("HT"));
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
   visitor_->OnStreamFrames(frames);
 
   // The stream should never be opened, now that the reset is received.
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
   EXPECT_TRUE(connection_->connected());
 }
 
 TEST_P(QuicServerSessionTest, AcceptClosedStream) {
   vector<QuicStreamFrame> frames;
   // Send (empty) compressed headers followed by two bytes of data.
   frames.push_back(QuicStreamFrame(kClientDataStreamId1, false, 0,
                                    MakeIOVector("\1\0\0\0\0\0\0\0HT")));
   frames.push_back(QuicStreamFrame(kClientDataStreamId2, false, 0,
                                    MakeIOVector("\2\0\0\0\0\0\0\0HT")));
   visitor_->OnStreamFrames(frames);
   EXPECT_EQ(2u, session_->GetNumOpenStreams());
 
   // Send a reset (and expect the peer to send a RST in response).
   QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_NO_ERROR, 0);
-  EXPECT_CALL(*connection_, SendRstStream(kClientDataStreamId1,
-                                          QUIC_RST_FLOW_CONTROL_ACCOUNTING, 0));
+  EXPECT_CALL(*connection_,
+              SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0));
   visitor_->OnRstStream(rst);
 
   // If we were tracking, we'd probably want to reject this because it's data
   // past the reset point of stream 3.  As it's a closed stream we just drop the
   // data on the floor, but accept the packet because it has data for stream 5.
   frames.clear();
   frames.push_back(
       QuicStreamFrame(kClientDataStreamId1, false, 2, MakeIOVector("TP")));
   frames.push_back(
       QuicStreamFrame(kClientDataStreamId2, false, 2, MakeIOVector("TP")));
@@ skipping 110 matching lines @@
                void(const CachedNetworkParameters* cached_network_parameters));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockQuicCryptoServerStream);
 };
 
 TEST_P(QuicServerSessionTest, BandwidthEstimates) {
   if (version() <= QUIC_VERSION_21) {
     return;
   }
+
   // Test that bandwidth estimate updates are sent to the client, only after the
   // bandwidth estimate has changes sufficiently, and enough time has passed.
 
   int32 bandwidth_estimate_kbytes_per_second = 123;
   int32 max_bandwidth_estimate_kbytes_per_second = 134;
   int32 max_bandwidth_estimate_timestamp = 1122334455;
   const string serving_region = "not a real region";
   session_->set_serving_region(serving_region);
 
   MockQuicCryptoServerStream* crypto_stream =
       new MockQuicCryptoServerStream(crypto_config_, session_.get());
   QuicServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
 
   // Set some initial bandwidth values.
   QuicSentPacketManager* sent_packet_manager =
       QuicConnectionPeer::GetSentPacketManager(session_->connection());
   QuicSustainedBandwidthRecorder& bandwidth_recorder =
       QuicSentPacketManagerPeer::GetBandwidthRecorder(sent_packet_manager);
+  // Seed an rtt measurement equal to the initial default rtt.
+  RttStats* rtt_stats =
+      QuicSentPacketManagerPeer::GetRttStats(sent_packet_manager);
+  rtt_stats->UpdateRtt(QuicTime::Delta::FromMicroseconds(
+      rtt_stats->initial_rtt_us()), QuicTime::Delta::Zero(), QuicTime::Zero());
   QuicSustainedBandwidthRecorderPeer::SetBandwidthEstimate(
       &bandwidth_recorder, bandwidth_estimate_kbytes_per_second);
   QuicSustainedBandwidthRecorderPeer::SetMaxBandwidthEstimate(
       &bandwidth_recorder, max_bandwidth_estimate_kbytes_per_second,
       max_bandwidth_estimate_timestamp);
 
   // There will be no update sent yet - not enough time has passed.
   QuicTime now = QuicTime::Zero();
   session_->OnCongestionWindowChange(now);
 
   // Bandwidth estimate has now changed sufficiently but not enough time has
   // passed to send a Server Config Update.
   bandwidth_estimate_kbytes_per_second =
       bandwidth_estimate_kbytes_per_second * 1.6;
   session_->OnCongestionWindowChange(now);
 
   // Bandwidth estimate has now changed sufficiently and enough time has passed,
   // but not enough packets have been sent.
   int64 srtt_ms =
-      sent_packet_manager->GetRttStats()->SmoothedRtt().ToMilliseconds();
+      sent_packet_manager->GetRttStats()->smoothed_rtt().ToMilliseconds();
   now = now.Add(QuicTime::Delta::FromMilliseconds(
       kMinIntervalBetweenServerConfigUpdatesRTTs * srtt_ms));
   session_->OnCongestionWindowChange(now);
 
   // Bandwidth estimate has now changed sufficiently, enough time has passed,
   // and enough packets have been sent.
   QuicConnectionPeer::SetSequenceNumberOfLastSentPacket(
       session_->connection(), kMinPacketsBetweenServerConfigUpdates);
 
   // Verify that the proto has exactly the values we expect.
   CachedNetworkParameters expected_network_params;
   expected_network_params.set_bandwidth_estimate_bytes_per_second(
       bandwidth_recorder.BandwidthEstimate().ToBytesPerSecond());
   expected_network_params.set_max_bandwidth_estimate_bytes_per_second(
       bandwidth_recorder.MaxBandwidthEstimate().ToBytesPerSecond());
   expected_network_params.set_max_bandwidth_timestamp_seconds(
       bandwidth_recorder.MaxBandwidthTimestamp());
   expected_network_params.set_min_rtt_ms(session_->connection()
                                              ->sent_packet_manager()
                                              .GetRttStats()
-                                             ->MinRtt()
+                                             ->min_rtt()
                                              .ToMilliseconds());
   expected_network_params.set_previous_connection_state(
       CachedNetworkParameters::CONGESTION_AVOIDANCE);
   expected_network_params.set_timestamp(
       session_->connection()->clock()->WallNow().ToUNIXSeconds());
   expected_network_params.set_serving_region(serving_region);
 
   EXPECT_CALL(*crypto_stream,
               SendServerConfigUpdate(EqualsProto(expected_network_params)))
       .Times(1);
   session_->OnCongestionWindowChange(now);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net