diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 937b5e8..44ed080 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "absl/strings/string_view.h"
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
@@ -226,6 +227,9 @@
     QuicSpdySessionPeer::SetMaxInboundHeaderListSize(&session_, 256 * 1024);
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
     session_.Initialize();
+    connection_->SetEncrypter(
+        quic::ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<quic::NullEncrypter>(connection_->perspective()));
     headers_stream_ = QuicSpdySessionPeer::GetHeadersStream(&session_);
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index 53d0d6d..4f1b461 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -8,6 +8,7 @@
 
 #include "absl/strings/escaping.h"
 #include "absl/strings/string_view.h"
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
@@ -82,6 +83,9 @@
   void Initialize() {
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
     session_.Initialize();
+    connection_->SetEncrypter(
+        ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<NullEncrypter>(connection_->perspective()));
     send_control_stream_ = QuicSpdySessionPeer::GetSendControlStream(&session_);
     QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
         session_.config(), kMinimumFlowControlSendWindow);
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index c8bae78..5444c9d 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -121,6 +121,9 @@
         QuicServerId(kServerHostname, kPort, false),
         client_crypto_config_.get(), &push_promise_index_);
     session_->Initialize();
+    connection_->SetEncrypter(
+        ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<NullEncrypter>(connection_->perspective()));
     crypto_stream_ = static_cast<QuicCryptoClientStream*>(
         session_->GetMutableCryptoStream());
     push_promise_[":path"] = "/bar";
@@ -281,7 +284,7 @@
   char data[] = "hello world";
   EXPECT_QUIC_BUG(
       session_->WritevData(stream->id(), ABSL_ARRAYSIZE(data), 0, NO_FIN,
-                           NOT_RETRANSMISSION, absl::nullopt),
+                           NOT_RETRANSMISSION, ENCRYPTION_INITIAL),
       "Client: Try to send data of stream");
 }
 
