Adding details to most quic connection close calls.

net/quic/quic_spdy_stream_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/quic/quic_spdy_stream.h"
 
 #include "base/strings/string_number_conversions.h"
 
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_utils.h"
@@ skipping 518 matching lines @@
                                                  kWindow);
 
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   // Receive data to overflow the window, violating flow control.
   string body;
   GenerateBody(&body, kWindow + 1);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
-  EXPECT_CALL(*connection_,
-              SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA));
+  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_P(QuicSpdyStreamTest, TestHandlingQuicRstStreamNoError) {
   Initialize(kShouldProcessData);
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   if (GetParam() <= QUIC_VERSION_28) {
@@ skipping 29 matching lines @@
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   // Send enough data to overflow the connection level flow control window.
   string body;
   GenerateBody(&body, kConnectionWindow + 1);
   EXPECT_LT(body.size(), kStreamWindow);
   QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
 
-  EXPECT_CALL(*connection_,
-              SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA));
+  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _));
   stream_->OnStreamFrame(frame);
 }
 
 TEST_P(QuicSpdyStreamTest, StreamFlowControlFinNotBlocked) {
   // An attempt to write a FIN with no data should not be flow control blocked,
   // even if the send window is 0.
 
   Initialize(kShouldProcessData);
 
   // Set a flow control limit of zero.
@@ skipping 51 matching lines @@
   // Receive initial headers.
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(false, headers.size());
 
   // Receive trailing headers with FIN deliberately set to false.
   SpdyHeaderBlock trailers_block;
   string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
   stream_->OnStreamHeaders(trailers);
 
-  EXPECT_CALL(*connection_,
-              SendConnectionClose(QUIC_INVALID_HEADERS_STREAM_DATA))
+  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_INVALID_HEADERS_STREAM_DATA, _))
       .Times(1);
   stream_->OnStreamHeadersComplete(/*fin=*/false, trailers.size());
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterFin) {
   // If Trailers are sent, neither Headers nor Body should contain a FIN.
   ValueRestore<bool> old_flag(&FLAGS_quic_supports_trailers, true);
   Initialize(kShouldProcessData);
 
   // Receive initial headers with FIN set.
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(/*fin=*/true, headers.size());
 
   // Receive trailing headers after FIN already received.
   SpdyHeaderBlock trailers_block;
   string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
   stream_->OnStreamHeaders(trailers);
 
-  EXPECT_CALL(*connection_,
-              SendConnectionClose(QUIC_INVALID_HEADERS_STREAM_DATA))
+  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_INVALID_HEADERS_STREAM_DATA, _))
       .Times(1);
   stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
 }
 
 TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterBodyWithFin) {
   // If body data are received with a FIN, no trailers should then arrive.
   ValueRestore<bool> old_flag(&FLAGS_quic_supports_trailers, true);
   Initialize(kShouldProcessData);
 
   // Receive initial headers without FIN set.
   string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
   stream_->OnStreamHeaders(headers);
   stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size());
 
   // Receive body data, with FIN.
   QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/true, 0, "body");
   stream_->OnStreamFrame(frame);
 
   // Receive trailing headers after FIN already received.
   SpdyHeaderBlock trailers_block;
   string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
   stream_->OnStreamHeaders(trailers);
 
-  EXPECT_CALL(*connection_,
-              SendConnectionClose(QUIC_INVALID_HEADERS_STREAM_DATA))
+  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
+                                QUIC_INVALID_HEADERS_STREAM_DATA, _))
       .Times(1);
   stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
 }
 
 TEST_P(QuicSpdyStreamTest, ClosingStreamWithNoTrailers) {
   // Verify that a stream receiving headers, body, and no trailers is correctly
   // marked as done reading on consumption of headers and body.
   ValueRestore<bool> old_flag(&FLAGS_quic_supports_trailers, true);
   Initialize(kShouldProcessData);
 
@@ skipping 131 matching lines @@
 
   // Writing Trailers should fail, as the FIN has already been sent.
   // populated with the number of body bytes written.
   EXPECT_DFATAL(stream_->WriteTrailers(SpdyHeaderBlock(), nullptr),
                 "Trailers cannot be sent after a FIN");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net