diff --git a/build/source_list.bzl b/build/source_list.bzl
index f023778..8ddf213 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -672,6 +672,7 @@
     "quic/core/quic_dispatcher_stats.cc",
     "quic/core/quic_error_codes.cc",
     "quic/core/quic_flow_controller.cc",
+    "quic/core/quic_force_blockable_packet_writer.cc",
     "quic/core/quic_framer.cc",
     "quic/core/quic_generic_session.cc",
     "quic/core/quic_idle_network_detector.cc",
diff --git a/build/source_list.gni b/build/source_list.gni
index f0cbd28..4e627df 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -672,6 +672,7 @@
     "src/quiche/quic/core/quic_dispatcher_stats.cc",
     "src/quiche/quic/core/quic_error_codes.cc",
     "src/quiche/quic/core/quic_flow_controller.cc",
+    "src/quiche/quic/core/quic_force_blockable_packet_writer.cc",
     "src/quiche/quic/core/quic_framer.cc",
     "src/quiche/quic/core/quic_generic_session.cc",
     "src/quiche/quic/core/quic_idle_network_detector.cc",
diff --git a/build/source_list.json b/build/source_list.json
index 587bf76..8a20ecb 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -671,6 +671,7 @@
     "quiche/quic/core/quic_dispatcher_stats.cc",
     "quiche/quic/core/quic_error_codes.cc",
     "quiche/quic/core/quic_flow_controller.cc",
+    "quiche/quic/core/quic_force_blockable_packet_writer.cc",
     "quiche/quic/core/quic_framer.cc",
     "quiche/quic/core/quic_generic_session.cc",
     "quiche/quic/core/quic_idle_network_detector.cc",
diff --git a/quiche/quic/core/http/quic_connection_migration_manager_test.cc b/quiche/quic/core/http/quic_connection_migration_manager_test.cc
index 350f489..81a48ac 100644
--- a/quiche/quic/core/http/quic_connection_migration_manager_test.cc
+++ b/quiche/quic/core/http/quic_connection_migration_manager_test.cc
@@ -43,75 +43,6 @@
   }
 };
 
-class TestQuicForceBlockablePacketWriter
-    : public QuicForceBlockablePacketWriter {
- public:
-  TestQuicForceBlockablePacketWriter() : QuicForceBlockablePacketWriter() {
-    ON_CALL(writer_, WritePacket(_, _, _, _, _, _))
-        .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0)));
-    ON_CALL(writer_, GetMaxPacketSize(_))
-        .WillByDefault(Return(kMaxOutgoingPacketSize));
-    ON_CALL(writer_, IsBatchMode()).WillByDefault(Return(false));
-    ON_CALL(writer_, GetNextWriteLocation(_, _))
-        .WillByDefault(Return(QuicPacketBuffer()));
-    ON_CALL(writer_, Flush())
-        .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0)));
-    ON_CALL(writer_, SupportsReleaseTime()).WillByDefault(Return(false));
-  }
-
-  // QuicPacketWriter.
-  WriteResult WritePacket(const char* buffer, size_t buf_len,
-                          const QuicIpAddress& self_address,
-                          const QuicSocketAddress& peer_address,
-                          PerPacketOptions* options,
-                          const QuicPacketWriterParams& params) override {
-    return writer_.WritePacket(buffer, buf_len, self_address, peer_address,
-                               options, params);
-  }
-
-  void SetWritable() override { writer_.SetWritable(); }
-
-  std::optional<int> MessageTooBigErrorCode() const override {
-    return kSocketErrorMsgSize;
-  }
-
-  QuicByteCount GetMaxPacketSize(
-      const QuicSocketAddress& peer_address) const override {
-    return writer_.GetMaxPacketSize(peer_address);
-  }
-
-  bool SupportsReleaseTime() const override {
-    return writer_.SupportsReleaseTime();
-  }
-
-  bool IsBatchMode() const override { return writer_.IsBatchMode(); }
-
-  bool SupportsEcn() const override { return writer_.SupportsEcn(); }
-
-  QuicPacketBuffer GetNextWriteLocation(
-      const QuicIpAddress& self_address,
-      const QuicSocketAddress& peer_address) override {
-    return writer_.GetNextWriteLocation(self_address, peer_address);
-  }
-
-  WriteResult Flush() override { return writer_.Flush(); }
-
-  bool IsWriteBlocked() const override {
-    return force_write_blocked_ || writer_.IsWriteBlocked();
-  }
-
-  // QuicForceBlockablePacketWriter
-  void ForceWriteBlocked(bool enforce_write_block) override {
-    force_write_blocked_ = enforce_write_block;
-  }
-
-  MockPacketWriter& GetMockWriter() { return writer_; }
-
- private:
-  NiceMock<MockPacketWriter> writer_;
-  bool force_write_blocked_ = false;
-};
-
 class TestQuicClientPathValidationContext
     : public QuicClientPathValidationContext {
  public:
@@ -119,7 +50,23 @@
       const quic::QuicSocketAddress& self_address,
       const quic::QuicSocketAddress& peer_address, QuicNetworkHandle network)
       : QuicClientPathValidationContext(self_address, peer_address, network),