diff --git a/quic/core/http/quic_spdy_server_stream_base_test.cc b/quic/core/http/quic_spdy_server_stream_base_test.cc
index 64184a7..4505cd0 100644
--- a/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -4,6 +4,7 @@
 
 #include "net/third_party/quiche/src/quic/core/http/quic_spdy_server_stream_base.h"
 
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_spdy_session_peer.h"
@@ -33,6 +34,9 @@
                                         &alarm_factory_,
                                         Perspective::IS_SERVER)) {
     session_.Initialize();
+    session_.connection()->SetEncrypter(
+        ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<NullEncrypter>(session_.perspective()));
     stream_ =
         new TestQuicSpdyServerStream(GetNthClientInitiatedBidirectionalStreamId(
                                          session_.transport_version(), 0),
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 714c21d..0d27288 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -335,7 +335,8 @@
     MakeIOVector("not empty", &iov);
     QuicStreamPeer::SendBuffer(stream).SaveStreamData(&iov, 1, 0, 9);
     QuicConsumedData consumed =
-        WritevData(stream->id(), 9, 0, FIN, NOT_RETRANSMISSION, absl::nullopt);
+        WritevData(stream->id(), 9, 0, FIN, NOT_RETRANSMISSION,
+                   GetEncryptionLevelToSendApplicationData());
     QuicStreamPeer::SendBuffer(stream).OnStreamDataConsumed(
         consumed.bytes_consumed);
     return consumed;
@@ -344,7 +345,7 @@
   QuicConsumedData SendLargeFakeData(QuicStream* stream, int bytes) {
     DCHECK(writev_consumes_all_data_);
     return WritevData(stream->id(), bytes, 0, FIN, NOT_RETRANSMISSION,
-                      absl::nullopt);
+                      GetEncryptionLevelToSendApplicationData());
   }
 
   using QuicSession::closed_streams;
@@ -1469,7 +1470,7 @@
     QuicConfig config;
     CryptoHandshakeMessage crypto_message;
     config.ToHandshakeMessage(&crypto_message, transport_version());
-    crypto_stream->SendHandshakeMessage(crypto_message);
+    crypto_stream->SendHandshakeMessage(crypto_message, ENCRYPTION_INITIAL);
     char buf[1000];
     QuicDataWriter writer(1000, buf, quiche::NETWORK_BYTE_ORDER);
     crypto_stream->WriteStreamData(offset, crypto_message.size(), &writer);
diff --git a/quic/core/qpack/qpack_send_stream_test.cc b/quic/core/qpack/qpack_send_stream_test.cc
index f99b168..80c8986 100644
--- a/quic/core/qpack/qpack_send_stream_test.cc
+++ b/quic/core/qpack/qpack_send_stream_test.cc
@@ -5,6 +5,7 @@
 #include "net/third_party/quiche/src/quic/core/qpack/qpack_send_stream.h"
 
 #include "absl/strings/string_view.h"
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/http/http_constants.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_config_peer.h"
@@ -69,6 +70,9 @@
         session_(connection_) {
     EXPECT_CALL(session_, OnCongestionWindowChange(_)).Times(AnyNumber());
     session_.Initialize();
+    connection_->SetEncrypter(
+        ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<NullEncrypter>(connection_->perspective()));
     if (connection_->version().SupportsAntiAmplificationLimit()) {
       QuicConnectionPeer::SetAddressValidated(connection_);
     }
diff --git a/quic/core/quic_crypto_client_handshaker.cc b/quic/core/quic_crypto_client_handshaker.cc
index f744153..74f0724 100644
--- a/quic/core/quic_crypto_client_handshaker.cc
+++ b/quic/core/quic_crypto_client_handshaker.cc
@@ -347,7 +347,7 @@
     chlo_hash_ = CryptoUtils::HashHandshakeMessage(out, Perspective::IS_CLIENT);
     session()->connection()->set_fully_pad_crypto_handshake_packets(
         crypto_config_->pad_inchoate_hello());
-    SendHandshakeMessage(out);
+    SendHandshakeMessage(out, ENCRYPTION_INITIAL);
     return;
   }
 
@@ -374,7 +374,7 @@
   next_state_ = STATE_RECV_SHLO;
   session()->connection()->set_fully_pad_crypto_handshake_packets(
       crypto_config_->pad_full_hello());
-  SendHandshakeMessage(out);
+  SendHandshakeMessage(out, ENCRYPTION_INITIAL);
   // Be prepared to decrypt with the new server write key.
   delegate_->OnNewEncryptionKeyAvailable(
       ENCRYPTION_ZERO_RTT,
diff --git a/quic/core/quic_crypto_handshaker.cc b/quic/core/quic_crypto_handshaker.cc
index d608ead..8adf83b 100644
--- a/quic/core/quic_crypto_handshaker.cc
+++ b/quic/core/quic_crypto_handshaker.cc
@@ -20,13 +20,16 @@
 QuicCryptoHandshaker::~QuicCryptoHandshaker() {}
 
 void QuicCryptoHandshaker::SendHandshakeMessage(
-    const CryptoHandshakeMessage& message) {
+    const CryptoHandshakeMessage& message,
+    EncryptionLevel level) {
   QUIC_DVLOG(1) << ENDPOINT << "Sending " << message.DebugString();
   session()->NeuterUnencryptedData();
   session()->OnCryptoHandshakeMessageSent(message);
   last_sent_handshake_message_tag_ = message.tag();
   const QuicData& data = message.GetSerialized();
-  stream_->WriteCryptoData(session_->connection()->encryption_level(),
+  stream_->WriteCryptoData(session_->use_write_or_buffer_data_at_level()
+                               ? level
+                               : session_->connection()->encryption_level(),
                            data.AsStringPiece());
 }
 
diff --git a/quic/core/quic_crypto_handshaker.h b/quic/core/quic_crypto_handshaker.h
index e5d8d51..b971580 100644
--- a/quic/core/quic_crypto_handshaker.h
+++ b/quic/core/quic_crypto_handshaker.h
@@ -21,7 +21,8 @@
 
   // Sends |message| to the peer.
   // TODO(wtc): return a success/failure status.
-  void SendHandshakeMessage(const CryptoHandshakeMessage& message);
+  void SendHandshakeMessage(const CryptoHandshakeMessage& message,
+                            EncryptionLevel level);
 
   void OnError(CryptoFramer* framer) override;
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 4c21e55..2bad8ec 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -173,7 +173,8 @@
   if (reply->tag() != kSHLO) {
     session()->connection()->set_fully_pad_crypto_handshake_packets(
         crypto_config_->pad_rej());
-    SendHandshakeMessage(*reply);
+    // Send REJ in plaintext.
+    SendHandshakeMessage(*reply, ENCRYPTION_INITIAL);
     return;
   }
 
@@ -213,7 +214,8 @@
 
   session()->connection()->set_fully_pad_crypto_handshake_packets(
       crypto_config_->pad_shlo());
-  SendHandshakeMessage(*reply);
+  // Send SHLO in ENCRYPTION_ZERO_RTT.
+  SendHandshakeMessage(*reply, ENCRYPTION_ZERO_RTT);
   delegate_->OnNewEncryptionKeyAvailable(
       ENCRYPTION_FORWARD_SECURE,
       std::move(crypto_negotiated_params_->forward_secure_crypters.encrypter));
@@ -284,12 +286,15 @@
 
   QUIC_DVLOG(1) << "Server: Sending server config update: "
                 << message.DebugString();
-  if (!QuicVersionUsesCryptoFrames(transport_version())) {
+
+  if (!session()->use_write_or_buffer_data_at_level() &&
+      !QuicVersionUsesCryptoFrames(transport_version())) {
     const QuicData& data = message.GetSerialized();
     WriteOrBufferData(absl::string_view(data.data(), data.length()), false,
                       nullptr);
   } else {
-    SendHandshakeMessage(message);
+    // Send server config update in ENCRYPTION_FORWARD_SECURE.
+    SendHandshakeMessage(message, ENCRYPTION_FORWARD_SECURE);
   }
 
   ++num_server_config_update_messages_sent_;
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index 688b585..5cdae35 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -142,6 +142,11 @@
 void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
                                        absl::string_view data) {
   if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
+    if (session()->use_write_or_buffer_data_at_level()) {
+      WriteOrBufferDataAtLevel(data, /*fin=*/false, level,
+                               /*ack_listener=*/nullptr);
+      return;
+    }
     // The QUIC crypto handshake takes care of setting the appropriate
     // encryption level before writing data. Since that is the only handshake
     // supported in versions less than 47, |level| can be ignored here.
@@ -307,7 +312,7 @@
                                             QuicByteCount data_length,
                                             bool /*fin*/,
                                             TransmissionType type) {
-  DCHECK_EQ(HANDSHAKE_RETRANSMISSION, type);
+  DCHECK(type == HANDSHAKE_RETRANSMISSION || type == PTO_RETRANSMISSION);
   QuicIntervalSet<QuicStreamOffset> retransmission(offset,
                                                    offset + data_length);
   // Determine the encryption level to send data. This only needs to be once as
@@ -340,7 +345,7 @@
     QuicByteCount retransmission_length,
     EncryptionLevel encryption_level,
     TransmissionType type) {
-  DCHECK_EQ(HANDSHAKE_RETRANSMISSION, type);
+  DCHECK(type == HANDSHAKE_RETRANSMISSION || type == PTO_RETRANSMISSION);
   const auto consumed = stream_delegate()->WritevData(
       id(), retransmission_length, retransmission_offset, NO_FIN, type,
       encryption_level);
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index de8091e..c5c4df8 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -74,6 +74,7 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_testonly_default_true, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_unified_iw_options, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_fast_huffman_encoder, true)
+QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_write_or_buffer_data_at_level, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_send_quic_fallback_server_config_on_leto_error, false)
 QUIC_FLAG(FLAGS_quic_restart_flag_dont_fetch_quic_private_keys_from_leto, false)
 QUIC_FLAG(FLAGS_quic_restart_flag_quic_enable_zero_rtt_for_tls_v2, true)
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 58bf909..587be13 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -2065,6 +2065,20 @@
   return false;
 }
 
+EncryptionLevel QuicFramer::GetEncryptionLevelToSendApplicationData() const {
+  if (!HasAnEncrypterForSpace(APPLICATION_DATA)) {
+    QUIC_BUG
+        << "Tried to get encryption level to send application data with no "
+           "encrypter available.";
+    return NUM_ENCRYPTION_LEVELS;
+  }
+  if (HasEncrypterOfEncryptionLevel(ENCRYPTION_FORWARD_SECURE)) {
+    return ENCRYPTION_FORWARD_SECURE;
+  }
+  DCHECK(HasEncrypterOfEncryptionLevel(ENCRYPTION_ZERO_RTT));
+  return ENCRYPTION_ZERO_RTT;
+}
+
 bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
                                     QuicDataWriter* writer,
                                     size_t* length_field_offset) {
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index 86c8882..e6936e0 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -621,6 +621,10 @@
   // Returns true if an encrypter of |space| is available.
   bool HasAnEncrypterForSpace(PacketNumberSpace space) const;
 
+  // Returns the encryption level to send application data. This should be only
+  // called with available encrypter for application data.
+  EncryptionLevel GetEncryptionLevelToSendApplicationData() const;
+
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
   Perspective perspective() const { return perspective_; }
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 5f1c5ef..bee5b10 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -730,6 +730,7 @@
     absl::optional<EncryptionLevel> level) {
   DCHECK(connection_->connected())
       << ENDPOINT << "Try to write stream data when connection is closed.";
+  DCHECK(!use_write_or_buffer_data_at_level_ || level.has_value());
   if (!IsEncryptionEstablished() &&
       !QuicUtils::IsCryptoStreamId(transport_version(), id)) {
     // Do not let streams write without encryption. The calling stream will end
@@ -2502,5 +2503,9 @@
   }
 }
 
