diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index 4704c4c..99f5372 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -28,7 +28,7 @@
 
 // The following tags have been deprecated and should not be reused:
 // "1CON", "BBQ4", "NCON", "RCID", "SREJ", "TBKP", "TB10", "SCLS", "SMHL",
-// "QNZR", "B2HI"
+// "QNZR", "B2HI", "H2PR", "FIFO", "LIFO", "RRWS"
 
 // clang-format off
 const QuicTag kCHLO = TAG('C', 'H', 'L', 'O');   // Client hello
@@ -337,14 +337,6 @@
 const QuicTag kMTUH = TAG('M', 'T', 'U', 'H');  // High-target MTU discovery.
 const QuicTag kMTUL = TAG('M', 'T', 'U', 'L');  // Low-target MTU discovery.
 
-// Enable Priority scheme experiment.
-const QuicTag kH2PR = TAG('H', '2', 'P', 'R');  // HTTP2 priorities.
-const QuicTag kFIFO = TAG('F', 'I', 'F', 'O');  // Stream with the smallest ID
-                                                // has the highest priority.
-const QuicTag kLIFO = TAG('L', 'I', 'F', 'O');  // Stream with the largest ID
-                                                // has the highest priority.
-const QuicTag kRRWS = TAG('R', 'R', 'W', 'S');  // Round robin write scheduling.
-
 const QuicTag kNSLC = TAG('N', 'S', 'L', 'C');  // Always send connection close
                                                 // for idle timeout.
 
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index e35d622..8026ac2 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -324,8 +324,8 @@
   void OnHeaders(SpdyStreamId stream_id,
                  bool has_priority,
                  int weight,
-                 SpdyStreamId parent_stream_id,
-                 bool exclusive,
+                 SpdyStreamId /* parent_stream_id */,
+                 bool /* exclusive */,
                  bool fin,
                  bool /*end*/) override {
     if (!session_->IsConnected()) {
@@ -342,13 +342,6 @@
         << "QuicSpdyStream use after free. "
         << session_->destruction_indicator() << QuicStackTrace();
 
-    if (session_->use_http2_priority_write_scheduler()) {
-      session_->OnHeaders(
-          stream_id, has_priority,
-          spdy::SpdyStreamPrecedence(parent_stream_id, weight, exclusive), fin);
-      return;
-    }
-
     SpdyPriority priority =
         has_priority ? Http2WeightToSpdy3Priority(weight) : 0;
     session_->OnHeaders(stream_id, has_priority,
@@ -379,18 +372,13 @@
   void OnContinuation(SpdyStreamId /*stream_id*/, bool /*end*/) override {}
 
   void OnPriority(SpdyStreamId stream_id,
-                  SpdyStreamId parent_id,
+                  SpdyStreamId /* parent_id */,
                   int weight,
-                  bool exclusive) override {
+                  bool /* exclusive */) override {
     DCHECK(!VersionUsesHttp3(session_->transport_version()));
     if (!session_->IsConnected()) {
       return;
     }
-    if (session_->use_http2_priority_write_scheduler()) {
-      session_->OnPriority(
-          stream_id, spdy::SpdyStreamPrecedence(parent_id, weight, exclusive));
-      return;
-    }
     SpdyPriority priority = Http2WeightToSpdy3Priority(weight);
     session_->OnPriority(stream_id, spdy::SpdyStreamPrecedence(priority));
   }
diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 53b4e40..b30410b 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -28,7 +28,6 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_default_to_bbr_v2, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_delay_initial_ack, true)
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_deprecate_http2_priority_experiment, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_server_blackhole_detection, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_draft_29, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_disable_version_q043, false)
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index a50d7a6..5c308f0 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -111,9 +111,7 @@
       datagram_queue_(this, std::move(datagram_observer)),
       closed_streams_clean_up_alarm_(nullptr),
       supported_versions_(supported_versions),
-      use_http2_priority_write_scheduler_(false),
       is_configured_(false),
-      enable_round_robin_scheduling_(false),
       was_zero_rtt_rejected_(false),
       liveness_testing_in_progress_(false) {
   closed_streams_clean_up_alarm_ =
@@ -613,9 +611,7 @@
                << ", finished_writes: " << i
                << ", connected: " << connection_->connected()
                << ", connection level flow control blocked: "
-               << flow_controller_.IsBlocked() << ", scheduler type: "
-               << spdy::WriteSchedulerTypeToString(
-                      write_blocked_streams_.scheduler_type());
+               << flow_controller_.IsBlocked();
       for (QuicStreamId id : last_writing_stream_ids) {
         QUIC_LOG(WARNING) << "last_writing_stream_id: " << id;
       }
@@ -1271,32 +1267,6 @@
       if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kIFWA)) {
         AdjustInitialFlowControlWindows(1024 * 1024);
       }