-        writer_(std::make_unique<TestQuicForceBlockablePacketWriter>()) {}
+        writer_(std::make_unique<QuicForceBlockablePacketWriter>()) {
+    auto* writer = new NiceMock<MockPacketWriter>();
+    // Owns writer.
+    writer_->set_writer(writer);
+    ON_CALL(*writer, WritePacket(_, _, _, _, _, _))
+        .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0)));
+    ON_CALL(*writer, GetMaxPacketSize(_))
+        .WillByDefault(Return(kMaxOutgoingPacketSize));
+    ON_CALL(*writer, IsBatchMode()).WillByDefault(Return(false));
+    ON_CALL(*writer, GetNextWriteLocation(_, _))
+        .WillByDefault(Return(QuicPacketBuffer()));
+    ON_CALL(*writer, Flush())
+        .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0)));
+    ON_CALL(*writer, SupportsReleaseTime()).WillByDefault(Return(false));
+    ON_CALL(*writer, MessageTooBigErrorCode())
+        .WillByDefault(Return(kSocketErrorMsgSize));
+  }
 
   QuicForceBlockablePacketWriter* ForceBlockableWriterToUse() override {
     return writer_.get();
@@ -130,7 +77,7 @@
   void ReleasePacketWriter() { writer_.release(); }
 
  private:
-  std::unique_ptr<TestQuicForceBlockablePacketWriter> writer_;
+  std::unique_ptr<QuicForceBlockablePacketWriter> writer_;
 };
 
 class TestQuicPathContextFactory : public QuicPathContextFactory {
@@ -372,7 +319,7 @@
       : QuicSpdyClientSessionWithMigration(
             connection, writer, visitor, config, supported_versions,
             default_network, current_network, std::move(path_context_factory),
-            migration_config),
+            migration_config, QuicPriorityType::kHttp),
         crypto_stream_(this) {
     ON_CALL(*this, IsSessionProxied()).WillByDefault(Return(false));
     ON_CALL(*this, OnMigrationToPathDone(_, _))
@@ -391,7 +338,6 @@
   MOCK_METHOD(void, PrepareForProbingOnPath,
               (QuicPathValidationContext & context), (override));
   MOCK_METHOD(bool, IsSessionProxied, (), (const));
-  MOCK_METHOD(QuicTimeDelta, TimeSinceLastStreamClose, (), (override));
   MOCK_METHOD(bool, PrepareForMigrationToPath,
               (QuicClientPathValidationContext&));
   MOCK_METHOD(void, OnMigrationToPathDone,
@@ -488,7 +434,22 @@
         connection_(new StrictMock<test::MockQuicConnection>(
             &connection_helper_, &alarm_factory_, Perspective::IS_CLIENT,
             versions_)),
-        default_writer_(new NiceMock<TestQuicForceBlockablePacketWriter>()) {
+        default_writer_(new QuicForceBlockablePacketWriter()) {
+    auto* writer = new NiceMock<MockPacketWriter>();
+    // Owns writer.
+    default_writer_->set_writer(writer);
+    ON_CALL(*writer, WritePacket(_, _, _, _, _, _))
+        .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0)));
+    ON_CALL(*writer, GetMaxPacketSize(_))
+        .WillByDefault(Return(kMaxOutgoingPacketSize));
+    ON_CALL(*writer, IsBatchMode()).WillByDefault(Return(false));
+    ON_CALL(*writer, GetNextWriteLocation(_, _))
+        .WillByDefault(Return(QuicPacketBuffer()));
+    ON_CALL(*writer, Flush())
+        .WillByDefault(Return(WriteResult(WRITE_STATUS_OK, 0)));
+    ON_CALL(*writer, SupportsReleaseTime()).WillByDefault(Return(false));
+    ON_CALL(*writer, MessageTooBigErrorCode())
+        .WillByDefault(Return(kSocketErrorMsgSize));
     connection_->SetQuicPacketWriter(default_writer_, true);
   }
 
