Change QuicStream::CloseConnectionWithDetails() to QuicStream::OnUnrecoverableError. The stream shouldn't be able to instruct the session on what to do. Instead, it should just report its state change and let the session handle it. gfe-relnote: name change only. Not protected. PiperOrigin-RevId: 294966339 Change-Id: Ibff2ed7169d0964ea5f19823445f5aa9ce8c5916
diff --git a/quic/core/http/quic_headers_stream.cc b/quic/core/http/quic_headers_stream.cc index 5b1a87b..1bac2b7 100644 --- a/quic/core/http/quic_headers_stream.cc +++ b/quic/core/http/quic_headers_stream.cc
@@ -85,8 +85,8 @@ if (header.unacked_length < header_length) { QUIC_BUG << "Unsent stream data is acked. unacked_length: " << header.unacked_length << " acked_length: " << header_length; - CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, - "Unsent stream data is acked"); + OnUnrecoverableError(QUIC_INTERNAL_ERROR, + "Unsent stream data is acked"); return false; } if (header.ack_listener != nullptr && header_length > 0) {
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc index ab7a55b..6e7389b 100644 --- a/quic/core/http/quic_receive_control_stream.cc +++ b/quic/core/http/quic_receive_control_stream.cc
@@ -26,13 +26,11 @@ HttpDecoderVisitor& operator=(const HttpDecoderVisitor&) = delete; void OnError(HttpDecoder* decoder) override { - stream_->session()->connection()->CloseConnection( - decoder->error(), decoder->error_detail(), - ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET); + stream_->OnUnrecoverableError(decoder->error(), decoder->error_detail()); } bool OnCancelPushFrame(const CancelPushFrame& /*frame*/) override { - CloseConnectionOnWrongFrame("Cancel Push"); + OnWrongFrame("Cancel Push"); return false; } @@ -41,13 +39,13 @@ stream_->spdy_session()->SetMaxAllowedPushId(frame.push_id); return true; } - CloseConnectionOnWrongFrame("Max Push Id"); + OnWrongFrame("Max Push Id"); return false; } bool OnGoAwayFrame(const GoAwayFrame& frame) override { if (stream_->spdy_session()->perspective() == Perspective::IS_SERVER) { - CloseConnectionOnWrongFrame("Go Away"); + OnWrongFrame("Go Away"); return false; } stream_->spdy_session()->OnHttp3GoAway(frame.stream_id); @@ -63,59 +61,59 @@ } bool OnDuplicatePushFrame(const DuplicatePushFrame& /*frame*/) override { - CloseConnectionOnWrongFrame("Duplicate Push"); + OnWrongFrame("Duplicate Push"); return false; } bool OnDataFrameStart(QuicByteCount /*header_length*/) override { - CloseConnectionOnWrongFrame("Data"); + OnWrongFrame("Data"); return false; } bool OnDataFramePayload(quiche::QuicheStringPiece /*payload*/) override { - CloseConnectionOnWrongFrame("Data"); + OnWrongFrame("Data"); return false; } bool OnDataFrameEnd() override { - CloseConnectionOnWrongFrame("Data"); + OnWrongFrame("Data"); return false; } bool OnHeadersFrameStart(QuicByteCount /*header_length*/) override { - CloseConnectionOnWrongFrame("Headers"); + OnWrongFrame("Headers"); return false; } bool OnHeadersFramePayload(quiche::QuicheStringPiece /*payload*/) override { - CloseConnectionOnWrongFrame("Headers"); + OnWrongFrame("Headers"); return false; } bool OnHeadersFrameEnd() override { - CloseConnectionOnWrongFrame("Headers"); + OnWrongFrame("Headers"); return false; } bool OnPushPromiseFrameStart(QuicByteCount /*header_length*/) override { - CloseConnectionOnWrongFrame("Push Promise"); + OnWrongFrame("Push Promise"); return false; } bool OnPushPromiseFramePushId(PushId /*push_id*/, QuicByteCount /*push_id_length*/) override { - CloseConnectionOnWrongFrame("Push Promise"); + OnWrongFrame("Push Promise"); return false; } bool OnPushPromiseFramePayload( quiche::QuicheStringPiece /*payload*/) override { - CloseConnectionOnWrongFrame("Push Promise"); + OnWrongFrame("Push Promise"); return false; } bool OnPushPromiseFrameEnd() override { - CloseConnectionOnWrongFrame("Push Promise"); + OnWrongFrame("Push Promise"); return false; } @@ -144,8 +142,8 @@ } private: - void CloseConnectionOnWrongFrame(quiche::QuicheStringPiece frame_type) { - stream_->CloseConnectionWithDetails( + void OnWrongFrame(quiche::QuicheStringPiece frame_type) { + stream_->OnUnrecoverableError( QUIC_HTTP_FRAME_UNEXPECTED_ON_CONTROL_STREAM, quiche::QuicheStrCat(frame_type, " frame received on control stream")); }
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc index 67234a9..8625dae 100644 --- a/quic/core/http/quic_spdy_stream.cc +++ b/quic/core/http/quic_spdy_stream.cc
@@ -41,8 +41,7 @@ HttpDecoderVisitor& operator=(const HttpDecoderVisitor&) = delete; void OnError(HttpDecoder* decoder) override { - stream_->CloseConnectionWithDetails(decoder->error(), - decoder->error_detail()); + stream_->OnUnrecoverableError(decoder->error(), decoder->error_detail()); } bool OnCancelPushFrame(const CancelPushFrame& /*frame*/) override { @@ -169,7 +168,7 @@ private: void CloseConnectionOnWrongFrame(quiche::QuicheStringPiece frame_type) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_HTTP_FRAME_UNEXPECTED_ON_SPDY_STREAM, quiche::QuicheStrCat(frame_type, " frame received on data stream")); } @@ -577,8 +576,8 @@ std::string connection_close_error_message = quiche::QuicheStrCat( "Error decoding ", headers_decompressed_ ? "trailers" : "headers", " on stream ", id(), ": ", error_message); - CloseConnectionWithDetails(QUIC_QPACK_DECOMPRESSION_FAILED, - connection_close_error_message); + OnUnrecoverableError(QUIC_QPACK_DECOMPRESSION_FAILED, + connection_close_error_message); } void QuicSpdyStream::MaybeSendPriorityUpdateFrame() { @@ -607,8 +606,8 @@ // or with H3_REQUEST_REJECTED (if server). std::string error_message = quiche::QuicheStrCat("Too large headers received on stream ", id()); - CloseConnectionWithDetails(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE, - error_message); + OnUnrecoverableError(QUIC_HEADERS_STREAM_DATA_DECOMPRESS_FAILURE, + error_message); } else { Reset(QUIC_HEADERS_TOO_LARGE); }
diff --git a/quic/core/quic_crypto_client_handshaker.cc b/quic/core/quic_crypto_client_handshaker.cc index 3614433..d9e67db 100644 --- a/quic/core/quic_crypto_client_handshaker.cc +++ b/quic/core/quic_crypto_client_handshaker.cc
@@ -83,7 +83,7 @@ QuicCryptoHandshaker::OnHandshakeMessage(message); if (message.tag() == kSCUP) { if (!one_rtt_keys_available()) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE, "Early SCUP disallowed"); return; @@ -98,9 +98,8 @@ // Do not process handshake messages after the handshake is confirmed. if (one_rtt_keys_available()) { - stream_->CloseConnectionWithDetails( - QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, - "Unexpected handshake message"); + stream_->OnUnrecoverableError(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, + "Unexpected handshake message"); return; } @@ -184,7 +183,7 @@ crypto_negotiated_params_, &error_details); if (error != QUIC_NO_ERROR) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( error, "Server config update invalid: " + error_details); return; } @@ -229,8 +228,8 @@ break; case STATE_IDLE: // This means that the peer sent us a message that we weren't expecting. - stream_->CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE, - "Handshake in idle state"); + stream_->OnUnrecoverableError(QUIC_INVALID_CRYPTO_MESSAGE_TYPE, + "Handshake in idle state"); return; case STATE_INITIALIZE_SCUP: DoInitializeServerConfigUpdate(cached); @@ -266,7 +265,7 @@ session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_INITIAL); encryption_established_ = false; if (num_client_hellos_ >= QuicCryptoClientStream::kMaxClientHellos) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_CRYPTO_TOO_MANY_REJECTS, quiche::QuicheStrCat("More than ", QuicCryptoClientStream::kMaxClientHellos, @@ -294,14 +293,13 @@ if (max_packet_size <= kFramingOverhead) { QUIC_DLOG(DFATAL) << "max_packet_length (" << max_packet_size << ") has no room for framing overhead."; - stream_->CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, - "max_packet_size too smalll"); + stream_->OnUnrecoverableError(QUIC_INTERNAL_ERROR, + "max_packet_size too smalll"); return; } if (kClientHelloMinimumSize > max_packet_size - kFramingOverhead) { QUIC_DLOG(DFATAL) << "Client hello won't fit in a single packet."; - stream_->CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, - "CHLO too large"); + stream_->OnUnrecoverableError(QUIC_INTERNAL_ERROR, "CHLO too large"); return; } next_state_ = STATE_RECV_REJ; @@ -324,7 +322,7 @@ // Flush the cached config so that, if it's bad, the server has a // chance to send us another in the future. cached->InvalidateServerConfig(); - stream_->CloseConnectionWithDetails(error, error_details); + stream_->OnUnrecoverableError(error, error_details); return; } chlo_hash_ = CryptoUtils::HashHandshakeMessage(out, Perspective::IS_CLIENT); @@ -358,8 +356,8 @@ // that we need. if (in->tag() != kREJ) { next_state_ = STATE_NONE; - stream_->CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE, - "Expected REJ"); + stream_->OnUnrecoverableError(QUIC_INVALID_CRYPTO_MESSAGE_TYPE, + "Expected REJ"); return; } @@ -397,7 +395,7 @@ if (error != QUIC_NO_ERROR) { next_state_ = STATE_NONE; - stream_->CloseConnectionWithDetails(error, error_details); + stream_->OnUnrecoverableError(error, error_details); return; } if (!cached->proof_valid()) { @@ -468,8 +466,8 @@ next_state_ = STATE_NONE; QUIC_CLIENT_HISTOGRAM_BOOL("QuicVerifyProofFailed.HandshakeConfirmed", one_rtt_keys_available(), ""); - stream_->CloseConnectionWithDetails( - QUIC_PROOF_INVALID, "Proof invalid: " + verify_error_details_); + stream_->OnUnrecoverableError(QUIC_PROOF_INVALID, + "Proof invalid: " + verify_error_details_); return; } @@ -501,8 +499,8 @@ // A reject message must be sent in ENCRYPTION_INITIAL. if (session()->connection()->last_decrypted_level() != ENCRYPTION_INITIAL) { // The rejection was sent encrypted! - stream_->CloseConnectionWithDetails( - QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT, "encrypted REJ message"); + stream_->OnUnrecoverableError(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT, + "encrypted REJ message"); return; } next_state_ = STATE_RECV_REJ; @@ -510,7 +508,7 @@ } if (in->tag() != kSHLO) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_INVALID_CRYPTO_MESSAGE_TYPE, quiche::QuicheStrCat("Expected SHLO or REJ. Received: ", QuicTagToString(in->tag()))); @@ -519,8 +517,8 @@ if (session()->connection()->last_decrypted_level() == ENCRYPTION_INITIAL) { // The server hello was sent without encryption. - stream_->CloseConnectionWithDetails(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT, - "unencrypted SHLO message"); + stream_->OnUnrecoverableError(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT, + "unencrypted SHLO message"); return; } @@ -532,14 +530,14 @@ crypto_negotiated_params_, &error_details); if (error != QUIC_NO_ERROR) { - stream_->CloseConnectionWithDetails( - error, "Server hello invalid: " + error_details); + stream_->OnUnrecoverableError(error, + "Server hello invalid: " + error_details); return; } error = session()->config()->ProcessPeerHello(*in, SERVER, &error_details); if (error != QUIC_NO_ERROR) { - stream_->CloseConnectionWithDetails( - error, "Server hello invalid: " + error_details); + stream_->OnUnrecoverableError(error, + "Server hello invalid: " + error_details); return; } session()->OnConfigNegotiated();
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc index 2f1f061..6150642 100644 --- a/quic/core/quic_crypto_server_handshaker.cc +++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -101,15 +101,14 @@ // Do not process handshake messages after the handshake is confirmed. if (one_rtt_keys_available_) { - stream_->CloseConnectionWithDetails( - QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, - "Unexpected handshake message from client"); + stream_->OnUnrecoverableError(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE, + "Unexpected handshake message from client"); return; } if (message.tag() != kCHLO) { - stream_->CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE, - "Handshake packet not CHLO"); + stream_->OnUnrecoverableError(QUIC_INVALID_CRYPTO_MESSAGE_TYPE, + "Handshake packet not CHLO"); return; } @@ -118,7 +117,7 @@ // Already processing some other handshake message. The protocol // does not allow for clients to send multiple handshake messages // before the server has a chance to respond. - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO, "Unexpected handshake message while processing CHLO"); return; @@ -167,7 +166,7 @@ const CryptoHandshakeMessage& message = result.client_hello; if (error != QUIC_NO_ERROR) { - stream_->CloseConnectionWithDetails(error, error_details); + stream_->OnUnrecoverableError(error, error_details); return; } @@ -187,7 +186,7 @@ const QuicErrorCode process_error = config->ProcessPeerHello(message, CLIENT, &process_error_details); if (process_error != QUIC_NO_ERROR) { - stream_->CloseConnectionWithDetails(process_error, process_error_details); + stream_->OnUnrecoverableError(process_error, process_error_details); return; }
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc index 6f92f3f..8e32448 100644 --- a/quic/core/quic_crypto_stream.cc +++ b/quic/core/quic_crypto_stream.cc
@@ -75,8 +75,8 @@ EncryptionLevel frame_level = level; if (substreams_[level].sequencer.NumBytesBuffered() > BufferSizeLimitForLevel(frame_level)) { - CloseConnectionWithDetails(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, - "Too much crypto data received"); + OnUnrecoverableError(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, + "Too much crypto data received"); } } @@ -84,8 +84,7 @@ if (QuicVersionUsesCryptoFrames(session()->transport_version())) { QUIC_PEER_BUG << "Crypto data received in stream frame instead of crypto frame"; - CloseConnectionWithDetails(QUIC_INVALID_STREAM_DATA, - "Unexpected stream frame"); + OnUnrecoverableError(QUIC_INVALID_STREAM_DATA, "Unexpected stream frame"); } QuicStream::OnStreamFrame(frame); } @@ -110,8 +109,8 @@ quiche::QuicheStringPiece data(static_cast<char*>(iov.iov_base), iov.iov_len); if (!crypto_message_parser()->ProcessInput(data, level)) { - CloseConnectionWithDetails(crypto_message_parser()->error(), - crypto_message_parser()->error_detail()); + OnUnrecoverableError(crypto_message_parser()->error(), + crypto_message_parser()->error_detail()); return; } sequencer->MarkConsumed(iov.iov_len); @@ -163,8 +162,8 @@ QUIC_BUG << "Writing too much crypto handshake data"; // TODO(nharper): Switch this to an IETF QUIC error code, possibly // INTERNAL_ERROR? - CloseConnectionWithDetails(QUIC_STREAM_LENGTH_OVERFLOW, - "Writing too much crypto handshake data"); + OnUnrecoverableError(QUIC_STREAM_LENGTH_OVERFLOW, + "Writing too much crypto handshake data"); } if (had_buffered_data) { // Do not try to write if there is buffered data. @@ -191,8 +190,8 @@ QuicByteCount newly_acked_length = 0; if (!substreams_[frame.level].send_buffer.OnStreamDataAcked( frame.offset, frame.data_length, &newly_acked_length)) { - CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, - "Trying to ack unsent crypto data."); + OnUnrecoverableError(QUIC_INTERNAL_ERROR, + "Trying to ack unsent crypto data."); return false; } return newly_acked_length > 0;
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc index 9d8407a..5331c37 100644 --- a/quic/core/quic_stream.cc +++ b/quic/core/quic_stream.cc
@@ -150,8 +150,8 @@ QUIC_NOTREACHED(); } -void PendingStream::CloseConnectionWithDetails(QuicErrorCode error, - const std::string& details) { +void PendingStream::OnUnrecoverableError(QuicErrorCode error, + const std::string& details) { stream_delegate_->OnStreamError(error, details); } @@ -174,14 +174,13 @@ QUIC_PEER_BUG << "Receive stream frame reaches max stream length. frame offset " << frame.offset << " length " << frame.data_length; - CloseConnectionWithDetails( - QUIC_STREAM_LENGTH_OVERFLOW, - "Peer sends more data than allowed on this stream."); + OnUnrecoverableError(QUIC_STREAM_LENGTH_OVERFLOW, + "Peer sends more data than allowed on this stream."); return; } if (frame.offset + frame.data_length > sequencer_.close_offset()) { - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_DATA_BEYOND_CLOSE_OFFSET, quiche::QuicheStrCat( "Stream ", id_, @@ -206,9 +205,8 @@ // violation of flow control. if (flow_controller_.FlowControlViolation() || connection_flow_controller_->FlowControlViolation()) { - CloseConnectionWithDetails( - QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, - "Flow control violation after increasing offset"); + OnUnrecoverableError(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, + "Flow control violation after increasing offset"); return; } } @@ -221,8 +219,8 @@ if (frame.byte_offset > kMaxStreamLength) { // Peer are not suppose to write bytes more than maxium allowed. - CloseConnectionWithDetails(QUIC_STREAM_LENGTH_OVERFLOW, - "Reset frame stream offset overflow."); + OnUnrecoverableError(QUIC_STREAM_LENGTH_OVERFLOW, + "Reset frame stream offset overflow."); return; } @@ -230,7 +228,7 @@ std::numeric_limits<QuicStreamOffset>::max(); if (sequencer()->close_offset() != kMaxOffset && frame.byte_offset != sequencer()->close_offset()) { - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_MULTIPLE_OFFSET, quiche::QuicheStrCat("Stream ", id_, " received new final offset: ", frame.byte_offset, @@ -242,9 +240,8 @@ MaybeIncreaseHighestReceivedOffset(frame.byte_offset); if (flow_controller_.FlowControlViolation() || connection_flow_controller_->FlowControlViolation()) { - CloseConnectionWithDetails( - QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, - "Flow control violation after increasing offset"); + OnUnrecoverableError(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, + "Flow control violation after increasing offset"); return; } } @@ -398,9 +395,8 @@ DCHECK(!(read_side_closed_ && write_side_closed_)); if (type_ == WRITE_UNIDIRECTIONAL) { - CloseConnectionWithDetails( - QUIC_DATA_RECEIVED_ON_WRITE_UNIDIRECTIONAL_STREAM, - "Data received on write unidirectional stream"); + OnUnrecoverableError(QUIC_DATA_RECEIVED_ON_WRITE_UNIDIRECTIONAL_STREAM, + "Data received on write unidirectional stream"); return; } @@ -413,7 +409,7 @@ << " reaches max stream length. frame offset " << frame.offset << " length " << frame.data_length << ". " << sequencer_.DebugString(); - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_LENGTH_OVERFLOW, quiche::QuicheStrCat("Peer sends more data than allowed on stream ", id_, ". frame: offset = ", frame.offset, @@ -423,7 +419,7 @@ } if (frame.offset + frame.data_length > sequencer_.close_offset()) { - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_DATA_BEYOND_CLOSE_OFFSET, quiche::QuicheStrCat( "Stream ", id_, @@ -459,9 +455,8 @@ // violation of flow control. if (flow_controller_->FlowControlViolation() || connection_flow_controller_->FlowControlViolation()) { - CloseConnectionWithDetails( - QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, - "Flow control violation after increasing offset"); + OnUnrecoverableError(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, + "Flow control violation after increasing offset"); return; } } @@ -481,8 +476,8 @@ rst_received_ = true; if (frame.byte_offset > kMaxStreamLength) { // Peer are not suppose to write bytes more than maxium allowed. - CloseConnectionWithDetails(QUIC_STREAM_LENGTH_OVERFLOW, - "Reset frame stream offset overflow."); + OnUnrecoverableError(QUIC_STREAM_LENGTH_OVERFLOW, + "Reset frame stream offset overflow."); return; } @@ -490,7 +485,7 @@ std::numeric_limits<QuicStreamOffset>::max(); if (sequencer()->close_offset() != kMaxOffset && frame.byte_offset != sequencer()->close_offset()) { - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_MULTIPLE_OFFSET, quiche::QuicheStrCat("Stream ", id_, " received new final offset: ", frame.byte_offset, @@ -502,9 +497,8 @@ MaybeIncreaseHighestReceivedOffset(frame.byte_offset); if (flow_controller_->FlowControlViolation() || connection_flow_controller_->FlowControlViolation()) { - CloseConnectionWithDetails( - QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, - "Flow control violation after increasing offset"); + OnUnrecoverableError(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, + "Flow control violation after increasing offset"); return; } @@ -549,8 +543,8 @@ rst_sent_ = true; } -void QuicStream::CloseConnectionWithDetails(QuicErrorCode error, - const std::string& details) { +void QuicStream::OnUnrecoverableError(QuicErrorCode error, + const std::string& details) { stream_delegate_->OnStreamError(error, details); } @@ -583,9 +577,8 @@ QUIC_DLOG(ERROR) << ENDPOINT << "Attempt to write when the write side is closed"; if (type_ == READ_UNIDIRECTIONAL) { - CloseConnectionWithDetails( - QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, - "Try to send data on read unidirectional stream"); + OnUnrecoverableError(QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, + "Try to send data on read unidirectional stream"); } return; } @@ -600,7 +593,7 @@ QuicStreamOffset offset = send_buffer_.stream_offset(); if (kMaxStreamLength - offset < data.length()) { QUIC_BUG << "Write too many data via stream " << id_; - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_LENGTH_OVERFLOW, quiche::QuicheStrCat("Write too many data via stream ", id_)); return; @@ -678,9 +671,8 @@ QUIC_DLOG(ERROR) << ENDPOINT << "Stream " << id() << " attempting to write when the write side is closed"; if (type_ == READ_UNIDIRECTIONAL) { - CloseConnectionWithDetails( - QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, - "Try to send data on read unidirectional stream"); + OnUnrecoverableError(QUIC_TRY_TO_WRITE_DATA_ON_READ_UNIDIRECTIONAL_STREAM, + "Try to send data on read unidirectional stream"); } return consumed_data; } @@ -695,7 +687,7 @@ if (offset > send_buffer_.stream_offset() || kMaxStreamLength < send_buffer_.stream_offset()) { QUIC_BUG << "Write too many data via stream " << id_; - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_STREAM_LENGTH_OVERFLOW, quiche::QuicheStrCat("Write too many data via stream ", id_)); return consumed_data; @@ -805,7 +797,7 @@ void QuicStream::OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) { if (type_ == READ_UNIDIRECTIONAL) { - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_WINDOW_UPDATE_RECEIVED_ON_READ_UNIDIRECTIONAL_STREAM, "WindowUpdateFrame received on READ_UNIDIRECTIONAL stream."); return; @@ -882,13 +874,11 @@ *newly_acked_length = 0; if (!send_buffer_.OnStreamDataAcked(offset, data_length, newly_acked_length)) { - CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, - "Trying to ack unsent data."); + OnUnrecoverableError(QUIC_INTERNAL_ERROR, "Trying to ack unsent data."); return false; } if (!fin_sent_ && fin_acked) { - CloseConnectionWithDetails(QUIC_INTERNAL_ERROR, - "Trying to ack unsent fin."); + OnUnrecoverableError(QUIC_INTERNAL_ERROR, "Trying to ack unsent fin."); return false; } // Indicates whether ack listener's OnPacketAcked should be called.
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h index 1d05292..c182031 100644 --- a/quic/core/quic_stream.h +++ b/quic/core/quic_stream.h
@@ -59,8 +59,8 @@ void OnFinRead() override; void AddBytesConsumed(QuicByteCount bytes) override; void Reset(QuicRstStreamErrorCode error) override; - void CloseConnectionWithDetails(QuicErrorCode error, - const std::string& details) override; + void OnUnrecoverableError(QuicErrorCode error, + const std::string& details) override; QuicStreamId id() const override; const QuicSocketAddress& PeerAddressOfLatestPacket() const override; @@ -155,8 +155,8 @@ // Called by the subclass or the sequencer to close the entire connection from // this end. - void CloseConnectionWithDetails(QuicErrorCode error, - const std::string& details) override; + void OnUnrecoverableError(QuicErrorCode error, + const std::string& details) override; // Get peer IP of the lastest packet which connection is dealing/delt with. const QuicSocketAddress& PeerAddressOfLatestPacket() const override;
diff --git a/quic/core/quic_stream_sequencer.cc b/quic/core/quic_stream_sequencer.cc index 79c2df7..c4c7f66 100644 --- a/quic/core/quic_stream_sequencer.cc +++ b/quic/core/quic_stream_sequencer.cc
@@ -74,7 +74,7 @@ "\nPeer Address: ", stream_->PeerAddressOfLatestPacket().ToString()); QUIC_LOG_FIRST_N(WARNING, 50) << QuicErrorCodeToString(result); QUIC_LOG_FIRST_N(WARNING, 50) << details; - stream_->CloseConnectionWithDetails(result, details); + stream_->OnUnrecoverableError(result, details); return; } @@ -117,7 +117,7 @@ // If there is a scheduled close, the new offset should match it. if (close_offset_ != kMaxOffset && offset != close_offset_) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_STREAM_SEQUENCER_INVALID_STATE, quiche::QuicheStrCat( "Stream ", stream_->id(), " received new final offset: ", offset, @@ -128,7 +128,7 @@ // The final offset should be no less than the highest offset that is // received. if (offset < highest_offset_) { - stream_->CloseConnectionWithDetails( + stream_->OnUnrecoverableError( QUIC_STREAM_SEQUENCER_INVALID_STATE, quiche::QuicheStrCat( "Stream ", stream_->id(), " received fin with offset: ", offset, @@ -197,7 +197,7 @@ if (read_error != QUIC_NO_ERROR) { std::string details = quiche::QuicheStrCat("Stream ", stream_->id(), ": ", error_details); - stream_->CloseConnectionWithDetails(read_error, details); + stream_->OnUnrecoverableError(read_error, details); return bytes_read; }
diff --git a/quic/core/quic_stream_sequencer.h b/quic/core/quic_stream_sequencer.h index 0733664..42b583f 100644 --- a/quic/core/quic_stream_sequencer.h +++ b/quic/core/quic_stream_sequencer.h
@@ -42,8 +42,8 @@ virtual void Reset(QuicRstStreamErrorCode error) = 0; // Called when an error has occurred which should result in the connection // being closed. - virtual void CloseConnectionWithDetails(QuicErrorCode error, - const std::string& details) = 0; + virtual void OnUnrecoverableError(QuicErrorCode error, + const std::string& details) = 0; // Returns the stream id of this stream. virtual QuicStreamId id() const = 0;
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc index 7cd498e..e2cd2ae 100644 --- a/quic/core/quic_stream_sequencer_test.cc +++ b/quic/core/quic_stream_sequencer_test.cc
@@ -33,7 +33,7 @@ public: MOCK_METHOD0(OnFinRead, void()); MOCK_METHOD0(OnDataAvailable, void()); - MOCK_METHOD2(CloseConnectionWithDetails, + MOCK_METHOD2(OnUnrecoverableError, void(QuicErrorCode error, const std::string& details)); MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error)); MOCK_METHOD0(OnCanWrite, void()); @@ -250,8 +250,7 @@ } TEST_F(QuicStreamSequencerTest, EmptyFrame) { - EXPECT_CALL(stream_, - CloseConnectionWithDetails(QUIC_EMPTY_STREAM_FRAME_NO_FIN, _)); + EXPECT_CALL(stream_, OnUnrecoverableError(QUIC_EMPTY_STREAM_FRAME_NO_FIN, _)); OnFrame(0, ""); EXPECT_EQ(0u, NumBufferedBytes()); EXPECT_EQ(0u, sequencer_->NumBytesConsumed()); @@ -375,7 +374,7 @@ OnFinFrame(3, ""); EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get())); - EXPECT_CALL(stream_, CloseConnectionWithDetails( + EXPECT_CALL(stream_, OnUnrecoverableError( QUIC_STREAM_SEQUENCER_INVALID_STATE, "Stream 1 received new final offset: 1, which is " "different from close offset: 3")); @@ -612,8 +611,7 @@ sequencer_->OnStreamFrame(frame1); QuicStreamFrame frame2(id, false, 2, quiche::QuicheStringPiece("hello")); - EXPECT_CALL(stream_, - CloseConnectionWithDetails(QUIC_OVERLAPPING_STREAM_DATA, _)) + EXPECT_CALL(stream_, OnUnrecoverableError(QUIC_OVERLAPPING_STREAM_DATA, _)) .Times(0); sequencer_->OnStreamFrame(frame2); } @@ -751,7 +749,7 @@ // Regression test for https://crbug.com/992486. TEST_F(QuicStreamSequencerTest, CorruptFinFrames) { - EXPECT_CALL(stream_, CloseConnectionWithDetails( + EXPECT_CALL(stream_, OnUnrecoverableError( QUIC_STREAM_SEQUENCER_INVALID_STATE, "Stream 1 received new final offset: 1, which is " "different from close offset: 2")); @@ -764,7 +762,7 @@ // Regression test for crbug.com/1015693 TEST_F(QuicStreamSequencerTest, ReceiveFinLessThanHighestOffset) { EXPECT_CALL(stream_, OnDataAvailable()).Times(1); - EXPECT_CALL(stream_, CloseConnectionWithDetails( + EXPECT_CALL(stream_, OnUnrecoverableError( QUIC_STREAM_SEQUENCER_INVALID_STATE, "Stream 1 received fin with offset: 0, which " "reduces current highest offset: 3"));
diff --git a/quic/core/tls_client_handshaker.cc b/quic/core/tls_client_handshaker.cc index 350a9ae..6f0bc4d 100644 --- a/quic/core/tls_client_handshaker.cc +++ b/quic/core/tls_client_handshaker.cc
@@ -340,7 +340,7 @@ const std::string& reason_phrase) { DCHECK(!reason_phrase.empty()); state_ = STATE_CONNECTION_CLOSED; - stream()->CloseConnectionWithDetails(error, reason_phrase); + stream()->OnUnrecoverableError(error, reason_phrase); } void TlsClientHandshaker::FinishHandshake() {
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc index 03a899f..59570b1 100644 --- a/quic/core/tls_handshaker_test.cc +++ b/quic/core/tls_handshaker_test.cc
@@ -207,9 +207,8 @@ for (size_t i = 0; i < pending_writes_.size(); ++i) { if (!stream->crypto_message_parser()->ProcessInput( pending_writes_[i].first, pending_writes_[i].second)) { - CloseConnectionWithDetails( - stream->crypto_message_parser()->error(), - stream->crypto_message_parser()->error_detail()); + OnUnrecoverableError(stream->crypto_message_parser()->error(), + stream->crypto_message_parser()->error_detail()); break; } }
diff --git a/quic/core/tls_server_handshaker.cc b/quic/core/tls_server_handshaker.cc index 3a99875..e5587cd 100644 --- a/quic/core/tls_server_handshaker.cc +++ b/quic/core/tls_server_handshaker.cc
@@ -202,7 +202,7 @@ void TlsServerHandshaker::CloseConnection(QuicErrorCode error, const std::string& reason_phrase) { state_ = STATE_CONNECTION_CLOSED; - stream()->CloseConnectionWithDetails(error, reason_phrase); + stream()->OnUnrecoverableError(error, reason_phrase); } bool TlsServerHandshaker::ProcessTransportParameters(
diff --git a/quic/quic_transport/quic_transport_stream.cc b/quic/quic_transport/quic_transport_stream.cc index 2852442..2824771 100644 --- a/quic/quic_transport/quic_transport_stream.cc +++ b/quic/quic_transport/quic_transport_stream.cc
@@ -78,7 +78,7 @@ QUIC_BUG << "WriteMemSlices() unexpectedly partially consumed the input " "data, provided: " << data.size() << ", written: " << consumed.bytes_consumed; - CloseConnectionWithDetails( + OnUnrecoverableError( QUIC_INTERNAL_ERROR, "WriteMemSlices() unexpectedly partially consumed the input data"); return false;
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc index 05a7310..a6775cc 100644 --- a/quic/tools/quic_simple_server_stream.cc +++ b/quic/tools/quic_simple_server_stream.cc
@@ -183,7 +183,7 @@ if (response->response_type() == QuicBackendResponse::CLOSE_CONNECTION) { QUIC_DVLOG(1) << "Special response: closing connection."; - CloseConnectionWithDetails(QUIC_NO_ERROR, "Toy server forcing close"); + OnUnrecoverableError(QUIC_NO_ERROR, "Toy server forcing close"); return; }