-      if (GetQuicReloadableFlag(quic_deprecate_http2_priority_experiment)) {
-        QUIC_CODE_COUNT(quic_deprecate_http2_priority_experiment);
-      } else {
-        if (ContainsQuicTag(config_.ReceivedConnectionOptions(), kH2PR) &&
-            !VersionHasIetfQuicFrames(transport_version())) {
-          // Enable HTTP2 (tree-style) priority write scheduler.
-          use_http2_priority_write_scheduler_ =
-              write_blocked_streams_.SwitchWriteScheduler(
-                  spdy::WriteSchedulerType::HTTP2, transport_version());
-        } else if (ContainsQuicTag(config_.ReceivedConnectionOptions(),
-                                   kFIFO)) {
-          // Enable FIFO write scheduler.
-          write_blocked_streams_.SwitchWriteScheduler(
-              spdy::WriteSchedulerType::FIFO, transport_version());
-        } else if (ContainsQuicTag(config_.ReceivedConnectionOptions(),
-                                   kLIFO)) {
-          // Enable LIFO write scheduler.
-          write_blocked_streams_.SwitchWriteScheduler(
-              spdy::WriteSchedulerType::LIFO, transport_version());
-        } else if (ContainsQuicTag(config_.ReceivedConnectionOptions(),
-                                   kRRWS) &&
-                   write_blocked_streams_.scheduler_type() ==
-                       spdy::WriteSchedulerType::SPDY) {
-          enable_round_robin_scheduling_ = true;
-        }
-      }
     }
 
     config_.SetStatelessResetTokenToSend(GetStatelessResetToken());
@@ -1807,13 +1777,6 @@
     QuicStreamId id,
     bool is_static,
     const spdy::SpdyStreamPrecedence& precedence) {
-  if (enable_round_robin_scheduling_) {
-    // Ignore provided precedence, instead, put all streams at the same priority
-    // bucket.
-    write_blocked_streams()->RegisterStream(
-        id, is_static, spdy::SpdyStreamPrecedence(spdy::kV3LowestPriority));
-    return;
-  }
   write_blocked_streams()->RegisterStream(id, is_static, precedence);
 }
 
@@ -1824,10 +1787,6 @@
 void QuicSession::UpdateStreamPriority(
     QuicStreamId id,
     const spdy::SpdyStreamPrecedence& new_precedence) {
-  if (enable_round_robin_scheduling_) {
-    // Ignore updated precedence.
-    return;
-  }
   write_blocked_streams()->UpdateStreamPriority(id, new_precedence);
 }
 
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 2101c28..b995c5d 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -543,10 +543,6 @@
 
   inline ParsedQuicVersion version() const { return connection_->version(); }
 
-  bool use_http2_priority_write_scheduler() const {
-    return use_http2_priority_write_scheduler_;
-  }
-
   bool is_configured() const { return is_configured_; }
 
   // Called to neuter crypto data of encryption |level|.
@@ -941,17 +937,10 @@
 
   absl::optional<std::string> user_agent_id_;
 
-  // If true, write_blocked_streams_ uses HTTP2 (tree-style) priority write
-  // scheduler.
-  bool use_http2_priority_write_scheduler_;
-
   // Initialized to false. Set to true when the session has been properly
   // configured and is ready for general operation.
   bool is_configured_;
 
-  // If true, enables round robin scheduling.
-  bool enable_round_robin_scheduling_;
-
   // Whether the session has received a 0-RTT rejection (QUIC+TLS only).
   bool was_zero_rtt_rejected_;
 
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 3288047..7c5d9bb 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -1045,142 +1045,6 @@
   session_.OnCanWrite();
 }
 