@@ -576,7 +537,7 @@
   TestQuicPathContextFactory* path_context_factory_ = nullptr;
   // Owned by |session_|
   StrictMock<test::MockQuicConnection>* connection_;
-  NiceMock<TestQuicForceBlockablePacketWriter>* default_writer_;
+  QuicForceBlockablePacketWriter* default_writer_;
   std::unique_ptr<TestQuicSpdyClientSessionWithMigration> session_;
   QuicConnectionMigrationManager* migration_manager_ = nullptr;
   bool connection_migration_on_path_degrading_ = true;
@@ -661,8 +622,8 @@
   path_context_factory_->SetSelfAddressForNetwork(alternate_network,
                                                   alternate_self_address);
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   EXPECT_CALL(*session_, ResetNonMigratableStreams());
   EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(true));
   EXPECT_CALL(*session_, OnMigrationToPathDone(_, true));
@@ -691,8 +652,8 @@
                                                   alternate_self_address);
   QuicSocketAddress self_address = connection_->self_address();
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   EXPECT_CALL(*session_, ResetNonMigratableStreams());
   EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(true));
   EXPECT_CALL(*session_, OnMigrationToPathDone(_, true));
@@ -746,8 +707,8 @@
   EXPECT_EQ(migrate_back_alarm->deadline(),
             connection_helper_.GetClock()->Now());
   // Fire the alarm to migrate back to default network, starting with probing.
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(2));
   QuicPathFrameBuffer path_frame_payload;
   EXPECT_CALL(*session_, PrepareForProbingOnPath(_));
   EXPECT_CALL(*connection_, SendPathChallenge(_, _, _, _, _))
@@ -773,8 +734,8 @@
                                                       self_address2);
   const QuicPathResponseFrame path_response(0, path_frame_payload);
   EXPECT_CALL(*session_, ResetNonMigratableStreams());
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(2));
   EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(true));
   EXPECT_CALL(*session_, OnMigrationToPathDone(_, true));
   connection_->ReallyOnPathResponseFrame(path_response);
@@ -803,8 +764,8 @@
 
   // Receive a network disconnected signal, migration should be attempted
   // immediately.
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   EXPECT_CALL(*session_, ResetNonMigratableStreams());
   migration_manager_->OnNetworkDisconnected(initial_network_);
   EXPECT_EQ(path_context_factory_->num_creation_attempts(), 1u);
