Adding details to most quic connection close calls.

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/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_connection.h"
@@ skipping 214 matching lines @@
   // Open more streams: server should accept slightly more than the limit.
   for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) {
     EXPECT_TRUE(QuicServerSessionPeer::GetOrCreateDynamicStream(session_.get(),
                                                                 stream_id));
     stream_id += 2;
   }
 
   // Now violate the server's internal stream limit.
   stream_id += 2;
   if (connection_->version() <= QUIC_VERSION_27) {
-    EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
+    EXPECT_CALL(*connection_,
+                SendConnectionCloseWithDetails(QUIC_TOO_MANY_OPEN_STREAMS, _));
     EXPECT_CALL(*connection_, SendRstStream(_, _, _)).Times(0);
   } else {
-    EXPECT_CALL(*connection_, SendConnectionClose(_)).Times(0);
+    EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(_, _)).Times(0);
     EXPECT_CALL(*connection_, SendRstStream(stream_id, QUIC_REFUSED_STREAM, 0));
   }
   // Even if the connection remains open, the stream creation should fail.
   EXPECT_FALSE(QuicServerSessionPeer::GetOrCreateDynamicStream(session_.get(),
                                                                stream_id));
 }
 
 TEST_P(QuicServerSessionTest, MaxAvailableStreams) {
   // Test that the server closes the connection if a client makes too many data
   // streams available.  The server accepts slightly more than the negotiated
@@ skipping 13 matching lines @@
   EXPECT_TRUE(QuicServerSessionPeer::GetOrCreateDynamicStream(
       session_.get(), kClientDataStreamId1));
 
   // Establish available streams up to the server's limit.
   const int kLimitingStreamId =
       kClientDataStreamId1 + (kAvailableStreamLimit)*2 + 2;
   EXPECT_TRUE(QuicServerSessionPeer::GetOrCreateDynamicStream(
       session_.get(), kLimitingStreamId));
 
   // A further available stream will result in connection close.
-  EXPECT_CALL(*connection_,
-              SendConnectionClose(QUIC_TOO_MANY_AVAILABLE_STREAMS));
+  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_TOO_MANY_AVAILABLE_STREAMS, _));
   // This forces stream kLimitingStreamId + 2 to become available, which
   // violates the quota.
   EXPECT_FALSE(QuicServerSessionPeer::GetOrCreateDynamicStream(
       session_.get(), kLimitingStreamId + 4));
 }
 
 TEST_P(QuicServerSessionTest, GetEvenIncomingError) {
   // Incoming streams on the server session must be odd.
-  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
+  EXPECT_CALL(*connection_,
+              SendConnectionCloseWithDetails(QUIC_INVALID_STREAM_ID, _));
   EXPECT_EQ(nullptr,
             QuicServerSessionPeer::GetOrCreateDynamicStream(session_.get(), 4));
 }
 
 TEST_P(QuicServerSessionTest, GetStreamDisconnected) {
   // Don't create new streams if the connection is disconnected.
   QuicConnectionPeer::CloseConnection(connection_);
   EXPECT_DFATAL(
       QuicServerSessionPeer::GetOrCreateDynamicStream(session_.get(), 5),
       "ShouldCreateIncomingDynamicStream called when disconnected");
@@ skipping 259 matching lines @@
   // Create peer initiated stream should have no problem.
   QuicStreamFrame data2(kClientDataStreamId2, false, 0, StringPiece("HT"));
   session_->OnStreamFrame(data2);
   EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net