+EncryptionLevel QuicSession::GetEncryptionLevelToSendApplicationData() const {
+  return connection_->framer().GetEncryptionLevelToSendApplicationData();
+}
+
 #undef ENDPOINT  // undef for jumbo builds
 }  // namespace quic
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index d162d59..cb0efbe 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -493,6 +493,9 @@
   virtual void MaybeSendStopSendingFrame(QuicStreamId id,
                                          QuicRstStreamErrorCode error);
 
+  // Returns the encryption level to send application data.
+  EncryptionLevel GetEncryptionLevelToSendApplicationData() const;
+
   const absl::optional<std::string> user_agent_id() const {
     return user_agent_id_;
   }
@@ -510,6 +513,10 @@
     return liveness_testing_in_progress_;
   }
 
+  bool use_write_or_buffer_data_at_level() const {
+    return use_write_or_buffer_data_at_level_;
+  }
+
  protected:
   using StreamMap = QuicHashMap<QuicStreamId, std::unique_ptr<QuicStream>>;
 
@@ -849,6 +856,9 @@
   bool liveness_testing_in_progress_;
 
   const bool split_up_send_rst_ = GetQuicReloadableFlag(quic_split_up_send_rst);
+
+  const bool use_write_or_buffer_data_at_level_ =
+      GetQuicReloadableFlag(quic_use_write_or_buffer_data_at_level);
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 129c937..0622508 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -350,7 +350,8 @@
     MakeIOVector("not empty", &iov);
     QuicStreamPeer::SendBuffer(stream).SaveStreamData(&iov, 1, 0, 9);
     QuicConsumedData consumed =
