diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index 8e32448..8a3153d 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -290,7 +290,7 @@
     // Set appropriate encryption level.
     session()->connection()->SetDefaultEncryptionLevel(
         retransmission_encryption_level);
-    QuicConsumedData consumed = session()->WritevData(
+    QuicConsumedData consumed = stream_delegate()->WritevData(
         this, id(), pending.length, pending.offset, NO_FIN);
     QUIC_DVLOG(1) << ENDPOINT << "stream " << id()
                   << " tries to retransmit stream data [" << pending.offset
@@ -332,7 +332,7 @@
     QuicByteCount retransmission_length = interval.max() - interval.min();
     // Set appropriate encryption level.
     session()->connection()->SetDefaultEncryptionLevel(send_encryption_level);
-    QuicConsumedData consumed = session()->WritevData(
+    QuicConsumedData consumed = stream_delegate()->WritevData(
         this, id(), retransmission_length, retransmission_offset, NO_FIN);
     QUIC_DVLOG(1) << ENDPOINT << "stream " << id()
                   << " is forced to retransmit stream data ["
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 466d17b..1d6534f 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -165,17 +165,6 @@
                                 const QuicSocketAddress& peer_address,
                                 const QuicReceivedPacket& packet);
 
-  // Called by streams when they want to write data to the peer.
-  // Returns a pair with the number of bytes consumed from data, and a boolean
-  // indicating if the fin bit was consumed.  This does not indicate the data
-  // has been sent on the wire: it may have been turned into a packet and queued
-  // if the socket was unexpectedly blocked.
-  virtual QuicConsumedData WritevData(QuicStream* stream,
-                                      QuicStreamId id,
-                                      size_t write_length,
-                                      QuicStreamOffset offset,
-                                      StreamSendingState state);
-
   // Called by application to send |message|. Data copy can be avoided if
   // |message| is provided in reference counted memory.
   // Please note, |message| provided in reference counted memory would be moved
@@ -263,6 +252,17 @@
   void OnStreamError(QuicErrorCode error_code,
                      std::string error_details) override;
 
+  // Called by streams when they want to write data to the peer.
+  // Returns a pair with the number of bytes consumed from data, and a boolean
+  // indicating if the fin bit was consumed.  This does not indicate the data
+  // has been sent on the wire: it may have been turned into a packet and queued
+  // if the socket was unexpectedly blocked.
+  QuicConsumedData WritevData(QuicStream* stream,
+                              QuicStreamId id,
+                              size_t write_length,
+                              QuicStreamOffset offset,
+                              StreamSendingState state) override;
+
   // Called by the QuicCryptoStream when a handshake message is sent.
   virtual void OnCryptoHandshakeMessageSent(
       const CryptoHandshakeMessage& message);
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index fee630b..6dcbd36 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -929,9 +929,9 @@
     const bool can_bundle_fin =
         retransmit_fin && (retransmission_offset + retransmission_length ==
                            stream_bytes_written());
-    consumed = session()->WritevData(this, id_, retransmission_length,
-                                     retransmission_offset,
-                                     can_bundle_fin ? FIN : NO_FIN);
+    consumed = stream_delegate_->WritevData(this, id_, retransmission_length,
+                                            retransmission_offset,
+                                            can_bundle_fin ? FIN : NO_FIN);
     QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                   << " is forced to retransmit stream data ["
                   << retransmission_offset << ", "
@@ -952,7 +952,8 @@
   if (retransmit_fin) {
     QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                   << " retransmits fin only frame.";
-    consumed = session()->WritevData(this, id_, 0, stream_bytes_written(), FIN);
+    consumed =
+        stream_delegate_->WritevData(this, id_, 0, stream_bytes_written(), FIN);
     if (!consumed.fin_consumed) {
       return false;
     }
@@ -1022,7 +1023,7 @@
   if (fin && add_random_padding_after_fin_) {
     state = FIN_AND_PADDING;
   }
-  QuicConsumedData consumed_data = session_->WritevData(
+  QuicConsumedData consumed_data = stream_delegate_->WritevData(
       this, id(), write_length, stream_bytes_written(), state);
 
   OnStreamDataConsumed(consumed_data.bytes_consumed);
@@ -1097,8 +1098,8 @@
     if (!send_buffer_.HasPendingRetransmission()) {
       QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                     << " retransmits fin only frame.";
-      consumed =
-          session()->WritevData(this, id_, 0, stream_bytes_written(), FIN);
+      consumed = stream_delegate_->WritevData(this, id_, 0,
+                                              stream_bytes_written(), FIN);
       fin_lost_ = !consumed.fin_consumed;
       if (fin_lost_) {
         // Connection is write blocked.
@@ -1111,9 +1112,9 @@
       const bool can_bundle_fin =
           fin_lost_ &&
           (pending.offset + pending.length == stream_bytes_written());
-      consumed =
-          session()->WritevData(this, id_, pending.length, pending.offset,
-                                can_bundle_fin ? FIN : NO_FIN);
+      consumed = stream_delegate_->WritevData(this, id_, pending.length,
+                                              pending.offset,
+                                              can_bundle_fin ? FIN : NO_FIN);
       QUIC_DVLOG(1) << ENDPOINT << "stream " << id_
                     << " tries to retransmit stream data [" << pending.offset
                     << ", " << pending.offset + pending.length
diff --git a/quic/core/stream_delegate_interface.h b/quic/core/stream_delegate_interface.h
index f6d052a..2616f13 100644
--- a/quic/core/stream_delegate_interface.h
+++ b/quic/core/stream_delegate_interface.h
@@ -5,10 +5,13 @@
 #ifndef QUICHE_QUIC_CORE_STREAM_DELEGATE_INTERFACE_H_
 #define QUICHE_QUIC_CORE_STREAM_DELEGATE_INTERFACE_H_
 
+#include <cstddef>
 #include "net/third_party/quiche/src/quic/core/quic_types.h"
 
 namespace quic {
 
+class QuicStream;
+
 class QUIC_EXPORT_PRIVATE StreamDelegateInterface {
  public:
   virtual ~StreamDelegateInterface() {}
@@ -16,6 +19,13 @@
   // Called when the stream has encountered errors that it can't handle.
   virtual void OnStreamError(QuicErrorCode error_code,
                              std::string error_details) = 0;
+
+  // Called when the stream needs to write data.
+  virtual QuicConsumedData WritevData(QuicStream* stream,
+                                      QuicStreamId id,
+                                      size_t write_length,
+                                      QuicStreamOffset offset,
+                                      StreamSendingState state) = 0;
 };
 
 }  // namespace quic