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;
   }