-        WritevData(stream->id(), 9, 0, FIN, NOT_RETRANSMISSION, absl::nullopt);
+        WritevData(stream->id(), 9, 0, FIN, NOT_RETRANSMISSION,
+                   GetEncryptionLevelToSendApplicationData());
     QuicStreamPeer::SendBuffer(stream).OnStreamDataConsumed(
         consumed.bytes_consumed);
     return consumed;
@@ -367,7 +368,7 @@
   QuicConsumedData SendLargeFakeData(QuicStream* stream, int bytes) {
     DCHECK(writev_consumes_all_data_);
     return WritevData(stream->id(), bytes, 0, FIN, NOT_RETRANSMISSION,
-                      absl::nullopt);
+                      GetEncryptionLevelToSendApplicationData());
   }
 
   bool UsesPendingStreams() const override { return uses_pending_streams_; }
@@ -1683,7 +1684,7 @@
     QuicConfig config;
     CryptoHandshakeMessage crypto_message;
     config.ToHandshakeMessage(&crypto_message, transport_version());
-    crypto_stream->SendHandshakeMessage(crypto_message);
+    crypto_stream->SendHandshakeMessage(crypto_message, ENCRYPTION_INITIAL);
     char buf[1000];
     QuicDataWriter writer(1000, buf, quiche::NETWORK_BYTE_ORDER);
     crypto_stream->WriteStreamData(offset, crypto_message.size(), &writer);
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index e9daac7..7b11146 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -639,6 +639,23 @@
     absl::string_view data,
     bool fin,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+  if (session()->use_write_or_buffer_data_at_level()) {
+    QUIC_BUG_IF(QuicUtils::IsCryptoStreamId(transport_version(), id_))
+        << ENDPOINT
+        << "WriteOrBufferData is used to send application data, use "
+           "WriteOrBufferDataAtLevel to send crypto data.";
+    return WriteOrBufferDataAtLevel(
+        data, fin, session()->GetEncryptionLevelToSendApplicationData(),
+        ack_listener);
+  }
+  return WriteOrBufferDataInner(data, fin, absl::nullopt, ack_listener);
+}
+
+void QuicStream::WriteOrBufferDataInner(
+    absl::string_view data,
+    bool fin,
+    absl::optional<EncryptionLevel> level,
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (data.empty() && !fin) {
     QUIC_BUG << "data.empty() && !fin";
     return;
@@ -678,10 +695,20 @@
   }
   if (!had_buffered_data && (HasBufferedData() || fin_buffered_)) {
     // Write data if there is no buffered data before.
-    WriteBufferedData();
+    WriteBufferedData(level);
   }
 }
 
