diff --git a/quiche/http2/adapter/oghttp2_session.cc b/quiche/http2/adapter/oghttp2_session.cc
index a760bbc..5f8b5ef 100644
--- a/quiche/http2/adapter/oghttp2_session.cc
+++ b/quiche/http2/adapter/oghttp2_session.cc
@@ -1769,8 +1769,8 @@
                   std::move(listener), options_.should_window_update_fn));
   if (inserted) {
     // Add the stream to the write scheduler.
-    const WriteScheduler::StreamPrecedenceType precedence(3);
-    write_scheduler_.RegisterStream(stream_id, precedence);
+    const spdy::SpdyPriority priority = 3;
+    write_scheduler_.RegisterStream(stream_id, priority);
 
     highest_processed_stream_id_ =
         std::max(highest_processed_stream_id_, stream_id);
diff --git a/quiche/http2/core/priority_write_scheduler.h b/quiche/http2/core/priority_write_scheduler.h
index ff867a9..54181f3 100644
--- a/quiche/http2/core/priority_write_scheduler.h
+++ b/quiche/http2/core/priority_write_scheduler.h
@@ -44,7 +44,7 @@
 template <typename StreamIdType>
 class QUICHE_EXPORT PriorityWriteScheduler {
  public:
-  using StreamPrecedenceType = spdy::StreamPrecedence<StreamIdType>;
+  using PriorityType = spdy::SpdyPriority;
 
   static constexpr int kHighestPriority = 0;
   static constexpr int kLowestPriority = 7;
@@ -53,16 +53,12 @@
   static_assert(spdy::kV3LowestPriority == kLowestPriority);
 
   // Registers new stream `stream_id` with the scheduler, assigning it the
-  // given precedence. If the scheduler supports stream dependencies, the
-  // stream is inserted into the dependency tree under
-  // `precedence.parent_id()`.
+  // given priority.
   //
-  // Preconditions: `stream_id` should be unregistered, and
-  // `precedence.parent_id()` should be registered or `kHttp2RootStreamId`.
-  void RegisterStream(StreamIdType stream_id,
-                      const StreamPrecedenceType& precedence) {
-    auto stream_info = std::make_unique<StreamInfo>(
-        StreamInfo{precedence.spdy3_priority(), stream_id, false});
+  // Preconditions: `stream_id` should be unregistered.
+  void RegisterStream(StreamIdType stream_id, PriorityType priority) {
+    auto stream_info =
+        std::make_unique<StreamInfo>(StreamInfo{priority, stream_id, false});
     bool inserted =
         stream_infos_.insert(std::make_pair(stream_id, std::move(stream_info)))
             .second;
@@ -94,29 +90,22 @@
     return stream_infos_.find(stream_id) != stream_infos_.end();
   }
 
-  // Returns the precedence of the specified stream. If the scheduler supports
-  // stream dependencies, calling `parent_id()` on the return value returns the
-  // stream's parent, and calling `exclusive()` returns true iff the specified
-  // stream is an only child of the parent stream.
+  // Returns the priority of the specified stream.
   //
   // Preconditions: `stream_id` should be registered.
-  StreamPrecedenceType GetStreamPrecedence(StreamIdType stream_id) const {
+  PriorityType GetStreamPriority(StreamIdType stream_id) const {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
       QUICHE_DVLOG(1) << "Stream " << stream_id << " not registered";
-      return StreamPrecedenceType(kLowestPriority);
+      return kLowestPriority;
     }
-    return StreamPrecedenceType(it->second->priority);
+    return it->second->priority;
   }
 
-  // Updates the precedence of the given stream. If the scheduler supports
-  // stream dependencies, `stream_id`'s parent will be updated to be
-  // `precedence.parent_id()` if it is not already.
+  // Updates the priority of the given stream.
   //
-  // Preconditions: `stream_id` should be unregistered, and
-  // `precedence.parent_id()` should be registered or `kHttp2RootStreamId`.
-  void UpdateStreamPrecedence(StreamIdType stream_id,
-                              const StreamPrecedenceType& precedence) {
+  // Preconditions: `stream_id` should be registered.
+  void UpdateStreamPriority(StreamIdType stream_id, PriorityType priority) {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
       // TODO(mpw): add to stream_infos_ on demand--see b/15676312.
@@ -124,27 +113,17 @@
       return;
     }
     StreamInfo* const stream_info = it->second.get();
-    spdy::SpdyPriority new_priority = precedence.spdy3_priority();
-    if (stream_info->priority == new_priority) {
+    if (stream_info->priority == priority) {
       return;
     }
     if (stream_info->ready) {
       bool erased = Erase(&priority_infos_[stream_info->priority].ready_list,
                           stream_info);
       QUICHE_DCHECK(erased);
-      priority_infos_[new_priority].ready_list.push_back(stream_info);
+      priority_infos_[priority].ready_list.push_back(stream_info);
       ++num_ready_streams_;
     }
-    stream_info->priority = new_priority;
-  }
-
-  // Returns child streams of the given stream, if any. If the scheduler
-  // doesn't support stream dependencies, returns an empty vector.
-  //
-  // Preconditions: `stream_id` should be registered.
-  std::vector<StreamIdType> GetStreamChildren(
-      StreamIdType /*stream_id*/) const {
-    return std::vector<StreamIdType>();
+    stream_info->priority = priority;
   }
 
   // Records time (in microseconds) of a read/write event for the given
@@ -167,7 +146,7 @@
   // is no such event.
   //
   // Preconditions: `stream_id` should be registered.
-  int64_t GetLatestEventWithPrecedence(StreamIdType stream_id) const {
+  int64_t GetLatestEventWithPriority(StreamIdType stream_id) const {
     auto it = stream_infos_.find(stream_id);
     if (it == stream_infos_.end()) {
       QUICHE_BUG(spdy_bug_19_5) << "Stream " << stream_id << " not registered";
@@ -175,8 +154,7 @@
     }
     int64_t last_event_time_usec = 0;
     const StreamInfo* const stream_info = it->second.get();
-    for (spdy::SpdyPriority p = kHighestPriority; p < stream_info->priority;
-         ++p) {
+    for (PriorityType p = kHighestPriority; p < stream_info->priority; ++p) {
       last_event_time_usec = std::max(last_event_time_usec,
                                       priority_infos_[p].last_event_time_usec);
     }
@@ -189,7 +167,7 @@
   //
   // Preconditions: `HasReadyStreams() == true`
   StreamIdType PopNextReadyStream() {
-    return std::get<0>(PopNextReadyStreamAndPrecedence());
+    return std::get<0>(PopNextReadyStreamAndPriority());
   }
 
   // If the scheduler has any ready streams, returns the next scheduled
@@ -197,9 +175,8 @@
   // ready to not ready.
   //
   // Preconditions: `HasReadyStreams() == true`
-  std::tuple<StreamIdType, StreamPrecedenceType>
-  PopNextReadyStreamAndPrecedence() {
-    for (spdy::SpdyPriority p = kHighestPriority; p <= kLowestPriority; ++p) {
+  std::tuple<StreamIdType, PriorityType> PopNextReadyStreamAndPriority() {
+    for (PriorityType p = kHighestPriority; p <= kLowestPriority; ++p) {
       ReadyList& ready_list = priority_infos_[p].ready_list;
       if (!ready_list.empty()) {
         StreamInfo* const info = ready_list.front();
@@ -209,12 +186,11 @@
         QUICHE_DCHECK(stream_infos_.find(info->stream_id) !=
                       stream_infos_.end());
         info->ready = false;
-        return std::make_tuple(info->stream_id,
-                               StreamPrecedenceType(info->priority));
+        return std::make_tuple(info->stream_id, info->priority);
       }
     }
     QUICHE_BUG(spdy_bug_19_6) << "No ready streams available";
-    return std::make_tuple(0, StreamPrecedenceType(kLowestPriority));
+    return std::make_tuple(0, kLowestPriority);
   }
 
   // Returns true if there's another stream ahead of the given stream in the
@@ -231,8 +207,7 @@
 
     // If there's a higher priority stream, this stream should yield.
     const StreamInfo* const stream_info = it->second.get();
-    for (spdy::SpdyPriority p = kHighestPriority; p < stream_info->priority;
-         ++p) {
+    for (PriorityType p = kHighestPriority; p < stream_info->priority; ++p) {
       if (!priority_infos_[p].ready_list.empty()) {
         return true;
       }
@@ -324,10 +299,11 @@
  private:
   friend class test::PriorityWriteSchedulerPeer<StreamIdType>;
 
-  // State kept for all registered streams. All ready streams have ready = true
-  // and should be present in priority_infos_[priority].ready_list.
+  // State kept for all registered streams.
+  // All ready streams have `ready == true` and should be present in
+  // `priority_infos_[priority].ready_list`.
   struct QUICHE_EXPORT StreamInfo {
-    spdy::SpdyPriority priority;
+    PriorityType priority;
     StreamIdType stream_id;
     bool ready;
   };
diff --git a/quiche/http2/core/priority_write_scheduler_test.cc b/quiche/http2/core/priority_write_scheduler_test.cc
index e8a54dd..8a4e518 100644
--- a/quiche/http2/core/priority_write_scheduler_test.cc
+++ b/quiche/http2/core/priority_write_scheduler_test.cc
@@ -15,7 +15,6 @@
 using ::spdy::kHttp2RootStreamId;
 using ::spdy::SpdyPriority;
 using ::spdy::SpdyStreamId;
-using ::spdy::SpdyStreamPrecedence;
 
 template <typename StreamIdType>
 class PriorityWriteSchedulerPeer {
@@ -49,20 +48,20 @@
   EXPECT_FALSE(scheduler_.HasReadyStreams());
   EXPECT_FALSE(scheduler_.StreamRegistered(1));
   EXPECT_EQ(0u, scheduler_.NumRegisteredStreams());
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(1));
+  scheduler_.RegisterStream(1, 1);
   EXPECT_TRUE(scheduler_.StreamRegistered(1));
   EXPECT_EQ(1u, scheduler_.NumRegisteredStreams());
 
   // Try redundant registrations.
-  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(1)),
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, 1),
                     "Stream 1 already registered");
   EXPECT_EQ(1u, scheduler_.NumRegisteredStreams());
 
-  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(2)),
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, 2),
                     "Stream 1 already registered");
   EXPECT_EQ(1u, scheduler_.NumRegisteredStreams());
 
-  scheduler_.RegisterStream(2, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(2, 3);
   EXPECT_EQ(2u, scheduler_.NumRegisteredStreams());
 
   // Verify registration != ready.
@@ -79,101 +78,70 @@
   EXPECT_EQ(0u, scheduler_.NumRegisteredStreams());
 }
 
-TEST_F(PriorityWriteSchedulerTest, RegisterStreamWithHttp2StreamDependency) {
-  EXPECT_FALSE(scheduler_.HasReadyStreams());
-  EXPECT_FALSE(scheduler_.StreamRegistered(1));
-  scheduler_.RegisterStream(
-      1, SpdyStreamPrecedence(kHttp2RootStreamId, 123, false));
-  EXPECT_TRUE(scheduler_.StreamRegistered(1));
-  EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority());
-  EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
-  EXPECT_FALSE(scheduler_.HasReadyStreams());
-
-  EXPECT_QUICHE_BUG(
-      scheduler_.RegisterStream(
-          1, SpdyStreamPrecedence(kHttp2RootStreamId, 256, false)),
-      "Stream 1 already registered");
-  EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority());
-  EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
-
-  // Registering stream with a non-existent parent stream is permissible, per
-  // b/15676312, but parent stream will always be reset to 0.
-  scheduler_.RegisterStream(2, SpdyStreamPrecedence(3, 123, false));
-  EXPECT_TRUE(scheduler_.StreamRegistered(2));
-  EXPECT_FALSE(scheduler_.StreamRegistered(3));
-  EXPECT_EQ(kHttp2RootStreamId, scheduler_.GetStreamPrecedence(2).parent_id());
-}
-
-TEST_F(PriorityWriteSchedulerTest, GetStreamPrecedence) {
+TEST_F(PriorityWriteSchedulerTest, GetStreamPriority) {
   // Unknown streams tolerated due to b/15676312. However, return lowest
   // priority.
-  EXPECT_EQ(kLowestPriority,
-            scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(1));
 
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(3));
-  EXPECT_TRUE(scheduler_.GetStreamPrecedence(1).is_spdy3_priority());
-  EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  scheduler_.RegisterStream(1, 3);
+  EXPECT_EQ(3, scheduler_.GetStreamPriority(1));
 
   // Redundant registration shouldn't change stream priority.
-  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, SpdyStreamPrecedence(4)),
+  EXPECT_QUICHE_BUG(scheduler_.RegisterStream(1, 4),
                     "Stream 1 already registered");
-  EXPECT_EQ(3, scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  EXPECT_EQ(3, scheduler_.GetStreamPriority(1));
 
-  scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(5));
-  EXPECT_EQ(5, scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  scheduler_.UpdateStreamPriority(1, 5);
+  EXPECT_EQ(5, scheduler_.GetStreamPriority(1));
 
   // Toggling ready state shouldn't change stream priority.
   scheduler_.MarkStreamReady(1, true);
-  EXPECT_EQ(5, scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  EXPECT_EQ(5, scheduler_.GetStreamPriority(1));
 
   // Test changing priority of ready stream.
   EXPECT_EQ(1u, peer_.NumReadyStreams(5));
-  scheduler_.UpdateStreamPrecedence(1, SpdyStreamPrecedence(6));
-  EXPECT_EQ(6, scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  scheduler_.UpdateStreamPriority(1, 6);
+  EXPECT_EQ(6, scheduler_.GetStreamPriority(1));
   EXPECT_EQ(0u, peer_.NumReadyStreams(5));
   EXPECT_EQ(1u, peer_.NumReadyStreams(6));
 
   EXPECT_EQ(1u, scheduler_.PopNextReadyStream());
-  EXPECT_EQ(6, scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  EXPECT_EQ(6, scheduler_.GetStreamPriority(1));
 
   scheduler_.UnregisterStream(1);
-  EXPECT_EQ(kLowestPriority,
-            scheduler_.GetStreamPrecedence(1).spdy3_priority());
+  EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(1));
 }
 
-TEST_F(PriorityWriteSchedulerTest, PopNextReadyStreamAndPrecedence) {
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(3));
+TEST_F(PriorityWriteSchedulerTest, PopNextReadyStreamAndPriority) {
+  scheduler_.RegisterStream(1, 3);
   scheduler_.MarkStreamReady(1, true);
-  EXPECT_EQ(std::make_tuple(1u, SpdyStreamPrecedence(3)),
-            scheduler_.PopNextReadyStreamAndPrecedence());
+  EXPECT_EQ(std::make_tuple(1u, 3), scheduler_.PopNextReadyStreamAndPriority());
   scheduler_.UnregisterStream(1);
 }
 
-TEST_F(PriorityWriteSchedulerTest, UpdateStreamPrecedence) {
-  // For the moment, updating stream precedence on a non-registered stream
-  // should have no effect. In the future, it will lazily cause the stream to
-  // be registered (b/15676312).
-  EXPECT_EQ(kLowestPriority,
-            scheduler_.GetStreamPrecedence(3).spdy3_priority());
+TEST_F(PriorityWriteSchedulerTest, UpdateStreamPriority) {
+  // For the moment, updating stream priority on a non-registered stream should
+  // have no effect. In the future, it will lazily cause the stream to be
+  // registered (b/15676312).
+  EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(3));
   EXPECT_FALSE(scheduler_.StreamRegistered(3));
-  scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(1));
+  scheduler_.UpdateStreamPriority(3, 1);
   EXPECT_FALSE(scheduler_.StreamRegistered(3));
-  EXPECT_EQ(kLowestPriority,
-            scheduler_.GetStreamPrecedence(3).spdy3_priority());
+  EXPECT_EQ(kLowestPriority, scheduler_.GetStreamPriority(3));
 
-  scheduler_.RegisterStream(3, SpdyStreamPrecedence(1));
-  EXPECT_EQ(1, scheduler_.GetStreamPrecedence(3).spdy3_priority());
-  scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(2));
-  EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).spdy3_priority());
+  scheduler_.RegisterStream(3, 1);
+  EXPECT_EQ(1, scheduler_.GetStreamPriority(3));
+  scheduler_.UpdateStreamPriority(3, 2);
+  EXPECT_EQ(2, scheduler_.GetStreamPriority(3));
 
   // Updating priority of stream to current priority value is valid, but has no
   // effect.
-  scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(2));
-  EXPECT_EQ(2, scheduler_.GetStreamPrecedence(3).spdy3_priority());
+  scheduler_.UpdateStreamPriority(3, 2);
+  EXPECT_EQ(2, scheduler_.GetStreamPriority(3));
 
   // Even though stream 4 is marked ready after stream 5, it should be returned
   // first by PopNextReadyStream() since it has higher priority.
-  scheduler_.RegisterStream(4, SpdyStreamPrecedence(1));
+  scheduler_.RegisterStream(4, 1);
   scheduler_.MarkStreamReady(3, false);  // priority 2
   EXPECT_TRUE(scheduler_.IsStreamReady(3));
   scheduler_.MarkStreamReady(4, false);  // priority 1
@@ -187,29 +155,13 @@
   // by PopNextReadyStream().
   scheduler_.MarkStreamReady(3, false);  // priority 2
   scheduler_.MarkStreamReady(4, false);  // priority 1
-  scheduler_.UpdateStreamPrecedence(4, SpdyStreamPrecedence(3));
+  scheduler_.UpdateStreamPriority(4, 3);
   EXPECT_EQ(3u, scheduler_.PopNextReadyStream());
   EXPECT_EQ(4u, scheduler_.PopNextReadyStream());
 
   scheduler_.UnregisterStream(3);
 }
 
