Update from https://crrev.com/307330

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/cached_network_parameters.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.h"
@@ skipping 19 matching lines @@
 using net::test::QuicDataStreamPeer;
 using net::test::QuicSentPacketManagerPeer;
 using net::test::QuicSessionPeer;
 using net::test::QuicSustainedBandwidthRecorderPeer;
 using net::test::SupportedVersions;
 using net::test::ValueRestore;
 using net::test::kClientDataStreamId1;
 using net::test::kClientDataStreamId2;
 using net::test::kClientDataStreamId3;
 using net::test::kClientDataStreamId4;
+using std::string;
 using testing::StrictMock;
 using testing::_;
 
 namespace net {
 namespace tools {
 namespace test {
 
 class QuicServerSessionPeer {
  public:
   static QuicDataStream* GetIncomingDataStream(
@@ skipping 248 matching lines @@
  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.
+  // bandwidth estimate has changes sufficiently, and enough time has passed,
+  // and we don't have any other data to write.
 
   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);
+  // Queue up some pending data.
+  session_->MarkWriteBlocked(kCryptoStreamId,
+                             QuicWriteBlockedList::kHighestPriority);
+  EXPECT_TRUE(session_->HasDataToWrite());
 
   // 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()->smoothed_rtt().ToMilliseconds();
   now = now.Add(QuicTime::Delta::FromMilliseconds(
       kMinIntervalBetweenServerConfigUpdatesRTTs * srtt_ms));
   session_->OnCongestionWindowChange(now);
 
+  // The connection no longer has pending data to be written.
+  session_->OnCanWrite();
+  EXPECT_FALSE(session_->HasDataToWrite());
+  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(
@@ skipping 54 matching lines @@
   cached_network_params.set_serving_region(kTestServingRegion);
   crypto_stream->set_previous_cached_network_params(cached_network_params);
   EXPECT_CALL(*connection_, ResumeConnectionState(_)).Times(1);
   session_->OnConfigNegotiated();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net