+void QuicStream::WriteOrBufferDataAtLevel(
+    absl::string_view data,
+    bool fin,
+    EncryptionLevel level,
+    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
+  DCHECK(session()->use_write_or_buffer_data_at_level());
+  QUIC_RELOADABLE_FLAG_COUNT(quic_use_write_or_buffer_data_at_level);
+  return WriteOrBufferDataInner(data, fin, level, ack_listener);
+}
+
 void QuicStream::OnCanWrite() {
   if (HasDeadlinePassed()) {
     OnDeadlinePassed();
@@ -701,7 +728,11 @@
     return;
   }
   if (HasBufferedData() || (fin_buffered_ && !fin_sent_)) {
-    WriteBufferedData();
+    absl::optional<EncryptionLevel> send_level = absl::nullopt;
+    if (session()->use_write_or_buffer_data_at_level()) {
+      send_level = session()->GetEncryptionLevelToSendApplicationData();
+    }
+    WriteBufferedData(send_level);
   }
   if (!fin_buffered_ && !fin_sent_ && CanWriteNewData()) {
     // Notify upper layer to write new data when buffered data size is below
@@ -779,7 +810,11 @@
 
   if (!had_buffered_data && (HasBufferedData() || fin_buffered_)) {
     // Write data if there is no buffered data before.
-    WriteBufferedData();
+    absl::optional<EncryptionLevel> send_level = absl::nullopt;
+    if (session()->use_write_or_buffer_data_at_level()) {
+      send_level = session()->GetEncryptionLevelToSendApplicationData();
+    }
+    WriteBufferedData(send_level);
   }
 
   return consumed_data;
@@ -1126,6 +1161,10 @@
   if (retransmission.Empty() && !retransmit_fin) {
     return true;
   }
+  absl::optional<EncryptionLevel> send_level = absl::nullopt;
+  if (session()->use_write_or_buffer_data_at_level()) {
+    send_level = session()->GetEncryptionLevelToSendApplicationData();
+  }
   QuicConsumedData consumed(0, false);
   for (const auto& interval : retransmission) {
     QuicStreamOffset retransmission_offset = interval.min();
@@ -1135,7 +1174,7 @@
                            stream_bytes_written());
     consumed = stream_delegate_->WritevData(
         id_, retransmission_length, retransmission_offset,
-        can_bundle_fin ? FIN : NO_FIN, type, absl::nullopt);
+        can_bundle_fin ? FIN : NO_FIN, type, send_level);
     QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                   << " is forced to retransmit stream data ["
                   << retransmission_offset << ", "
@@ -1157,7 +1196,7 @@
     QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                   << " retransmits fin only frame.";
     consumed = stream_delegate_->WritevData(id_, 0, stream_bytes_written(), FIN,
-                                            type, absl::nullopt);
+                                            type, send_level);
     if (!consumed.fin_consumed) {
       return false;
     }