-TEST_F(PriorityWriteSchedulerTest,
-       UpdateStreamPrecedenceWithHttp2StreamDependency) {
-  // Unknown streams tolerated due to b/15676312, but should have no effect.
-  scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false));
-  EXPECT_FALSE(scheduler_.StreamRegistered(3));
-
-  scheduler_.RegisterStream(3, SpdyStreamPrecedence(3));
-  scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false));
-  EXPECT_TRUE(scheduler_.GetStreamPrecedence(3).is_spdy3_priority());
-  EXPECT_EQ(4, scheduler_.GetStreamPrecedence(3).spdy3_priority());
-
-  scheduler_.UnregisterStream(3);
-  scheduler_.UpdateStreamPrecedence(3, SpdyStreamPrecedence(0, 100, false));
-  EXPECT_FALSE(scheduler_.StreamRegistered(3));
-}
-
 TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBack) {
   EXPECT_FALSE(scheduler_.HasReadyStreams());
   EXPECT_QUICHE_BUG(scheduler_.MarkStreamReady(1, false),
@@ -220,16 +172,16 @@
 
   // Add a bunch of ready streams to tail of per-priority lists.
   // Expected order: (P2) 4, (P3) 1, 2, 3, (P5) 5.
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(1, 3);
   scheduler_.MarkStreamReady(1, false);
   EXPECT_TRUE(scheduler_.HasReadyStreams());
-  scheduler_.RegisterStream(2, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(2, 3);
   scheduler_.MarkStreamReady(2, false);
-  scheduler_.RegisterStream(3, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(3, 3);
   scheduler_.MarkStreamReady(3, false);
-  scheduler_.RegisterStream(4, SpdyStreamPrecedence(2));
+  scheduler_.RegisterStream(4, 2);
   scheduler_.MarkStreamReady(4, false);
-  scheduler_.RegisterStream(5, SpdyStreamPrecedence(5));
+  scheduler_.RegisterStream(5, 5);
   scheduler_.MarkStreamReady(5, false);
 
   EXPECT_EQ(4u, scheduler_.PopNextReadyStream());
@@ -251,16 +203,16 @@
 
   // Add a bunch of ready streams to head of per-priority lists.
   // Expected order: (P2) 4, (P3) 3, 2, 1, (P5) 5
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(1, 3);
   scheduler_.MarkStreamReady(1, true);
   EXPECT_TRUE(scheduler_.HasReadyStreams());
-  scheduler_.RegisterStream(2, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(2, 3);
   scheduler_.MarkStreamReady(2, true);
-  scheduler_.RegisterStream(3, SpdyStreamPrecedence(3));
+  scheduler_.RegisterStream(3, 3);
   scheduler_.MarkStreamReady(3, true);
-  scheduler_.RegisterStream(4, SpdyStreamPrecedence(2));
+  scheduler_.RegisterStream(4, 2);
   scheduler_.MarkStreamReady(4, true);
-  scheduler_.RegisterStream(5, SpdyStreamPrecedence(5));
+  scheduler_.RegisterStream(5, 5);
   scheduler_.MarkStreamReady(5, true);
 
   EXPECT_EQ(4u, scheduler_.PopNextReadyStream());
@@ -273,12 +225,12 @@
 }
 
 TEST_F(PriorityWriteSchedulerTest, MarkStreamReadyBackAndFront) {
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(4));
-  scheduler_.RegisterStream(2, SpdyStreamPrecedence(3));
-  scheduler_.RegisterStream(3, SpdyStreamPrecedence(3));
-  scheduler_.RegisterStream(4, SpdyStreamPrecedence(3));
-  scheduler_.RegisterStream(5, SpdyStreamPrecedence(4));
-  scheduler_.RegisterStream(6, SpdyStreamPrecedence(1));
+  scheduler_.RegisterStream(1, 4);
+  scheduler_.RegisterStream(2, 3);
+  scheduler_.RegisterStream(3, 3);
+  scheduler_.RegisterStream(4, 3);
+  scheduler_.RegisterStream(5, 4);
+  scheduler_.RegisterStream(6, 1);
 
   // Add a bunch of ready streams to per-priority lists, with variety of adding
   // at head and tail.
@@ -302,7 +254,7 @@
 
 TEST_F(PriorityWriteSchedulerTest, MarkStreamNotReady) {
   // Verify ready state reflected in NumReadyStreams().
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(1));
+  scheduler_.RegisterStream(1, 1);
   EXPECT_EQ(0u, scheduler_.NumReadyStreams());
   scheduler_.MarkStreamReady(1, false);
   EXPECT_EQ(1u, scheduler_.NumReadyStreams());
@@ -323,7 +275,7 @@
 }
 
 TEST_F(PriorityWriteSchedulerTest, UnregisterRemovesStream) {
-  scheduler_.RegisterStream(3, SpdyStreamPrecedence(4));
+  scheduler_.RegisterStream(3, 4);
   scheduler_.MarkStreamReady(3, false);
   EXPECT_EQ(1u, scheduler_.NumReadyStreams());
 
@@ -335,10 +287,10 @@
 }
 
 TEST_F(PriorityWriteSchedulerTest, ShouldYield) {
-  scheduler_.RegisterStream(1, SpdyStreamPrecedence(1));
-  scheduler_.RegisterStream(4, SpdyStreamPrecedence(4));
-  scheduler_.RegisterStream(5, SpdyStreamPrecedence(4));
-  scheduler_.RegisterStream(7, SpdyStreamPrecedence(7));
+  scheduler_.RegisterStream(1, 1);
+  scheduler_.RegisterStream(4, 4);
+  scheduler_.RegisterStream(5, 4);
+  scheduler_.RegisterStream(7, 7);
 
   // Make sure we don't yield when the list is empty.
   EXPECT_FALSE(scheduler_.ShouldYield(1));
@@ -361,23 +313,23 @@
   EXPECT_TRUE(scheduler_.ShouldYield(5));
 }
 
-TEST_F(PriorityWriteSchedulerTest, GetLatestEventWithPrecedence) {
+TEST_F(PriorityWriteSchedulerTest, GetLatestEventWithPriority) {
   EXPECT_QUICHE_BUG(scheduler_.RecordStreamEventTime(3, 5),
                     "Stream 3 not registered");
-  EXPECT_QUICHE_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(4)),
+  EXPECT_QUICHE_BUG(EXPECT_EQ(0, scheduler_.GetLatestEventWithPriority(4)),
                     "Stream 4 not registered");
 
   for (int i = 1; i < 5; ++i) {
-    scheduler_.RegisterStream(i, SpdyStreamPrecedence(i));
+    scheduler_.RegisterStream(i, i);
   }
   for (int i = 1; i < 5; ++i) {
-    EXPECT_EQ(0, scheduler_.GetLatestEventWithPrecedence(i));
+    EXPECT_EQ(0, scheduler_.GetLatestEventWithPriority(i));
   }
   for (int i = 1; i < 5; ++i) {
     scheduler_.RecordStreamEventTime(i, i * 100);
   }
   for (int i = 1; i < 5; ++i) {
-    EXPECT_EQ((i - 1) * 100, scheduler_.GetLatestEventWithPrecedence(i));
+    EXPECT_EQ((i - 1) * 100, scheduler_.GetLatestEventWithPriority(i));
   }
 }
 
diff --git a/quiche/quic/core/quic_write_blocked_list.cc b/quiche/quic/core/quic_write_blocked_list.cc
index 9e53c94..473b154 100644
--- a/quiche/quic/core/quic_write_blocked_list.cc
+++ b/quiche/quic/core/quic_write_blocked_list.cc
@@ -35,11 +35,10 @@
     return static_stream_id;
   }
 
-  const auto id_and_precedence =
-      priority_write_scheduler_.PopNextReadyStreamAndPrecedence();
-  const QuicStreamId id = std::get<0>(id_and_precedence);
-  const spdy::SpdyPriority priority =
-      std::get<1>(id_and_precedence).spdy3_priority();
+  const auto id_and_priority =
+      priority_write_scheduler_.PopNextReadyStreamAndPriority();
+  const QuicStreamId id = std::get<0>(id_and_priority);
+  const spdy::SpdyPriority priority = std::get<1>(id_and_priority);
 
   if (!priority_write_scheduler_.HasReadyStreams()) {
     // If no streams are blocked, don't bother latching.  This stream will be
@@ -66,8 +65,7 @@
     return;
   }
 
-  priority_write_scheduler_.RegisterStream(
-      stream_id, spdy::SpdyStreamPrecedence(priority.urgency));
+  priority_write_scheduler_.RegisterStream(stream_id, priority.urgency);
 }
 
 void QuicWriteBlockedList::UnregisterStream(QuicStreamId stream_id,
@@ -82,8 +80,8 @@
 void QuicWriteBlockedList::UpdateStreamPriority(
     QuicStreamId stream_id, const QuicStreamPriority& new_priority) {
   QUICHE_DCHECK(!static_stream_collection_.IsRegistered(stream_id));
-  priority_write_scheduler_.UpdateStreamPrecedence(
-      stream_id, spdy::SpdyStreamPrecedence(new_priority.urgency));
+  priority_write_scheduler_.UpdateStreamPriority(stream_id,
+                                                 new_priority.urgency);
 }
 
 void QuicWriteBlockedList::UpdateBytesForStream(QuicStreamId stream_id,
diff --git a/quiche/quic/core/quic_write_blocked_list.h b/quiche/quic/core/quic_write_blocked_list.h
index 3a8fc6c..1bbff6e 100644
--- a/quiche/quic/core/quic_write_blocked_list.h
+++ b/quiche/quic/core/quic_write_blocked_list.h
@@ -51,7 +51,7 @@
   bool ShouldYield(QuicStreamId id) const;
 
   spdy::SpdyPriority GetSpdyPriorityofStream(QuicStreamId id) const {
-    return priority_write_scheduler_.GetStreamPrecedence(id).spdy3_priority();
+    return priority_write_scheduler_.GetStreamPriority(id);
   }
 
   // Pops the highest priority stream, special casing static streams. Latches