-TEST_P(QuicSessionTestServer, Http2Priority) {
-  if (GetQuicReloadableFlag(quic_deprecate_http2_priority_experiment)) {
-    return;
-  }
-
-  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
-    // The test is using HTTP/2 priority which is not supported in IETF QUIC.
-    return;
-  }
-  QuicTagVector copt;
-  copt.push_back(kH2PR);
-  QuicConfigPeer::SetReceivedConnectionOptions(session_.config(), copt);
-  connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
-  session_.OnConfigNegotiated();
-  ASSERT_TRUE(session_.use_http2_priority_write_scheduler());
-
-  session_.set_writev_consumes_all_data(true);
-  TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
-  TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
-  TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
-
-  session_.set_writev_consumes_all_data(true);
-  /*
-           0
-          /|\
-         2 4 6
-  */
-  session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
-  // Verify streams are scheduled round robin.
-  InSequence s;
-  EXPECT_CALL(*stream2, OnCanWrite());
-  EXPECT_CALL(*stream4, OnCanWrite());
-  EXPECT_CALL(*stream6, OnCanWrite());
-  session_.OnCanWrite();
-
-  /*
-           0
-           |
-           4
-          / \
-         2   6
-  */
-  // Update stream 4's priority.
-  stream4->SetPriority(
-      spdy::SpdyStreamPrecedence(0, spdy::kHttp2DefaultStreamWeight, true));
-  session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
-  EXPECT_CALL(*stream4, OnCanWrite()).WillOnce(Invoke([this, stream4]() {
-    session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  }));
-  EXPECT_CALL(*stream4, OnCanWrite());
-  EXPECT_CALL(*stream2, OnCanWrite());
-  session_.OnCanWrite();
-  EXPECT_CALL(*stream6, OnCanWrite());
-  session_.OnCanWrite();
-
-  /*
-         0
-         |
-         6
-         |
-         4
-         |
-         2
-  */
-  // Update stream 6's priority.
-  stream6->SetPriority(
-      spdy::SpdyStreamPrecedence(0, spdy::kHttp2DefaultStreamWeight, true));
-  session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
-  EXPECT_CALL(*stream6, OnCanWrite()).WillOnce(Invoke([this, stream6]() {
-    session_.MarkConnectionLevelWriteBlocked(stream6->id());
-  }));
-  EXPECT_CALL(*stream6, OnCanWrite());
-  EXPECT_CALL(*stream4, OnCanWrite());
-  session_.OnCanWrite();
-  EXPECT_CALL(*stream2, OnCanWrite());
-  session_.OnCanWrite();
-}
-
-TEST_P(QuicSessionTestServer, RoundRobinScheduling) {
-  if (GetQuicReloadableFlag(quic_deprecate_http2_priority_experiment)) {
-    return;
-  }
-
-  if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
-    // IETF QUIC currently doesn't support PRIORITY.
-    return;
-  }
-  QuicTagVector copt;
-  copt.push_back(kRRWS);
-  QuicConfigPeer::SetReceivedConnectionOptions(session_.config(), copt);
-  connection_->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
-  session_.OnConfigNegotiated();
-
-  session_.set_writev_consumes_all_data(true);
-  TestStream* stream2 = session_.CreateOutgoingBidirectionalStream();
-  TestStream* stream4 = session_.CreateOutgoingBidirectionalStream();
-  TestStream* stream6 = session_.CreateOutgoingBidirectionalStream();
-
-  session_.set_writev_consumes_all_data(true);
-  session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
-  // Verify streams are scheduled round robin.
-  InSequence s;
-  EXPECT_CALL(*stream2, OnCanWrite());
-  EXPECT_CALL(*stream4, OnCanWrite());
-  EXPECT_CALL(*stream6, OnCanWrite());
-  session_.OnCanWrite();
-
-  /* 2, 4, 6, 8 */
-  TestStream* stream8 = session_.CreateOutgoingBidirectionalStream();
-
-  // Verify updated priority is ignored.
-  stream4->SetPriority(spdy::SpdyStreamPrecedence(spdy::kV3HighestPriority));
-  session_.MarkConnectionLevelWriteBlocked(stream8->id());
-  session_.MarkConnectionLevelWriteBlocked(stream4->id());
-  session_.MarkConnectionLevelWriteBlocked(stream2->id());
-  session_.MarkConnectionLevelWriteBlocked(stream6->id());
-
-  EXPECT_CALL(*stream8, OnCanWrite());
-  EXPECT_CALL(*stream4, OnCanWrite());
-  EXPECT_CALL(*stream2, OnCanWrite());
-  EXPECT_CALL(*stream6, OnCanWrite());
-  session_.OnCanWrite();
-}
-
 TEST_P(QuicSessionTestServer, OnCanWriteBundlesStreams) {
   // Encryption needs to be established before data can be sent.
   CompleteHandshake();
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 5aa7150..b5cdd31 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -1458,16 +1458,10 @@
 // static
 spdy::SpdyStreamPrecedence QuicStream::CalculateDefaultPriority(
     const QuicSession* session) {
-  if (VersionUsesHttp3(session->transport_version())) {
-    return spdy::SpdyStreamPrecedence(kDefaultUrgency);
-  }
-
-  if (session->use_http2_priority_write_scheduler()) {
-    return spdy::SpdyStreamPrecedence(0, spdy::kHttp2DefaultStreamWeight,
-                                      false);
-  }
-
-  return spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority);
+  return spdy::SpdyStreamPrecedence(
+      VersionUsesHttp3(session->transport_version())
+          ? kDefaultUrgency
+          : QuicStream::kDefaultPriority);
 }
 
 }  // namespace quic
diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc
index 21e4fde..02b72e3 100644
--- a/quic/core/quic_write_blocked_list.cc
+++ b/quic/core/quic_write_blocked_list.cc
@@ -10,13 +10,10 @@
 namespace quic {
 
 QuicWriteBlockedList::QuicWriteBlockedList(QuicTransportVersion version)
-    : priority_write_scheduler_(
-          std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
-              QuicVersionUsesCryptoFrames(version)
-                  ? std::numeric_limits<QuicStreamId>::max()
-                  : 0)),
-      last_priority_popped_(0),
-      scheduler_type_(spdy::WriteSchedulerType::SPDY) {
+    : priority_write_scheduler_(QuicVersionUsesCryptoFrames(version)
+                                    ? std::numeric_limits<QuicStreamId>::max()
+                                    : 0),
+      last_priority_popped_(0) {
   memset(batch_write_stream_id_, 0, sizeof(batch_write_stream_id_));
   memset(bytes_left_for_batch_write_, 0, sizeof(bytes_left_for_batch_write_));
 }
@@ -35,47 +32,7 @@
     }
   }
 
-  return priority_write_scheduler_->ShouldYield(id);
-}
-
-bool QuicWriteBlockedList::SwitchWriteScheduler(spdy::WriteSchedulerType type,
-                                                QuicTransportVersion version) {
-  if (scheduler_type_ == type) {
-    return true;
-  }
-  if (priority_write_scheduler_->NumRegisteredStreams() != 0) {
-    QUIC_BUG << "Cannot switch scheduler with registered streams";
-    return false;
-  }
-  QUIC_DVLOG(1) << "Switching to scheduler type: "
-                << spdy::WriteSchedulerTypeToString(type);
-  switch (type) {
-    case spdy::WriteSchedulerType::LIFO:
-      priority_write_scheduler_ =
-          std::make_unique<spdy::LifoWriteScheduler<QuicStreamId>>();
-      break;
-    case spdy::WriteSchedulerType::SPDY:
-      priority_write_scheduler_ =
-          std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
-              QuicVersionUsesCryptoFrames(version)
-                  ? std::numeric_limits<QuicStreamId>::max()
-                  : 0);
-      break;
-    case spdy::WriteSchedulerType::HTTP2:
-      priority_write_scheduler_ =
-          std::make_unique<spdy::Http2PriorityWriteScheduler<QuicStreamId>>();
-      break;
-    case spdy::WriteSchedulerType::FIFO:
-      priority_write_scheduler_ =
-          std::make_unique<spdy::FifoWriteScheduler<QuicStreamId>>();
-      break;
-    default:
-      QUIC_BUG << "Scheduler is not supported for type: "
-               << spdy::WriteSchedulerTypeToString(type);
-      return false;
-  }
-  scheduler_type_ = type;
-  return true;
+  return priority_write_scheduler_.ShouldYield(id);
 }
 
 QuicStreamId QuicWriteBlockedList::PopFront() {
@@ -85,16 +42,12 @@
   }
 
   const auto id_and_precedence =
-      priority_write_scheduler_->PopNextReadyStreamAndPrecedence();
+      priority_write_scheduler_.PopNextReadyStreamAndPrecedence();
   const QuicStreamId id = std::get<0>(id_and_precedence);
-  if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
-    // No batch writing logic for non-SPDY priority write scheduler.
-    return id;
-  }
   const spdy::SpdyPriority priority =
       std::get<1>(id_and_precedence).spdy3_priority();
 