@@ -1183,7 +1222,7 @@
   return send_buffer_.WriteStreamData(offset, data_length, writer);
 }
 
-void QuicStream::WriteBufferedData() {
+void QuicStream::WriteBufferedData(absl::optional<EncryptionLevel> level) {
   DCHECK(!write_side_closed_ && (HasBufferedData() || fin_buffered_));
 
   if (session_->ShouldYield(id())) {
@@ -1235,7 +1274,7 @@
   }
   QuicConsumedData consumed_data =
       stream_delegate_->WritevData(id(), write_length, stream_bytes_written(),
-                                   state, NOT_RETRANSMISSION, absl::nullopt);
+                                   state, NOT_RETRANSMISSION, level);
 
   OnStreamDataConsumed(consumed_data.bytes_consumed);
 
@@ -1306,12 +1345,15 @@
 void QuicStream::WritePendingRetransmission() {
   while (HasPendingRetransmission()) {
     QuicConsumedData consumed(0, false);
+    absl::optional<EncryptionLevel> send_level = absl::nullopt;
+    if (session()->use_write_or_buffer_data_at_level()) {
+      send_level = session()->GetEncryptionLevelToSendApplicationData();
+    }
     if (!send_buffer_.HasPendingRetransmission()) {
       QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                     << " retransmits fin only frame.";
-      consumed =
-          stream_delegate_->WritevData(id_, 0, stream_bytes_written(), FIN,
-                                       LOSS_RETRANSMISSION, absl::nullopt);
+      consumed = stream_delegate_->WritevData(
+          id_, 0, stream_bytes_written(), FIN, LOSS_RETRANSMISSION, send_level);
       fin_lost_ = !consumed.fin_consumed;
       if (fin_lost_) {
         // Connection is write blocked.
@@ -1326,7 +1368,7 @@
           (pending.offset + pending.length == stream_bytes_written());
       consumed = stream_delegate_->WritevData(
           id_, pending.length, pending.offset, can_bundle_fin ? FIN : NO_FIN,
-          LOSS_RETRANSMISSION, absl::nullopt);
+          LOSS_RETRANSMISSION, send_level);
       QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                     << " tries to retransmit stream data [" << pending.offset
                     << ", " << pending.offset + pending.length
diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 467cca9..275e93a 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -275,15 +275,23 @@
   // stop sending stream-level flow-control updates when this end sends FIN.
   virtual void StopReading();
 
-  // Sends as much of 'data' to the connection as the connection will consume,
-  // and then buffers any remaining data in queued_data_.
-  // If fin is true: if it is immediately passed on to the session,
-  // write_side_closed() becomes true, otherwise fin_buffered_ becomes true.
+  // Sends as much of |data| to the connection on the application encryption
+  // level as the connection will consume, and then buffers any remaining data
+  // in the send buffer. If fin is true: if it is immediately passed on to the
+  // session, write_side_closed() becomes true, otherwise fin_buffered_ becomes
+  // true.
   void WriteOrBufferData(
       absl::string_view data,
       bool fin,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
+  // Sends |data| to connection with specified |level|.
+  void WriteOrBufferDataAtLevel(
+      absl::string_view data,
+      bool fin,
+      EncryptionLevel level,
+      QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+
   // Adds random padding after the fin is consumed for this stream.
   void AddRandomPaddingAfterFin();
 
@@ -455,9 +463,10 @@
   // controller, marks this stream as connection-level write blocked.
   void MaybeSendBlocked();
 
-  // Write buffered data in send buffer. TODO(fayang): Consider combine
-  // WriteOrBufferData, Writev and WriteBufferedData.
-  void WriteBufferedData();
+  // Write buffered data in send buffer.
+  // TODO(fayang): Change absl::optional<EncryptionLevel> to EncryptionLevel
+  // when deprecating quic_use_write_or_buffer_data_at_level.
+  void WriteBufferedData(absl::optional<EncryptionLevel> level);
 
   // Close the read side of the stream.  May cause the stream to be closed.
   void CloseReadSide();
@@ -465,6 +474,14 @@
   // Called when bytes are sent to the peer.
   void AddBytesSent(QuicByteCount bytes);
 
+  // TODO(fayang): Inline this function when deprecating
+  // quic_use_write_or_buffer_data_at_level.
+  void WriteOrBufferDataInner(
+      absl::string_view data,
+      bool fin,
+      absl::optional<EncryptionLevel> level,
+      QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
+
   // Returns true if deadline_ has passed.
   bool HasDeadlinePassed() const;
 
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 563a7fd..d241dac 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -11,6 +11,7 @@
 #include "absl/base/macros.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_rst_stream_frame.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
 #include "net/third_party/quiche/src/quic/core/quic_constants.h"
@@ -95,7 +96,9 @@
     connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
     session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
     session_->Initialize();
-
+    connection_->SetEncrypter(
+        ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<NullEncrypter>(connection_->perspective()));
     QuicConfigPeer::SetReceivedInitialSessionFlowControlWindow(
         session_->config(), kMinimumFlowControlSendWindow);
     QuicConfigPeer::SetReceivedInitialMaxStreamDataBytesUnidirectional(
diff --git a/quic/core/stream_delegate_interface.h b/quic/core/stream_delegate_interface.h
index 7c36c91..dc93299 100644
--- a/quic/core/stream_delegate_interface.h
+++ b/quic/core/stream_delegate_interface.h
@@ -26,6 +26,8 @@
   // Called when the stream needs to write data. If |level| is present, the data
   // will be written at the specified |level|. The data will be written
   // at specified transmission |type|.
+  // TODO(fayang): Change absl::optional<EncryptionLevel> to EncryptionLevel
+  // when deprecating quic_use_write_or_buffer_data_at_level.
   virtual QuicConsumedData WritevData(
       QuicStreamId id,
       size_t write_length,
diff --git a/quic/quic_transport/quic_transport_stream_test.cc b/quic/quic_transport/quic_transport_stream_test.cc
index e6c244b..82cd914 100644
--- a/quic/quic_transport/quic_transport_stream_test.cc
+++ b/quic/quic_transport/quic_transport_stream_test.cc
@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "absl/strings/string_view.h"
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/frames/quic_window_update_frame.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
 #include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
@@ -42,7 +43,9 @@
         session_(connection_) {
     QuicEnableVersion(DefaultVersionForQuicTransport());
     session_.Initialize();
-
+    connection_->SetEncrypter(
+        ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<NullEncrypter>(connection_->perspective()));
     stream_ = new QuicTransportStream(0, &session_, &interface_);
     session_.ActivateStream(QuicWrapUnique(stream_));
 
diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 90d1313..4b21cca 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -11,6 +11,7 @@
 #include "absl/base/macros.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
 #include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
 #include "net/third_party/quiche/src/quic/core/http/spdy_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_error_codes.h"
@@ -251,6 +252,9 @@
     session_.config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     session_.Initialize();
+    connection_->SetEncrypter(
+        quic::ENCRYPTION_FORWARD_SECURE,
+        std::make_unique<quic::NullEncrypter>(connection_->perspective()));
     if (connection_->version().SupportsAntiAmplificationLimit()) {
       QuicConnectionPeer::SetAddressValidated(connection_);
     }