@@ -852,8 +813,8 @@
   session_->set_alternate_network(alternate_network);
   EXPECT_NE(alternate_network, migration_manager_->current_network());
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(migration_config_.idle_migration_period));
+  connection_helper_.GetClock()->AdvanceTime(
+      migration_config_.idle_migration_period);
   EXPECT_CALL(
       *connection_,
       CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
@@ -889,8 +850,8 @@
   EXPECT_NE(alternate_network, migration_manager_->current_network());
   EXPECT_TRUE(session_->config()->DisableConnectionMigration());
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   EXPECT_CALL(*connection_,
               CloseConnection(QUIC_CONNECTION_MIGRATION_DISABLED_BY_CONFIG,
                               "Migration disabled by config",
@@ -905,8 +866,8 @@
   Initialize();
   EXPECT_TRUE(session_->config()->DisableConnectionMigration());
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   migration_manager_->MaybeStartMigrateSessionOnWriteError(/*error_code=*/111);
   // An alarm should have been scheduled to run pending callbacks.
   QuicAlarm* pending_callbacks_alarm =
@@ -940,8 +901,8 @@
   path_context_factory_->SetSelfAddressForNetwork(alternate_network,
                                                   alternate_self_address);
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   EXPECT_CALL(*session_, ResetNonMigratableStreams());
   EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(true));
   EXPECT_CALL(*session_, OnMigrationToPathDone(_, true));
@@ -963,7 +924,6 @@
   // The migrate back timer will fire. Due to default network being
   // disconnected, no attempt will be exercised to migrate back.
   connection_helper_.GetClock()->AdvanceTime(QuicTimeDelta::FromSeconds(1));
-  QuicTimeDelta time_since_last_stream_close = QuicTimeDelta::FromSeconds(1);
   EXPECT_CALL(*session_, PrepareForProbingOnPath(_)).Times(0);
   alarm_factory_.FireAlarm(migrate_back_alarm);
   EXPECT_EQ(path_context_factory_->num_creation_attempts(), 1u);
@@ -978,8 +938,6 @@
     path_context_factory_->SetSelfAddressForNetwork(
         initial_network_,
         QuicSocketAddress(QuicIpAddress::Loopback4(), kTestPort + i));
-    EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-        .WillOnce(Return(time_since_last_stream_close));
     // Update CIDs.
     QuicConnectionPeer::RetirePeerIssuedConnectionIdsNoLongerOnPath(
         connection_);
@@ -1020,15 +978,12 @@
     EXPECT_EQ(migrate_back_alarm->deadline(),
               connection_helper_.GetClock()->Now() + next_delay);
     connection_helper_.GetClock()->AdvanceTime(next_delay);
-    time_since_last_stream_close = time_since_last_stream_close + next_delay;
   }
 
   // The connection should have been idle for longer than the idle migration
   // period. Next attempt to migrate back will close the connection.
-  EXPECT_GT(time_since_last_stream_close,
+  EXPECT_GT(session_->TimeSinceLastStreamClose(),
             migration_config_.idle_migration_period);
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(time_since_last_stream_close));
   //  The connection should be closed instead of attempting to migrate back.
   EXPECT_CALL(
       *connection_,
@@ -1970,8 +1925,8 @@
   path_context_factory_->SetSelfAddressForNetwork(alternate_network,
                                                   alternate_self_address);
 
-  EXPECT_CALL(*session_, TimeSinceLastStreamClose())
-      .WillOnce(Return(QuicTimeDelta::Zero()));
+  EXPECT_EQ(session_->TimeSinceLastStreamClose(),
+            QuicTimeDelta::FromSeconds(1));
   EXPECT_CALL(*session_, ResetNonMigratableStreams());
   // Session failed to prepare for migration. Migration should not be attempted.
   EXPECT_CALL(*session_, PrepareForMigrationToPath(_)).WillOnce(Return(false));
diff --git a/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc b/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc
index 4c9939b..a9f2c99 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc
+++ b/quiche/quic/core/http/quic_spdy_client_session_with_migration.cc
@@ -14,16 +14,24 @@
     const ParsedQuicVersionVector& supported_versions,
     QuicNetworkHandle default_network, QuicNetworkHandle current_network,
     std::unique_ptr<QuicPathContextFactory> path_context_factory,
-    QuicConnectionMigrationConfig migration_config)
-    : QuicSpdyClientSessionBase(connection, visitor, config,
-                                supported_versions),
+    QuicConnectionMigrationConfig migration_config,
+    QuicPriorityType priority_type)
+    : QuicSpdyClientSessionBase(connection, visitor, config, supported_versions,
+                                priority_type),
       path_context_factory_(std::move(path_context_factory)),
       migration_manager_(this, connection->clock(), default_network,
                          current_network, path_context_factory_.get(),
                          migration_config),