-  if (!priority_write_scheduler_->HasReadyStreams()) {
+  if (!priority_write_scheduler_.HasReadyStreams()) {
     // If no streams are blocked, don't bother latching.  This stream will be
     // the first popped for its priority anyway.
     batch_write_stream_id_[priority] = 0;
@@ -113,15 +66,15 @@
     QuicStreamId stream_id,
     bool is_static_stream,
     const spdy::SpdyStreamPrecedence& precedence) {
-  DCHECK(!priority_write_scheduler_->StreamRegistered(stream_id))
+  DCHECK(!priority_write_scheduler_.StreamRegistered(stream_id))
       << "stream " << stream_id << " already registered";
-  DCHECK(PrecedenceMatchesSchedulerType(precedence));
+  DCHECK(precedence.is_spdy3_priority());
   if (is_static_stream) {
     static_stream_collection_.Register(stream_id);
     return;
   }
 
-  priority_write_scheduler_->RegisterStream(stream_id, precedence);
+  priority_write_scheduler_.RegisterStream(stream_id, precedence);
 }
 
 void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id,
@@ -130,22 +83,19 @@
     static_stream_collection_.Unregister(stream_id);
     return;
   }
-  priority_write_scheduler_->UnregisterStream(stream_id);
+  priority_write_scheduler_.UnregisterStream(stream_id);
 }
 
 void QuicWriteBlockedList::UpdateStreamPriority(
     QuicStreamId stream_id,
     const spdy::SpdyStreamPrecedence& new_precedence) {
   DCHECK(!static_stream_collection_.IsRegistered(stream_id));
-  DCHECK(PrecedenceMatchesSchedulerType(new_precedence));
-  priority_write_scheduler_->UpdateStreamPrecedence(stream_id, new_precedence);
+  DCHECK(new_precedence.is_spdy3_priority());
+  priority_write_scheduler_.UpdateStreamPrecedence(stream_id, new_precedence);
 }
 
 void QuicWriteBlockedList::UpdateBytesForStream(QuicStreamId stream_id,
                                                 size_t bytes) {
-  if (scheduler_type_ != spdy::WriteSchedulerType::SPDY) {
-    return;
-  }
   if (batch_write_stream_id_[last_priority_popped_] == stream_id) {
     // If this was the last data stream popped by PopFront, update the
     // bytes remaining in its batch write.
@@ -160,10 +110,9 @@
   }
 
   bool push_front =
-      scheduler_type_ == spdy::WriteSchedulerType::SPDY &&
       stream_id == batch_write_stream_id_[last_priority_popped_] &&
       bytes_left_for_batch_write_[last_priority_popped_] > 0;
-  priority_write_scheduler_->MarkStreamReady(stream_id, push_front);
+  priority_write_scheduler_.MarkStreamReady(stream_id, push_front);
 }
 
 bool QuicWriteBlockedList::IsStreamBlocked(QuicStreamId stream_id) const {
@@ -173,25 +122,7 @@
     }
   }
 
