@fails-components/webtransport 0.0.1-rc.0 → 0.0.1-rc.1

package/third_party/quiche/quiche/quic/core/quic_crypto_client_handshaker.cc

@@ -11,9 +11,11 @@
 #include "quiche/quic/core/crypto/crypto_protocol.h"
 #include "quiche/quic/core/crypto/crypto_utils.h"
 #include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_client_stats.h"
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
 
@@ -149,6 +151,16 @@ bool QuicCryptoClientHandshaker::IsCryptoFrameExpectedForEncryptionLevel(
   return true;
 }
 
+EncryptionLevel
+QuicCryptoClientHandshaker::GetEncryptionLevelToSendCryptoDataOfSpace(
+    PacketNumberSpace space) const {
+  if (space == INITIAL_DATA) {
+    return ENCRYPTION_INITIAL;
+  }
+  QUICHE_DCHECK(false);
+  return NUM_ENCRYPTION_LEVELS;
+}
+
 bool QuicCryptoClientHandshaker::one_rtt_keys_available() const {
   return one_rtt_keys_available_;
 }
@@ -263,7 +275,7 @@ void QuicCryptoClientHandshaker::DoHandshakeLoop(
         DoInitializeServerConfigUpdate(cached);
         break;
       case STATE_NONE:
-        QUIC_NOTREACHED();
+        QUICHE_NOTREACHED();
         return;
       case STATE_CONNECTION_CLOSED:
         rv = QUIC_FAILURE;

package/third_party/quiche/quiche/quic/core/quic_crypto_client_handshaker.h

@@ -11,6 +11,7 @@
 #include "quiche/quic/core/crypto/quic_crypto_client_config.h"
 #include "quiche/quic/core/quic_crypto_client_stream.h"
 #include "quiche/quic/core/quic_server_id.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 
@@ -45,6 +46,8 @@ class QUIC_EXPORT_PRIVATE QuicCryptoClientHandshaker
   bool encryption_established() const override;
   bool IsCryptoFrameExpectedForEncryptionLevel(
       EncryptionLevel level) const override;
+  EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const override;
   bool one_rtt_keys_available() const override;
   const QuicCryptoNegotiatedParameters& crypto_negotiated_params()
       const override;

package/third_party/quiche/quiche/quic/core/quic_crypto_client_handshaker_test.cc

@@ -11,7 +11,7 @@
 #include "quiche/quic/platform/api/quic_test.h"
 #include "quiche/quic/test_tools/quic_test_utils.h"
 
-namespace quic {
+namespace quic::test {
 namespace {
 
 class TestProofHandler : public QuicCryptoClientStream::ProofHandler {
@@ -214,4 +214,4 @@ TEST_P(QuicCryptoClientHandshakerTest, TestNoPaddingInFullHelloWhenDisabled) {
 }
 
 }  // namespace
-}  // namespace quic
+}  // namespace quic::test

package/third_party/quiche/quiche/quic/core/quic_crypto_client_stream.cc

@@ -169,4 +169,10 @@ bool QuicCryptoClientStream::IsCryptoFrameExpectedForEncryptionLevel(
   return handshaker_->IsCryptoFrameExpectedForEncryptionLevel(level);
 }
 
+EncryptionLevel
+QuicCryptoClientStream::GetEncryptionLevelToSendCryptoDataOfSpace(
+    PacketNumberSpace space) const {
+  return handshaker_->GetEncryptionLevelToSendCryptoDataOfSpace(space);
+}
+
 }  // namespace quic

package/third_party/quiche/quiche/quic/core/quic_crypto_client_stream.h

@@ -17,6 +17,7 @@
 #include "quiche/quic/core/quic_crypto_stream.h"
 #include "quiche/quic/core/quic_server_id.h"
 #include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_versions.h"
 #include "quiche/quic/platform/api/quic_export.h"
 
@@ -173,6 +174,10 @@ class QUIC_EXPORT_PRIVATE QuicCryptoClientStream
     virtual bool IsCryptoFrameExpectedForEncryptionLevel(
         EncryptionLevel level) const = 0;
 
+    // Returns the encryption level to send CRYPTO_FRAME for `space`.
+    virtual EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+        PacketNumberSpace space) const = 0;
+
     // Returns true once 1RTT keys are available.
     virtual bool one_rtt_keys_available() const = 0;
 