-      writer_(writer) {
-  QUICHE_DCHECK_EQ(writer_, connection->writer())
-      << "Writer is not the connection writer";
+      writer_(writer),
+      most_recent_stream_close_time_(connection->clock()->ApproximateNow()) {
+  QUICHE_DCHECK(writer_ == nullptr || writer_ == connection->writer())
+      << "Writer is should be either null or the connection writer";
+  if (migration_config.migrate_session_on_network_change ||
+      migration_config.allow_port_migration ||
+      migration_config.allow_server_preferred_address) {
+    QUICHE_DCHECK_EQ(writer_, connection->writer())
+        << "Writer is not the connection writer";
+  }
 }
 
 QuicSpdyClientSessionWithMigration::~QuicSpdyClientSessionWithMigration() =
@@ -73,6 +81,8 @@
 void QuicSpdyClientSessionWithMigration::OnServerPreferredAddressAvailable(
     const QuicSocketAddress& server_preferred_address) {
   QUICHE_DCHECK(version().HasIetfQuicFrames());
+  QuicSpdyClientSessionBase::OnServerPreferredAddressAvailable(
+      server_preferred_address);
   migration_manager_.MaybeStartMigrateSessionToServerPreferredAddress(
       server_preferred_address);
 }
@@ -87,4 +97,15 @@
   return migration_manager_.config();
 }
 
+void QuicSpdyClientSessionWithMigration::OnStreamClosed(
+    QuicStreamId stream_id) {
+  most_recent_stream_close_time_ = connection()->clock()->ApproximateNow();
+  QuicSpdyClientSessionBase::OnStreamClosed(stream_id);
+}
+
+QuicTimeDelta QuicSpdyClientSessionWithMigration::TimeSinceLastStreamClose() {
+  return connection()->clock()->ApproximateNow() -
+         most_recent_stream_close_time_;
+}
+
 }  // namespace quic
diff --git a/quiche/quic/core/http/quic_spdy_client_session_with_migration.h b/quiche/quic/core/http/quic_spdy_client_session_with_migration.h
index e434a3c..da219c5 100644
--- a/quiche/quic/core/http/quic_spdy_client_session_with_migration.h
+++ b/quiche/quic/core/http/quic_spdy_client_session_with_migration.h
@@ -33,13 +33,16 @@
 class QUICHE_EXPORT QuicSpdyClientSessionWithMigration
     : public QuicSpdyClientSessionBase {
  public:
+  // `writer` must be the same as the connection's writer if any type of
+  // migration is enabled. Otherwise, it can also be nullptr.
   QuicSpdyClientSessionWithMigration(
       QuicConnection* connection, QuicForceBlockablePacketWriter* writer,
       QuicSession::Visitor* visitor, const QuicConfig& config,
       const ParsedQuicVersionVector& supported_versions,
       QuicNetworkHandle default_network, QuicNetworkHandle current_network,
       std::unique_ptr<QuicPathContextFactory> path_context_factory,
-      QuicConnectionMigrationConfig migration_config);
+      QuicConnectionMigrationConfig migration_config,
+      QuicPriorityType priority_type);
 
   ~QuicSpdyClientSessionWithMigration() override;
 