-  return priority_write_scheduler_->IsStreamReady(stream_id);
-}
-
-bool QuicWriteBlockedList::PrecedenceMatchesSchedulerType(
-    const spdy::SpdyStreamPrecedence& precedence) {
-  switch (scheduler_type_) {
-    case spdy::WriteSchedulerType::LIFO:
-      break;
-    case spdy::WriteSchedulerType::SPDY:
-      return precedence.is_spdy3_priority();
-    case spdy::WriteSchedulerType::HTTP2:
-      return !precedence.is_spdy3_priority();
-    case spdy::WriteSchedulerType::FIFO:
-      break;
-    default:
-      DCHECK(false);
-      return false;
-  }
-  return true;
+  return priority_write_scheduler_.IsStreamReady(stream_id);
 }
 
 void QuicWriteBlockedList::StaticStreamCollection::Register(QuicStreamId id) {
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index 7b5f29f..2d87847 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -26,9 +26,6 @@
 // priority.  QUIC stream priority order is:
 // Crypto stream > Headers stream > Data streams by requested priority.
 class QUIC_EXPORT_PRIVATE QuicWriteBlockedList {
- private:
-  using QuicPriorityWriteScheduler = spdy::WriteScheduler<QuicStreamId>;
-
  public:
   explicit QuicWriteBlockedList(QuicTransportVersion version);
   QuicWriteBlockedList(const QuicWriteBlockedList&) = delete;
@@ -36,7 +33,7 @@
   ~QuicWriteBlockedList();
 
   bool HasWriteBlockedDataStreams() const {
-    return priority_write_scheduler_->HasReadyStreams();
+    return priority_write_scheduler_.HasReadyStreams();
   }
 
   bool HasWriteBlockedSpecialStream() const {
@@ -49,20 +46,15 @@
 
   size_t NumBlockedStreams() const {
     return NumBlockedSpecialStreams() +
-           priority_write_scheduler_->NumReadyStreams();
+           priority_write_scheduler_.NumReadyStreams();
   }
 
   bool ShouldYield(QuicStreamId id) const;
 
   spdy::SpdyPriority GetSpdyPriorityofStream(QuicStreamId id) const {
-    return priority_write_scheduler_->GetStreamPrecedence(id).spdy3_priority();
+    return priority_write_scheduler_.GetStreamPrecedence(id).spdy3_priority();
   }
 
-  // Switches write scheduler. This can only be called before any stream is
-  // registered.
-  bool SwitchWriteScheduler(spdy::WriteSchedulerType type,
-                            QuicTransportVersion version);
-
   // Pops the highest priority stream, special casing crypto and headers
   // streams. Latches the most recently popped data stream for batch writing
   // purposes.
@@ -88,13 +80,8 @@
   // Returns true if stream with |stream_id| is write blocked.
   bool IsStreamBlocked(QuicStreamId stream_id) const;
 
-  spdy::WriteSchedulerType scheduler_type() const { return scheduler_type_; }
-
  private:
-  bool PrecedenceMatchesSchedulerType(
-      const spdy::SpdyStreamPrecedence& precedence);
-
-  std::unique_ptr<QuicPriorityWriteScheduler> priority_write_scheduler_;
+  spdy::PriorityWriteScheduler<QuicStreamId> priority_write_scheduler_;
 
   // If performing batch writes, this will be the stream ID of the stream doing
   // batch writes for this priority level.  We will allow this stream to write
@@ -152,8 +139,6 @@
   };
 
   StaticStreamCollection static_stream_collection_;
-
-  spdy::WriteSchedulerType scheduler_type_;
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_write_blocked_list_test.cc b/quic/core/quic_write_blocked_list_test.cc
index 9ce822d..7cf7797 100644
--- a/quic/core/quic_write_blocked_list_test.cc
+++ b/quic/core/quic_write_blocked_list_test.cc
@@ -15,73 +15,37 @@
 namespace test {
 namespace {
 
-const bool kExclusiveBit = true;
-
 class QuicWriteBlockedListTest : public QuicTestWithParam<bool> {
  public:
   QuicWriteBlockedListTest()
-      : write_blocked_list_(AllSupportedVersions()[0].transport_version) {
-    if (GetParam()) {
-      write_blocked_list_.SwitchWriteScheduler(
-          spdy::WriteSchedulerType::HTTP2,
-          AllSupportedVersions()[0].transport_version);
-    }
-  }
+      : write_blocked_list_(AllSupportedVersions()[0].transport_version) {}
 
  protected:
   QuicWriteBlockedList write_blocked_list_;
 };
 
-INSTANTIATE_TEST_SUITE_P(Tests,
-                         QuicWriteBlockedListTest,
-                         ::testing::Bool(),
-                         ::testing::PrintToStringParamName());
-
-TEST_P(QuicWriteBlockedListTest, PriorityOrder) {
-  if (GetParam()) {
-    /*
-         0
-         |
-         23
-         |
-         17
-         |
-         40
-    */
-    write_blocked_list_.RegisterStream(
-        17, false,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        40, false,
-        spdy::SpdyStreamPrecedence(17, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        23, false,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        1, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        3, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-  } else {
-    // Mark streams blocked in roughly reverse priority order, and
-    // verify that streams are sorted.
-    write_blocked_list_.RegisterStream(
-        40, false, spdy::SpdyStreamPrecedence(kV3LowestPriority));
-    write_blocked_list_.RegisterStream(
-        23, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(
-        17, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(
-        1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(
-        3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  }
+TEST_F(QuicWriteBlockedListTest, PriorityOrder) {
+  /*
+       0
+       |
+       23
+       |
+       17
+       |
+       40
+  */
+  // Mark streams blocked in roughly reverse priority order, and
+  // verify that streams are sorted.
+  write_blocked_list_.RegisterStream(
+      40, false, spdy::SpdyStreamPrecedence(kV3LowestPriority));
+  write_blocked_list_.RegisterStream(
+      23, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(
+      17, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(
+      1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(
+      3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
   write_blocked_list_.AddStream(40);
   EXPECT_TRUE(write_blocked_list_.IsStreamBlocked(40));
@@ -120,16 +84,9 @@
   EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
 }
 
-TEST_P(QuicWriteBlockedListTest, CryptoStream) {
-  if (GetParam()) {
-    write_blocked_list_.RegisterStream(
-        1, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-  } else {
-    write_blocked_list_.RegisterStream(
-        1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  }
+TEST_F(QuicWriteBlockedListTest, CryptoStream) {
+  write_blocked_list_.RegisterStream(
+      1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
   write_blocked_list_.AddStream(1);
 
   EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
@@ -139,16 +96,9 @@
   EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
 }
 
-TEST_P(QuicWriteBlockedListTest, HeadersStream) {
-  if (GetParam()) {
-    write_blocked_list_.RegisterStream(
-        3, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-  } else {
-    write_blocked_list_.RegisterStream(
-        3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  }
+TEST_F(QuicWriteBlockedListTest, HeadersStream) {
+  write_blocked_list_.RegisterStream(
+      3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
   write_blocked_list_.AddStream(3);
 
   EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
@@ -158,22 +108,11 @@
   EXPECT_FALSE(write_blocked_list_.HasWriteBlockedSpecialStream());
 }
 
-TEST_P(QuicWriteBlockedListTest, VerifyHeadersStream) {
-  if (GetParam()) {
-    write_blocked_list_.RegisterStream(
-        5, false,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        3, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-  } else {
-    write_blocked_list_.RegisterStream(
-        5, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(
-        3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  }
+TEST_F(QuicWriteBlockedListTest, VerifyHeadersStream) {
+  write_blocked_list_.RegisterStream(
+      5, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(
+      3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
   write_blocked_list_.AddStream(5);
   write_blocked_list_.AddStream(3);
 
@@ -189,20 +128,13 @@
   EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
 }
 
-TEST_P(QuicWriteBlockedListTest, NoDuplicateEntries) {
+TEST_F(QuicWriteBlockedListTest, NoDuplicateEntries) {
   // Test that QuicWriteBlockedList doesn't allow duplicate entries.
   // Try to add a stream to the write blocked list multiple times at the same
   // priority.
   const QuicStreamId kBlockedId = 3 + 2;
-  if (GetParam()) {
-    write_blocked_list_.RegisterStream(
-        kBlockedId, false,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-  } else {
     write_blocked_list_.RegisterStream(
         kBlockedId, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  }
   write_blocked_list_.AddStream(kBlockedId);
   write_blocked_list_.AddStream(kBlockedId);
   write_blocked_list_.AddStream(kBlockedId);
@@ -217,10 +149,7 @@
   EXPECT_FALSE(write_blocked_list_.HasWriteBlockedDataStreams());
 }
 
-TEST_P(QuicWriteBlockedListTest, BatchingWrites) {
-  if (GetParam()) {
-    return;
-  }
+TEST_F(QuicWriteBlockedListTest, BatchingWrites) {
   const QuicStreamId id1 = 3 + 2;
   const QuicStreamId id2 = id1 + 2;
   const QuicStreamId id3 = id2 + 2;
@@ -273,62 +202,31 @@
   EXPECT_EQ(id1, write_blocked_list_.PopFront());
 }
 
-TEST_P(QuicWriteBlockedListTest, Ceding) {
-  if (GetParam()) {
-    /*
-         0
-         |
-         15
-         |
-         16
-         |
-         5
-         |
-         4
-         |
-         7
-    */
-    write_blocked_list_.RegisterStream(
-        15, false,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        16, false,
-        spdy::SpdyStreamPrecedence(15, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        4, false,
-        spdy::SpdyStreamPrecedence(16, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        5, false,
-        spdy::SpdyStreamPrecedence(16, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        7, false,
-        spdy::SpdyStreamPrecedence(4, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        1, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-    write_blocked_list_.RegisterStream(
-        3, true,
-        spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight,
-                                   kExclusiveBit));
-  } else {
-    write_blocked_list_.RegisterStream(
-        15, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(
-        16, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(5, false, spdy::SpdyStreamPrecedence(5));
-    write_blocked_list_.RegisterStream(4, false, spdy::SpdyStreamPrecedence(5));
-    write_blocked_list_.RegisterStream(7, false, spdy::SpdyStreamPrecedence(7));
-    write_blocked_list_.RegisterStream(
-        1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-    write_blocked_list_.RegisterStream(
-        3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
-  }
+TEST_F(QuicWriteBlockedListTest, Ceding) {
+  /*
+       0
+       |
+       15
+       |
+       16
+       |
+       5
+       |
+       4
+       |
+       7
+  */
+  write_blocked_list_.RegisterStream(
+      15, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(
+      16, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(5, false, spdy::SpdyStreamPrecedence(5));
+  write_blocked_list_.RegisterStream(4, false, spdy::SpdyStreamPrecedence(5));
+  write_blocked_list_.RegisterStream(7, false, spdy::SpdyStreamPrecedence(7));
+  write_blocked_list_.RegisterStream(
+      1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  write_blocked_list_.RegisterStream(
+      3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
   // When nothing is on the list, nothing yields.
   EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
@@ -366,66 +264,6 @@
   EXPECT_FALSE(write_blocked_list_.ShouldYield(1));
 }
 
-TEST_P(QuicWriteBlockedListTest, UpdateStreamPriority) {
-  if (!GetParam()) {
-    return;
-  }
-  /*
-       0
-       |
-       5
-       |
-       7
-       |
-       9
-       |
-       11
-  */
-  write_blocked_list_.RegisterStream(
-      5, false,
-      spdy::SpdyStreamPrecedence(0, kHttp2DefaultStreamWeight, kExclusiveBit));
-  write_blocked_list_.RegisterStream(
-      7, false,
-      spdy::SpdyStreamPrecedence(5, kHttp2DefaultStreamWeight, kExclusiveBit));
-  write_blocked_list_.RegisterStream(
-      9, false,
-      spdy::SpdyStreamPrecedence(7, kHttp2DefaultStreamWeight, kExclusiveBit));
-  write_blocked_list_.RegisterStream(
-      11, false,
-      spdy::SpdyStreamPrecedence(9, kHttp2DefaultStreamWeight, kExclusiveBit));
-
-  write_blocked_list_.AddStream(7);
-  EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
-  EXPECT_TRUE(write_blocked_list_.ShouldYield(9));
-  EXPECT_TRUE(write_blocked_list_.ShouldYield(11));
-
-  // Update 9's priority.
-  if (GetParam()) {
-    /*
-         0
-         |
-         5
-        / \
-       7   9
-           |
-           11
-    */
-    write_blocked_list_.UpdateStreamPriority(
-        9, spdy::SpdyStreamPrecedence(5, kHttp2DefaultStreamWeight,
-                                      kExclusiveBit));
-  } else {
-    write_blocked_list_.UpdateStreamPriority(9, spdy::SpdyStreamPrecedence(1));
-  }
-  EXPECT_FALSE(write_blocked_list_.ShouldYield(5));
-  // Verify 9 now does not yield to 7.
-  EXPECT_FALSE(write_blocked_list_.ShouldYield(9));
-  EXPECT_FALSE(write_blocked_list_.ShouldYield(11));
-
-  write_blocked_list_.AddStream(9);
-  // Verify 11 yield to 9.
-  EXPECT_TRUE(write_blocked_list_.ShouldYield(11));
-}
-
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 33bad6b..740b591 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -65,7 +65,7 @@
     const std::string& request_url,
     const std::list<QuicBackendResponse::ServerPushInfo>& resources,
     QuicStreamId original_stream_id,
-    const spdy::SpdyStreamPrecedence& original_precedence,
+    const spdy::SpdyStreamPrecedence& /* original_precedence */,
     const spdy::Http2HeaderBlock& original_request_headers) {
   if (!server_push_enabled()) {
     return;
@@ -85,11 +85,9 @@
     highest_promised_stream_id_ = new_highest_promised_stream_id;
     SendPushPromise(original_stream_id, highest_promised_stream_id_,
                     headers.Clone());
-    promised_streams_.push_back(PromisedStreamInfo(
-        std::move(headers), highest_promised_stream_id_,
-        use_http2_priority_write_scheduler()
-            ? original_precedence
-            : spdy::SpdyStreamPrecedence(resource.priority)));
+    promised_streams_.push_back(
+        PromisedStreamInfo(std::move(headers), highest_promised_stream_id_,
+                           spdy::SpdyStreamPrecedence(resource.priority)));
   }
 
   // Procese promised push request as many as possible.