@@ -289,6 +294,9 @@ class QUIC_EXPORT_PRIVATE QuicCryptoClientStream
   SSL* GetSsl() const override;
   bool IsCryptoFrameExpectedForEncryptionLevel(
       EncryptionLevel level) const override;
+  EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const override;
+
   bool ExportKeyingMaterial(absl::string_view label, absl::string_view context,
                             size_t result_len, std::string* result) override;
   std::string chlo_hash() const;

package/third_party/quiche/quiche/quic/core/quic_crypto_server_stream.cc

@@ -10,6 +10,7 @@
 #include "absl/base/macros.h"
 #include "absl/strings/string_view.h"
 #include "openssl/sha.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_flag_utils.h"
 #include "quiche/quic/platform/api/quic_testvalue.h"
 #include "quiche/common/platform/api/quiche_logging.h"
@@ -68,7 +69,6 @@ QuicCryptoServerStream::QuicCryptoServerStream(
       zero_rtt_attempted_(false),
       chlo_packet_size_(0),
       validate_client_hello_cb_(nullptr),
-      process_client_hello_cb_(nullptr),
       encryption_established_(false),
       one_rtt_keys_available_(false),
       one_rtt_packet_decrypted_(false),
@@ -88,9 +88,10 @@ void QuicCryptoServerStream::CancelOutstandingCallbacks() {
     send_server_config_update_cb_->Cancel();
     send_server_config_update_cb_ = nullptr;
   }
-  if (process_client_hello_cb_ != nullptr) {
-    process_client_hello_cb_->Cancel();
-    process_client_hello_cb_ = nullptr;
+  if (std::shared_ptr<ProcessClientHelloCallback> cb =
+          process_client_hello_cb_.lock()) {
+    cb->Cancel();
+    process_client_hello_cb_.reset();
   }
 }
 
@@ -114,7 +115,7 @@ void QuicCryptoServerStream::OnHandshakeMessage(
   }
 
   if (validate_client_hello_cb_ != nullptr ||
-      process_client_hello_cb_ != nullptr) {
+      !process_client_hello_cb_.expired()) {
     // 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.
@@ -128,7 +129,7 @@ void QuicCryptoServerStream::OnHandshakeMessage(
 
   std::unique_ptr<ValidateCallback> cb(new ValidateCallback(this));
   QUICHE_DCHECK(validate_client_hello_cb_ == nullptr);
-  QUICHE_DCHECK(process_client_hello_cb_ == nullptr);
+  QUICHE_DCHECK(process_client_hello_cb_.expired());
   validate_client_hello_cb_ = cb.get();
   crypto_config_->ValidateClientHello(
       message, GetClientAddress(), session()->connection()->self_address(),
@@ -143,12 +144,11 @@ void QuicCryptoServerStream::FinishProcessingHandshakeMessage(
     std::unique_ptr<ProofSource::Details> details) {
   // Clear the callback that got us here.
   QUICHE_DCHECK(validate_client_hello_cb_ != nullptr);
-  QUICHE_DCHECK(process_client_hello_cb_ == nullptr);
+  QUICHE_DCHECK(process_client_hello_cb_.expired());
   validate_client_hello_cb_ = nullptr;
 
-  std::unique_ptr<ProcessClientHelloCallback> cb(
-      new ProcessClientHelloCallback(this, result));
-  process_client_hello_cb_ = cb.get();
+  auto cb = std::make_shared<ProcessClientHelloCallback>(this, result);
+  process_client_hello_cb_ = cb;
   ProcessClientHello(result, std::move(details), std::move(cb));
 }
 
@@ -160,9 +160,9 @@ void QuicCryptoServerStream::
         std::unique_ptr<DiversificationNonce> diversification_nonce,
         std::unique_ptr<ProofSource::Details> proof_source_details) {
   // Clear the callback that got us here.
-  QUICHE_DCHECK(process_client_hello_cb_ != nullptr);
+  QUICHE_DCHECK(!process_client_hello_cb_.expired());
   QUICHE_DCHECK(validate_client_hello_cb_ == nullptr);
-  process_client_hello_cb_ = nullptr;
+  process_client_hello_cb_.reset();
   proof_source_details_ = std::move(proof_source_details);
 
   AdjustTestValue("quic::QuicCryptoServerStream::after_process_client_hello",
@@ -456,7 +456,7 @@ void QuicCryptoServerStream::ProcessClientHello(
         ValidateClientHelloResultCallback::Result>
         result,
     std::unique_ptr<ProofSource::Details> proof_source_details,
-    std::unique_ptr<ProcessClientHelloResultCallback> done_cb) {
+    std::shared_ptr<ProcessClientHelloResultCallback> done_cb) {
   proof_source_details_ = std::move(proof_source_details);
   const CryptoHandshakeMessage& message = result->client_hello;
   std::string error_details;
@@ -532,4 +532,17 @@ bool QuicCryptoServerStream::IsCryptoFrameExpectedForEncryptionLevel(
   return true;
 }
 
+EncryptionLevel
+QuicCryptoServerStream::GetEncryptionLevelToSendCryptoDataOfSpace(
+    PacketNumberSpace space) const {
+  if (space == INITIAL_DATA) {
+    return ENCRYPTION_INITIAL;
+  }
+  if (space == APPLICATION_DATA) {
+    return ENCRYPTION_ZERO_RTT;
+  }
+  QUICHE_DCHECK(false);
+  return NUM_ENCRYPTION_LEVELS;
+}
+
 }  // namespace quic

package/third_party/quiche/quiche/quic/core/quic_crypto_server_stream.h

@@ -12,6 +12,7 @@
 #include "quiche/quic/core/quic_crypto_handshaker.h"
 #include "quiche/quic/core/quic_crypto_server_stream_base.h"
 #include "quiche/quic/core/quic_session.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/platform/api/quic_export.h"
 
 namespace quic {
@@ -74,6 +75,8 @@ class QUIC_EXPORT_PRIVATE QuicCryptoServerStream
   SSL* GetSsl() const override;
   bool IsCryptoFrameExpectedForEncryptionLevel(
       EncryptionLevel level) const override;
+  EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const override;
 
   // From QuicCryptoHandshaker
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
@@ -98,7 +101,7 @@ class QUIC_EXPORT_PRIVATE QuicCryptoServerStream
           ValidateClientHelloResultCallback::Result>
           result,
       std::unique_ptr<ProofSource::Details> proof_source_details,
-      std::unique_ptr<ProcessClientHelloResultCallback> done_cb);
+      std::shared_ptr<ProcessClientHelloResultCallback> done_cb);
 
   // Hook that allows the server to set QuicConfig defaults just
   // before going through the parameter negotiation step.
@@ -251,7 +254,7 @@ class QUIC_EXPORT_PRIVATE QuicCryptoServerStream
   // ProcessClientHello and forward it to
   // FinishProcessingHandshakeMessageAfterProcessClientHello.  Note that this
   // field is mutually exclusive with validate_client_hello_cb_.
-  ProcessClientHelloCallback* process_client_hello_cb_;
+  std::weak_ptr<ProcessClientHelloCallback> process_client_hello_cb_;
 
   // The ProofSource::Details from this connection.
   std::unique_ptr<ProofSource::Details> proof_source_details_;

package/third_party/quiche/quiche/quic/core/quic_crypto_stream.cc

@@ -37,10 +37,7 @@ QuicCryptoStream::QuicCryptoStream(QuicSession* session)
           QuicVersionUsesCryptoFrames(session->transport_version())
               ? CRYPTO
               : BIDIRECTIONAL),
-      substreams_{{{this, ENCRYPTION_INITIAL},
-                   {this, ENCRYPTION_HANDSHAKE},
-                   {this, ENCRYPTION_ZERO_RTT},
-                   {this, ENCRYPTION_FORWARD_SECURE}}} {
+      substreams_{{{this}, {this}, {this}}} {
   // The crypto stream is exempt from connection level flow control.
   DisableConnectionFlowControlForThisStream();
 }
@@ -82,9 +79,11 @@ void QuicCryptoStream::OnCryptoFrame(const QuicCryptoFrame& frame) {
         absl::StrCat("CRYPTO_FRAME is unexpectedly received at level ", level));
     return;
   }
-  substreams_[level].sequencer.OnCryptoFrame(frame);
+  CryptoSubstream& substream =
+      substreams_[QuicUtils::GetPacketNumberSpace(level)];
+  substream.sequencer.OnCryptoFrame(frame);
   EncryptionLevel frame_level = level;
-  if (substreams_[level].sequencer.NumBytesBuffered() >
+  if (substream.sequencer.NumBytesBuffered() >
       BufferSizeLimitForLevel(frame_level)) {
     OnUnrecoverableError(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA,
                          "Too much crypto data received");
@@ -109,7 +108,8 @@ void QuicCryptoStream::OnDataAvailable() {
     OnDataAvailableInSequencer(sequencer(), level);
     return;
   }
-  OnDataAvailableInSequencer(&substreams_[level].sequencer, level);
+  OnDataAvailableInSequencer(
+      &substreams_[QuicUtils::GetPacketNumberSpace(level)].sequencer, level);
 }
 
 void QuicCryptoStream::OnDataAvailableInSequencer(
@@ -146,7 +146,8 @@ void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
   }
   const bool had_buffered_data = HasBufferedCryptoFrames();
   // Append |data| to the send buffer for this encryption level.
-  QuicStreamSendBuffer* send_buffer = &substreams_[level].send_buffer;
+  QuicStreamSendBuffer* send_buffer =
+      &substreams_[QuicUtils::GetPacketNumberSpace(level)].send_buffer;
   QuicStreamOffset offset = send_buffer->stream_offset();
   send_buffer->SaveStreamData(data);
   if (kMaxStreamLength - offset < data.length()) {
@@ -173,8 +174,9 @@ size_t QuicCryptoStream::BufferSizeLimitForLevel(EncryptionLevel) const {
 bool QuicCryptoStream::OnCryptoFrameAcked(const QuicCryptoFrame& frame,
                                           QuicTime::Delta /*ack_delay_time*/) {
   QuicByteCount newly_acked_length = 0;
-  if (!substreams_[frame.level].send_buffer.OnStreamDataAcked(
-          frame.offset, frame.data_length, &newly_acked_length)) {
+  if (!substreams_[QuicUtils::GetPacketNumberSpace(frame.level)]
+           .send_buffer.OnStreamDataAcked(frame.offset, frame.data_length,
+                                          &newly_acked_length)) {
     OnUnrecoverableError(QUIC_INTERNAL_ERROR,
                          "Trying to ack unsent crypto data.");
     return false;
@@ -201,9 +203,10 @@ void QuicCryptoStream::NeuterStreamDataOfEncryptionLevel(
     }
     return;
   }
-  QuicStreamSendBuffer* send_buffer = &substreams_[level].send_buffer;
-  // TODO(nharper): Consider adding a Clear() method to QuicStreamSendBuffer to
-  // replace the following code.
+  QuicStreamSendBuffer* send_buffer =
+      &substreams_[QuicUtils::GetPacketNumberSpace(level)].send_buffer;
+  // TODO(nharper): Consider adding a Clear() method to QuicStreamSendBuffer
+  // to replace the following code.
   QuicIntervalSet<QuicStreamOffset> to_ack = send_buffer->bytes_acked();
   to_ack.Complement(0, send_buffer->stream_offset());
   for (const auto& interval : to_ack) {
@@ -225,22 +228,13 @@ void QuicCryptoStream::OnStreamDataConsumed(QuicByteCount bytes_consumed) {
   QuicStream::OnStreamDataConsumed(bytes_consumed);
 }
 
-namespace {
-
-constexpr std::array<EncryptionLevel, NUM_ENCRYPTION_LEVELS>
-AllEncryptionLevels() {
-  return {ENCRYPTION_INITIAL, ENCRYPTION_HANDSHAKE, ENCRYPTION_ZERO_RTT,
-          ENCRYPTION_FORWARD_SECURE};
-}
-
-}  // namespace
 
 bool QuicCryptoStream::HasPendingCryptoRetransmission() const {
   if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     return false;
   }
-  for (EncryptionLevel level : AllEncryptionLevels()) {
-    if (substreams_[level].send_buffer.HasPendingRetransmission()) {
+  for (const auto& substream : substreams_) {
+    if (substream.send_buffer.HasPendingRetransmission()) {
       return true;
     }
   }
@@ -251,12 +245,15 @@ void QuicCryptoStream::WritePendingCryptoRetransmission() {
   QUIC_BUG_IF(quic_bug_12573_3,
               !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames";
-  for (EncryptionLevel level : AllEncryptionLevels()) {
-    QuicStreamSendBuffer* send_buffer = &substreams_[level].send_buffer;
+  for (uint8_t i = INITIAL_DATA; i <= APPLICATION_DATA; ++i) {
+    auto packet_number_space = static_cast<PacketNumberSpace>(i);
+    QuicStreamSendBuffer* send_buffer =
+        &substreams_[packet_number_space].send_buffer;
     while (send_buffer->HasPendingRetransmission()) {
       auto pending = send_buffer->NextPendingRetransmission();
       size_t bytes_consumed = stream_delegate()->SendCryptoData(
-          level, pending.length, pending.offset, HANDSHAKE_RETRANSMISSION);
+          GetEncryptionLevelToSendCryptoDataOfSpace(packet_number_space),
+          pending.length, pending.offset, HANDSHAKE_RETRANSMISSION);
       send_buffer->OnStreamDataRetransmitted(pending.offset, bytes_consumed);
       if (bytes_consumed < pending.length) {
         return;
@@ -351,14 +348,17 @@ uint64_t QuicCryptoStream::crypto_bytes_read() const {
     return stream_bytes_read();
   }
   uint64_t bytes_read = 0;
-  for (EncryptionLevel level : AllEncryptionLevels()) {
-    bytes_read += substreams_[level].sequencer.NumBytesConsumed();
+  for (const CryptoSubstream& substream : substreams_) {
+    bytes_read += substream.sequencer.NumBytesConsumed();
   }
   return bytes_read;
 }
 
+// TODO(haoyuewang) Move this test-only method under
+// quiche/quic/test_tools.
 uint64_t QuicCryptoStream::BytesReadOnLevel(EncryptionLevel level) const {
-  return substreams_[level].sequencer.NumBytesConsumed();
+  return substreams_[QuicUtils::GetPacketNumberSpace(level)]
+      .sequencer.NumBytesConsumed();
 }
 
 bool QuicCryptoStream::WriteCryptoFrame(EncryptionLevel level,
@@ -368,16 +368,17 @@ bool QuicCryptoStream::WriteCryptoFrame(EncryptionLevel level,
   QUIC_BUG_IF(quic_bug_12573_4,
               !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames (2)";
-  return substreams_[level].send_buffer.WriteStreamData(offset, data_length,
-                                                        writer);
+  return substreams_[QuicUtils::GetPacketNumberSpace(level)]
+      .send_buffer.WriteStreamData(offset, data_length, writer);
 }
 
 void QuicCryptoStream::OnCryptoFrameLost(QuicCryptoFrame* crypto_frame) {
   QUIC_BUG_IF(quic_bug_12573_5,
               !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't lose CRYPTO frames";
-  substreams_[crypto_frame->level].send_buffer.OnStreamDataLost(
-      crypto_frame->offset, crypto_frame->data_length);
+  substreams_[QuicUtils::GetPacketNumberSpace(crypto_frame->level)]
+      .send_buffer.OnStreamDataLost(crypto_frame->offset,
+                                    crypto_frame->data_length);
 }
 
 bool QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame,
@@ -388,7 +389,8 @@ bool QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame,
   QuicIntervalSet<QuicStreamOffset> retransmission(
       crypto_frame->offset, crypto_frame->offset + crypto_frame->data_length);
   QuicStreamSendBuffer* send_buffer =
-      &substreams_[crypto_frame->level].send_buffer;
+      &substreams_[QuicUtils::GetPacketNumberSpace(crypto_frame->level)]
+           .send_buffer;
   retransmission.Difference(send_buffer->bytes_acked());
   if (retransmission.Empty()) {
     return true;
@@ -396,9 +398,12 @@ bool QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame,
   for (const auto& interval : retransmission) {
     size_t retransmission_offset = interval.min();
     size_t retransmission_length = interval.max() - interval.min();
+    EncryptionLevel retransmission_encryption_level =
+        GetEncryptionLevelToSendCryptoDataOfSpace(
+            QuicUtils::GetPacketNumberSpace(crypto_frame->level));
     size_t bytes_consumed = stream_delegate()->SendCryptoData(
-        crypto_frame->level, retransmission_length, retransmission_offset,
-        type);
+        retransmission_encryption_level, retransmission_length,
+        retransmission_offset, type);
     send_buffer->OnStreamDataRetransmitted(retransmission_offset,
                                            bytes_consumed);
     if (bytes_consumed < retransmission_length) {
@@ -412,8 +417,10 @@ void QuicCryptoStream::WriteBufferedCryptoFrames() {
   QUIC_BUG_IF(quic_bug_12573_7,
               !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't use CRYPTO frames";
-  for (EncryptionLevel level : AllEncryptionLevels()) {
-    QuicStreamSendBuffer* send_buffer = &substreams_[level].send_buffer;
+  for (uint8_t i = INITIAL_DATA; i <= APPLICATION_DATA; ++i) {
+    auto packet_number_space = static_cast<PacketNumberSpace>(i);
+    QuicStreamSendBuffer* send_buffer =
+        &substreams_[packet_number_space].send_buffer;
     const size_t data_length =
         send_buffer->stream_offset() - send_buffer->stream_bytes_written();
     if (data_length == 0) {
@@ -421,8 +428,8 @@ void QuicCryptoStream::WriteBufferedCryptoFrames() {
       continue;
     }
     size_t bytes_consumed = stream_delegate()->SendCryptoData(
-        level, data_length, send_buffer->stream_bytes_written(),
-        NOT_RETRANSMISSION);
+        GetEncryptionLevelToSendCryptoDataOfSpace(packet_number_space),
+        data_length, send_buffer->stream_bytes_written(), NOT_RETRANSMISSION);
     send_buffer->OnStreamDataConsumed(bytes_consumed);
     if (bytes_consumed < data_length) {
       // Connection is write blocked.
@@ -435,8 +442,8 @@ bool QuicCryptoStream::HasBufferedCryptoFrames() const {
   QUIC_BUG_IF(quic_bug_12573_8,
               !QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't use CRYPTO frames";
-  for (EncryptionLevel level : AllEncryptionLevels()) {
-    const QuicStreamSendBuffer& send_buffer = substreams_[level].send_buffer;
+  for (const CryptoSubstream& substream : substreams_) {
+    const QuicStreamSendBuffer& send_buffer = substream.send_buffer;
     QUICHE_DCHECK_GE(send_buffer.stream_offset(),
                      send_buffer.stream_bytes_written());
     if (send_buffer.stream_offset() > send_buffer.stream_bytes_written()) {
@@ -457,15 +464,16 @@ bool QuicCryptoStream::IsFrameOutstanding(EncryptionLevel level, size_t offset,
     // the wrong transport version.
     return false;
   }
-  return substreams_[level].send_buffer.IsStreamDataOutstanding(offset, length);
+  return substreams_[QuicUtils::GetPacketNumberSpace(level)]
+      .send_buffer.IsStreamDataOutstanding(offset, length);
 }
 
 bool QuicCryptoStream::IsWaitingForAcks() const {
   if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     return QuicStream::IsWaitingForAcks();
   }
-  for (EncryptionLevel level : AllEncryptionLevels()) {
-    if (substreams_[level].send_buffer.stream_bytes_outstanding()) {
+  for (const CryptoSubstream& substream : substreams_) {
+    if (substream.send_buffer.stream_bytes_outstanding()) {
       return true;
     }
   }
@@ -473,7 +481,7 @@ bool QuicCryptoStream::IsWaitingForAcks() const {
 }
 
 QuicCryptoStream::CryptoSubstream::CryptoSubstream(
-    QuicCryptoStream* crypto_stream, EncryptionLevel)
+    QuicCryptoStream* crypto_stream)
     : sequencer(crypto_stream),
       send_buffer(crypto_stream->session()
                       ->connection()

package/third_party/quiche/quiche/quic/core/quic_crypto_stream.h

@@ -236,8 +236,9 @@ class QUIC_EXPORT_PRIVATE QuicCryptoStream : public QuicStream {
   virtual void OnDataAvailableInSequencer(QuicStreamSequencer* sequencer,
                                           EncryptionLevel level);
 
-  QuicStreamSequencer* GetStreamSequencerForLevel(EncryptionLevel level) {
-    return &substreams_[level].sequencer;
+  QuicStreamSequencer* GetStreamSequencerForPacketNumberSpace(
+      PacketNumberSpace packet_number_space) {
+    return &substreams_[packet_number_space].sequencer;
   }
 
   // Called by OnCryptoFrame to check if a CRYPTO frame is received at an
@@ -245,13 +246,17 @@ class QUIC_EXPORT_PRIVATE QuicCryptoStream : public QuicStream {
   virtual bool IsCryptoFrameExpectedForEncryptionLevel(
       EncryptionLevel level) const = 0;
 
+  // Called to determine the encryption level to send/retransmit crypto data.
+  virtual EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const = 0;
+
  private:
-  // Data sent and received in CRYPTO frames is sent at multiple encryption
-  // levels. Some of the state for the single logical crypto stream is split
-  // across encryption levels, and a CryptoSubstream is used to manage that
-  // state for a particular encryption level.
+  // Data sent and received in CRYPTO frames is sent at multiple packet number
+  // spaces. Some of the state for the single logical crypto stream is split
+  // across packet number spaces, and a CryptoSubstream is used to manage that
+  // state for a particular packet number space.
   struct QUIC_EXPORT_PRIVATE CryptoSubstream {
-    CryptoSubstream(QuicCryptoStream* crypto_stream, EncryptionLevel);
+    CryptoSubstream(QuicCryptoStream* crypto_stream);
 
     QuicStreamSequencer sequencer;
     QuicStreamSendBuffer send_buffer;
@@ -262,9 +267,9 @@ class QUIC_EXPORT_PRIVATE QuicCryptoStream : public QuicStream {
   // TLS 1.3, which never encrypts crypto data.
   QuicIntervalSet<QuicStreamOffset> bytes_consumed_[NUM_ENCRYPTION_LEVELS];
 
-  // Keeps state for data sent/received in CRYPTO frames at each encryption
-  // level.
-  std::array<CryptoSubstream, NUM_ENCRYPTION_LEVELS> substreams_;
+  // Keeps state for data sent/received in CRYPTO frames at each packet number
+  // space;
+  std::array<CryptoSubstream, NUM_PACKET_NUMBER_SPACES> substreams_;
 };
 
 }  // namespace quic

package/third_party/quiche/quiche/quic/core/quic_crypto_stream_test.cc

@@ -13,6 +13,7 @@
 #include "quiche/quic/core/crypto/crypto_handshake.h"
 #include "quiche/quic/core/crypto/crypto_protocol.h"
 #include "quiche/quic/core/crypto/null_encrypter.h"
+#include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/quic_utils.h"
 #include "quiche/quic/platform/api/quic_socket_address.h"
 #include "quiche/quic/platform/api/quic_test.h"
@@ -101,6 +102,22 @@ class MockQuicCryptoStream : public QuicCryptoStream,
     return level != ENCRYPTION_ZERO_RTT;
   }
 
+  EncryptionLevel GetEncryptionLevelToSendCryptoDataOfSpace(
+      PacketNumberSpace space) const override {
+    switch (space) {
+      case INITIAL_DATA:
+        return ENCRYPTION_INITIAL;
+      case HANDSHAKE_DATA:
+        return ENCRYPTION_HANDSHAKE;
+      case APPLICATION_DATA:
+        return QuicCryptoStream::session()
+            ->GetEncryptionLevelToSendApplicationData();
+      default:
+        QUICHE_DCHECK(false);
+        return NUM_ENCRYPTION_LEVELS;
+    }
+  }
+
  private:
   quiche::QuicheReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
   std::vector<CryptoHandshakeMessage> messages_;
@@ -266,6 +283,17 @@ TEST_F(QuicCryptoStreamTest, RetransmitCryptoDataInCryptoFrames) {
       .WillOnce(Invoke(connection_,
                        &MockQuicConnection::QuicConnection_SendCryptoData));
   stream_->WriteCryptoData(ENCRYPTION_ZERO_RTT, data);
+
+  // Before encryption moves to ENCRYPTION_FORWARD_SECURE, ZERO RTT data are
+  // retranmitted at ENCRYPTION_ZERO_RTT.
+  QuicCryptoFrame lost_frame = QuicCryptoFrame(ENCRYPTION_ZERO_RTT, 0, 650);
+  stream_->OnCryptoFrameLost(&lost_frame);
+
+  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 650, 0))
+      .WillOnce(Invoke(connection_,
+                       &MockQuicConnection::QuicConnection_SendCryptoData));
+  stream_->WritePendingCryptoRetransmission();
+
   connection_->SetEncrypter(
       ENCRYPTION_FORWARD_SECURE,
       std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
@@ -273,7 +301,7 @@ TEST_F(QuicCryptoStreamTest, RetransmitCryptoDataInCryptoFrames) {
   EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, connection_->encryption_level());
 
   // Lost [0, 1000).
-  QuicCryptoFrame lost_frame(ENCRYPTION_INITIAL, 0, 1000);
+  lost_frame = QuicCryptoFrame(ENCRYPTION_INITIAL, 0, 1000);
   stream_->OnCryptoFrameLost(&lost_frame);
   EXPECT_TRUE(stream_->HasPendingCryptoRetransmission());
   // Lost [1200, 2000).
@@ -289,7 +317,7 @@ TEST_F(QuicCryptoStreamTest, RetransmitCryptoDataInCryptoFrames) {
   EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_INITIAL, 150, 1200))
       .WillOnce(Invoke(connection_,
                        &MockQuicConnection::QuicConnection_SendCryptoData));
-  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 650, 0))
+  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_FORWARD_SECURE, 650, 0))
       .WillOnce(Invoke(connection_,
                        &MockQuicConnection::QuicConnection_SendCryptoData));
   stream_->WritePendingCryptoRetransmission();
@@ -533,7 +561,7 @@ TEST_F(QuicCryptoStreamTest, RetransmitStreamDataWithCryptoFrames) {
       stream_->OnCryptoFrameAcked(acked_frame, QuicTime::Delta::Zero()));
 
   // Retransmit only [1350, 1500).
-  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 150, 0))
+  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_FORWARD_SECURE, 150, 0))
       .WillOnce(Invoke(connection_,
                        &MockQuicConnection::QuicConnection_SendCryptoData));
   QuicCryptoFrame frame_to_retransmit(ENCRYPTION_ZERO_RTT, 0, 150);
@@ -543,10 +571,11 @@ TEST_F(QuicCryptoStreamTest, RetransmitStreamDataWithCryptoFrames) {
   EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, connection_->encryption_level());
 
   // Retransmit [1350, 2700) again and all data is sent.
-  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 650, 0))
+  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_FORWARD_SECURE, 650, 0))
       .WillOnce(Invoke(connection_,
                        &MockQuicConnection::QuicConnection_SendCryptoData));
-  EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 200, 1150))
+  EXPECT_CALL(*connection_,
+              SendCryptoData(ENCRYPTION_FORWARD_SECURE, 200, 1150))
       .WillOnce(Invoke(connection_,
                        &MockQuicConnection::QuicConnection_SendCryptoData));
   frame_to_retransmit = QuicCryptoFrame(ENCRYPTION_ZERO_RTT, 0, 1350);