@@ -68,7 +71,7 @@
   virtual bool IsSessionProxied() const = 0;
 
   // Returns the time elapsed since the latest stream closure.
-  virtual quic::QuicTimeDelta TimeSinceLastStreamClose() = 0;
+  quic::QuicTimeDelta TimeSinceLastStreamClose();
 
   // QuicSpdyClientSessionBase
   void OnPathDegrading() override;
@@ -76,6 +79,7 @@
   void SetDefaultEncryptionLevel(EncryptionLevel level) override;
   void OnServerPreferredAddressAvailable(
       const quic::QuicSocketAddress& server_preferred_address) override;
+  void OnStreamClosed(QuicStreamId stream_id) override;
 
   // Migrates session onto the new path, i.e. changing the default writer and
   // network.
@@ -113,6 +117,7 @@
   std::unique_ptr<QuicPathContextFactory> path_context_factory_;
   QuicConnectionMigrationManager migration_manager_;
   QuicForceBlockablePacketWriter* absl_nonnull writer_;
+  QuicTime most_recent_stream_close_time_;
 };
 
 }  // namespace quic
diff --git a/quiche/quic/core/quic_force_blockable_packet_writer.cc b/quiche/quic/core/quic_force_blockable_packet_writer.cc
new file mode 100644
index 0000000..10655d3
--- /dev/null
+++ b/quiche/quic/core/quic_force_blockable_packet_writer.cc
@@ -0,0 +1,18 @@
+// Copyright 2025 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "quiche/quic/core/quic_force_blockable_packet_writer.h"
+
+namespace quic {
+
+void QuicForceBlockablePacketWriter::ForceWriteBlocked(
+    bool enforce_write_block) {
+  enforce_write_block_ = enforce_write_block;
+}
+
+bool QuicForceBlockablePacketWriter::IsWriteBlocked() const {
+  return enforce_write_block_ || QuicPacketWriterWrapper::IsWriteBlocked();
+}
+
+}  // namespace quic
diff --git a/quiche/quic/core/quic_force_blockable_packet_writer.h b/quiche/quic/core/quic_force_blockable_packet_writer.h
index a487885..677490f 100644
--- a/quiche/quic/core/quic_force_blockable_packet_writer.h
+++ b/quiche/quic/core/quic_force_blockable_packet_writer.h
@@ -5,20 +5,26 @@
 #ifndef QUICHE_QUIC_CORE_QUIC_FORCE_BLOCKABLE_PACKET_WRITER_H_
 #define QUICHE_QUIC_CORE_QUIC_FORCE_BLOCKABLE_PACKET_WRITER_H_
 
-#include "quiche/quic/core/quic_packet_writer.h"
+#include "quiche/quic/core/quic_packet_writer_wrapper.h"
 
 namespace quic {
 
-// A extended interface of QuicPacketWriter that can be forced to be write
+// A QuicPacketWriterWrapper implementation that can be forced to be write
 // blocked.
-class QUICHE_EXPORT QuicForceBlockablePacketWriter : public QuicPacketWriter {
+class QUICHE_EXPORT QuicForceBlockablePacketWriter
+    : public QuicPacketWriterWrapper {
  public:
   // If `enforce_write_block` is true, IsWriteBlocked() will always return true
   // regardless of whether SetWritable() is called or not until
-  // this method is called again with |enforce_write_block| false.
-  // If |enforce_write_block| is false, SetWritable() may still be needed to
+  // this method is called again with `enforce_write_block` false.
+  // If `enforce_write_block` is false, SetWritable() may still be needed to
   // make IsWriteBlocked() to return true.
-  virtual void ForceWriteBlocked(bool enforce_write_block) = 0;
+  void ForceWriteBlocked(bool enforce_write_block);
+
+  bool IsWriteBlocked() const override;
+
+ private:
+  bool enforce_write_block_ = false;
 };
 
 }  // namespace quic