gfe-relnote: In QUIC, replaces QuicStream::priority_ with QuicStream::precedence_ and pluming it to write_blocked_list. No functional change expected. Not protected.

This is a preparation for using H2 priority.

PiperOrigin-RevId: 260000909
Change-Id: Ieee790614b259509ad12611e17e99511feedc423

quic/core/http/quic_headers_stream_test.cc

diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index ebfa6cc..89338a8 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -284,7 +284,8 @@
                                      _, _, NO_FIN))
         .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
     QuicSpdySessionPeer::WriteHeadersOnHeadersStream(
-        &session_, stream_id, headers_.Clone(), fin, priority, nullptr);
+        &session_, stream_id, headers_.Clone(), fin,
+        spdy::SpdyStreamPrecedence(priority), nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
     if (is_request) {
@@ -451,7 +452,8 @@
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
-          EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
+          EXPECT_CALL(session_, OnStreamHeadersPriority(
+                                    stream_id, spdy::SpdyStreamPrecedence(0)));
         } else {
           SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
@@ -536,7 +538,10 @@
             .WillRepeatedly(InvokeWithoutArgs(
                 this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
       } else {
-        EXPECT_CALL(session_, OnPriorityFrame(stream_id, priority)).Times(1);
+        EXPECT_CALL(
+            session_,
+            OnPriorityFrame(stream_id, spdy::SpdyStreamPrecedence(priority)))
+            .Times(1);
       }
       stream_frame_.data_buffer = frame.data();
       stream_frame_.data_length = frame.size();
@@ -588,7 +593,8 @@
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
-          EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
+          EXPECT_CALL(session_, OnStreamHeadersPriority(
+                                    stream_id, spdy::SpdyStreamPrecedence(0)));
         } else {
           SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);
@@ -778,7 +784,8 @@
           headers_frame.set_has_priority(true);
           headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0));
           frame = framer_->SerializeFrame(headers_frame);
-          EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
+          EXPECT_CALL(session_, OnStreamHeadersPriority(
+                                    stream_id, spdy::SpdyStreamPrecedence(0)));
         } else {
           SpdyHeadersIR headers_frame(stream_id, headers_.Clone());
           headers_frame.set_fin(fin);

quic/core/http/quic_receive_control_stream.cc

diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 93fae3a..922dc8c 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -237,7 +237,7 @@
   // that the server is not permitted to open. In that case, simply drop the
   // frame.
   if (stream) {
-    stream->SetPriority(priority.weight);
+    stream->SetPriority(spdy::SpdyStreamPrecedence(priority.weight));
   }
   return true;
 }

quic/core/http/quic_receive_control_stream_test.cc

diff --git a/quic/core/http/quic_receive_control_stream_test.cc b/quic/core/http/quic_receive_control_stream_test.cc
index aaf60e9..d5a3139 100644
--- a/quic/core/http/quic_receive_control_stream_test.cc
+++ b/quic/core/http/quic_receive_control_stream_test.cc
@@ -223,9 +223,9 @@
   QuicStreamFrame data(receive_control_stream_->id(), false, 0,
                        QuicStringPiece(serialized_frame));
 
-  EXPECT_EQ(3u, stream_->priority());
+  EXPECT_EQ(3u, stream_->precedence().spdy3_priority());
   receive_control_stream_->OnStreamFrame(data);
-  EXPECT_EQ(1u, stream_->priority());
+  EXPECT_EQ(1u, stream_->precedence().spdy3_priority());
 }
 
 TEST_P(QuicReceiveControlStreamTest, PushPromiseOnControlStreamShouldClose) {

quic/core/http/quic_server_session_base_test.cc

diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 0041c85..698193b 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -503,7 +503,8 @@
   QuicServerSessionBasePeer::SetCryptoStream(session_.get(), crypto_stream);
   session_->RegisterStreamPriority(
       QuicUtils::GetHeadersStreamId(connection_->transport_version()),
-      /*is_static=*/true, QuicStream::kDefaultPriority);
+      /*is_static=*/true,
+      spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority));
 
   // Set some initial bandwidth values.
   QuicSentPacketManager* sent_packet_manager =

quic/core/http/quic_spdy_session.cc

diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 3a55a34..6352d7b 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -215,11 +215,10 @@
       return;
     }
 
-    // TODO(mpw): avoid down-conversion and plumb SpdyStreamPrecedence through
-    // QuicHeadersStream.
     SpdyPriority priority =
         has_priority ? Http2WeightToSpdy3Priority(weight) : 0;
-    session_->OnHeaders(stream_id, has_priority, priority, fin);
+    session_->OnHeaders(stream_id, has_priority,
+                        spdy::SpdyStreamPrecedence(priority), fin);
   }
 
   void OnWindowUpdate(SpdyStreamId /*stream_id*/,
@@ -259,7 +258,7 @@
     // TODO (wangyix): implement real HTTP/2 weights and dependencies instead of
     // converting to SpdyPriority.
     SpdyPriority priority = Http2WeightToSpdy3Priority(weight);
-    session_->OnPriority(stream_id, priority);
+    session_->OnPriority(stream_id, spdy::SpdyStreamPrecedence(priority));
   }
 
   bool OnUnknownFrame(SpdyStreamId /*stream_id*/,
@@ -412,14 +411,15 @@
   QUIC_NOTREACHED();
 }
 
-void QuicSpdySession::OnStreamHeadersPriority(QuicStreamId stream_id,
-                                              SpdyPriority priority) {
+void QuicSpdySession::OnStreamHeadersPriority(
+    QuicStreamId stream_id,
+    const spdy::SpdyStreamPrecedence& precedence) {
   QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
   if (!stream) {
     // It's quite possible to receive headers after a stream has been reset.
     return;
   }
-  stream->OnStreamHeadersPriority(priority);
+  stream->OnStreamHeadersPriority(precedence);
 }
 
 void QuicSpdySession::OnStreamHeaderList(QuicStreamId stream_id,
@@ -460,15 +460,16 @@
   stream->OnStreamHeaderList(fin, frame_len, header_list);
 }
 
-void QuicSpdySession::OnPriorityFrame(QuicStreamId stream_id,
-                                      SpdyPriority priority) {
+void QuicSpdySession::OnPriorityFrame(
+    QuicStreamId stream_id,
+    const spdy::SpdyStreamPrecedence& precedence) {
   QuicSpdyStream* stream = GetSpdyDataStream(stream_id);
   if (!stream) {
     // It's quite possible to receive a PRIORITY frame after a stream has been
     // reset.
     return;
   }
-  stream->OnPriorityFrame(priority);
+  stream->OnPriorityFrame(precedence);
 }
 
 size_t QuicSpdySession::ProcessHeaderData(const struct iovec& iov) {
@@ -480,13 +481,14 @@
     QuicStreamId id,
     SpdyHeaderBlock headers,
     bool fin,
-    SpdyPriority priority,
+    const spdy::SpdyStreamPrecedence& precedence,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   DCHECK(!VersionUsesQpack(connection()->transport_version()));
 
   return WriteHeadersOnHeadersStreamImpl(
       id, std::move(headers), fin,
-      /* parent_stream_id = */ 0, Spdy3PriorityToHttp2Weight(priority),
+      /* parent_stream_id = */ 0,
+      Spdy3PriorityToHttp2Weight(precedence.spdy3_priority()),
       /* exclusive = */ false, std::move(ack_listener));
 }
 
@@ -644,7 +646,7 @@
 
 void QuicSpdySession::OnHeaders(SpdyStreamId stream_id,
                                 bool has_priority,
-                                SpdyPriority priority,
+                                const spdy::SpdyStreamPrecedence& precedence,
                                 bool fin) {
   if (has_priority) {
     if (perspective() == Perspective::IS_CLIENT) {
@@ -652,7 +654,7 @@
                                  "Server must not send priorities.");
       return;
     }
-    OnStreamHeadersPriority(stream_id, priority);
+    OnStreamHeadersPriority(stream_id, precedence);
   } else {
     if (perspective() == Perspective::IS_SERVER) {
       CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
@@ -681,13 +683,13 @@
 // TODO (wangyix): Why is SpdyStreamId used instead of QuicStreamId?
 // This occurs in many places in this file.
 void QuicSpdySession::OnPriority(SpdyStreamId stream_id,
-                                 SpdyPriority priority) {
+                                 const spdy::SpdyStreamPrecedence& precedence) {
   if (perspective() == Perspective::IS_CLIENT) {
     CloseConnectionWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                "Server must not send PRIORITY frames.");
     return;
   }
-  OnPriorityFrame(stream_id, priority);
+  OnPriorityFrame(stream_id, precedence);
 }
 
 void QuicSpdySession::OnHeaderList(const QuicHeaderList& header_list) {

quic/core/http/quic_spdy_session.h

diff --git a/quic/core/http/quic_spdy_session.h b/quic/core/http/quic_spdy_session.h
index a504e9c..3fe5c66 100644
--- a/quic/core/http/quic_spdy_session.h
+++ b/quic/core/http/quic_spdy_session.h
@@ -76,8 +76,9 @@
 
   // Called by |headers_stream_| when headers with a priority have been
   // received for a stream.  This method will only be called for server streams.
-  virtual void OnStreamHeadersPriority(QuicStreamId stream_id,
-                                       spdy::SpdyPriority priority);
+  virtual void OnStreamHeadersPriority(
+      QuicStreamId stream_id,
+      const spdy::SpdyStreamPrecedence& precedence);
 
   // Called by |headers_stream_| when headers have been completely received
   // for a stream.  |fin| will be true if the fin flag was set in the headers
@@ -98,7 +99,7 @@
   // Called by |headers_stream_| when a PRIORITY frame has been received for a
   // stream. This method will only be called for server streams.
   virtual void OnPriorityFrame(QuicStreamId stream_id,
-                               spdy::SpdyPriority priority);
+                               const spdy::SpdyStreamPrecedence& precedence);
 
   // Sends contents of |iov| to h2_deframer_, returns number of bytes processed.
   size_t ProcessHeaderData(const struct iovec& iov);
@@ -111,7 +112,7 @@
       QuicStreamId id,
       spdy::SpdyHeaderBlock headers,
       bool fin,
-      spdy::SpdyPriority priority,
+      const spdy::SpdyStreamPrecedence& precedence,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
 
   // Writes a PRIORITY frame the to peer. Returns the size in bytes of the
@@ -243,7 +244,7 @@
   // Called when a HEADERS frame has been received.
   void OnHeaders(spdy::SpdyStreamId stream_id,
                  bool has_priority,
-                 spdy::SpdyPriority priority,
+                 const spdy::SpdyStreamPrecedence& precedence,
                  bool fin);
 
   // Called when a PUSH_PROMISE frame has been received.
@@ -251,7 +252,8 @@
                      spdy::SpdyStreamId promised_stream_id);
 
   // Called when a PRIORITY frame has been received.
-  void OnPriority(spdy::SpdyStreamId stream_id, spdy::SpdyPriority priority);
+  void OnPriority(spdy::SpdyStreamId stream_id,
+                  const spdy::SpdyStreamPrecedence& precedence);
 
   // Called when the complete list of headers is available.
   void OnHeaderList(const QuicHeaderList& header_list);

quic/core/http/quic_spdy_session_test.cc

diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 2042f88..c36cdd7 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -654,7 +654,7 @@
   // Now let stream 4 do the 2nd of its 3 writes, but add a block for a high
   // priority stream 6.  4 should be preempted.  6 will write but *not* block so
   // will cede back to 4.
-  stream6->SetPriority(kV3HighestPriority);
+  stream6->SetPriority(spdy::SpdyStreamPrecedence(kV3HighestPriority));
   EXPECT_CALL(*stream4, OnCanWrite())
       .WillOnce(Invoke([this, stream4, stream6]() {
         session_.SendLargeFakeData(stream4, 6000);
@@ -1253,14 +1253,15 @@
     EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
     headers["header"] = QuicStrCat(random.RandUint64(), random.RandUint64(),
                                    random.RandUint64());
-    session_.WriteHeadersOnHeadersStream(stream_id, headers.Clone(), true, 0,
+    session_.WriteHeadersOnHeadersStream(stream_id, headers.Clone(), true,
+                                         spdy::SpdyStreamPrecedence(0),
                                          nullptr);
     stream_id += IdDelta();
   }
   // Write once more to ensure that the headers stream has buffered data. The
   // random headers may have exactly filled the flow control window.
-  session_.WriteHeadersOnHeadersStream(stream_id, std::move(headers), true, 0,
-                                       nullptr);
+  session_.WriteHeadersOnHeadersStream(stream_id, std::move(headers), true,
+                                       spdy::SpdyStreamPrecedence(0), nullptr);
   EXPECT_TRUE(headers_stream->HasBufferedData());
 
   EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
@@ -2006,8 +2007,10 @@
 TEST_P(QuicSpdySessionTestServer, OnPriorityFrame) {
   QuicStreamId stream_id = GetNthClientInitiatedBidirectionalId(0);
   TestStream* stream = session_.CreateIncomingStream(stream_id);
-  session_.OnPriorityFrame(stream_id, kV3HighestPriority);
-  EXPECT_EQ(kV3HighestPriority, stream->priority());
+  session_.OnPriorityFrame(stream_id,
+                           spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  EXPECT_EQ(spdy::SpdyStreamPrecedence(kV3HighestPriority),
+            stream->precedence());
 }
 
 TEST_P(QuicSpdySessionTestServer, SimplePendingStreamType) {

quic/core/http/quic_spdy_stream.cc

diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index aee3ba5..c577225 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -479,9 +479,10 @@
   }
 }
 
-void QuicSpdyStream::OnStreamHeadersPriority(SpdyPriority priority) {
+void QuicSpdyStream::OnStreamHeadersPriority(
+    const spdy::SpdyStreamPrecedence& precedence) {
   DCHECK_EQ(Perspective::IS_SERVER, session()->connection()->perspective());
-  SetPriority(priority);
+  SetPriority(precedence);
 }
 
 void QuicSpdyStream::OnStreamHeaderList(bool fin,
@@ -623,9 +624,10 @@
   }
 }
 
-void QuicSpdyStream::OnPriorityFrame(SpdyPriority priority) {
+void QuicSpdyStream::OnPriorityFrame(
+    const spdy::SpdyStreamPrecedence& precedence) {
   DCHECK_EQ(Perspective::IS_SERVER, session()->connection()->perspective());
-  SetPriority(priority);
+  SetPriority(precedence);
 }
 
 void QuicSpdyStream::OnStreamReset(const QuicRstStreamFrame& frame) {
@@ -936,7 +938,7 @@
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   if (!VersionUsesQpack(transport_version())) {
     return spdy_session_->WriteHeadersOnHeadersStream(
-        id(), std::move(header_block), fin, priority(),
+        id(), std::move(header_block), fin, precedence(),
         std::move(ack_listener));
   }
 
@@ -976,7 +978,7 @@
 }
 
 void QuicSpdyStream::PopulatePriorityFrame(PriorityFrame* frame) {
-  frame->weight = priority();
+  frame->weight = precedence().spdy3_priority();
   frame->dependency_type = ROOT_OF_TREE;
   frame->prioritized_type = REQUEST_STREAM;
   frame->prioritized_element_id = id();

quic/core/http/quic_spdy_stream.h

diff --git a/quic/core/http/quic_spdy_stream.h b/quic/core/http/quic_spdy_stream.h
index bdb8752..e030e93 100644
--- a/quic/core/http/quic_spdy_stream.h
+++ b/quic/core/http/quic_spdy_stream.h
@@ -78,7 +78,8 @@
 
   // Called by the session when headers with a priority have been received
   // for this stream.  This method will only be called for server streams.
-  virtual void OnStreamHeadersPriority(spdy::SpdyPriority priority);
+  virtual void OnStreamHeadersPriority(
+      const spdy::SpdyStreamPrecedence& precedence);
 
   // Called by the session when decompressed headers have been completely
   // delivered to this stream.  If |fin| is true, then this stream
@@ -95,7 +96,7 @@
 
   // Called by the session when a PRIORITY frame has been been received for this
   // stream. This method will only be called for server streams.
-  void OnPriorityFrame(spdy::SpdyPriority priority);
+  void OnPriorityFrame(const spdy::SpdyStreamPrecedence& precedence);
 
   // Override the base class to not discard response when receiving
   // QUIC_STREAM_NO_ERROR.

quic/core/http/quic_spdy_stream_test.cc

diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index ddfb651..20c1b65 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -108,22 +108,26 @@
 class TestMockUpdateStreamSession : public MockQuicSpdySession {
  public:
   explicit TestMockUpdateStreamSession(QuicConnection* connection)
-      : MockQuicSpdySession(connection) {}
+      : MockQuicSpdySession(connection),
+        expected_precedence_(
+            spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority)) {}
 
-  void UpdateStreamPriority(QuicStreamId id, SpdyPriority priority) override {
+  void UpdateStreamPriority(
+      QuicStreamId id,
+      const spdy::SpdyStreamPrecedence& precedence) override {
     EXPECT_EQ(id, expected_stream_->id());
-    EXPECT_EQ(expected_priority_, priority);
-    EXPECT_EQ(expected_priority_, expected_stream_->priority());
+    EXPECT_EQ(expected_precedence_, precedence);
+    EXPECT_EQ(expected_precedence_, expected_stream_->precedence());
   }
 
   void SetExpectedStream(QuicSpdyStream* stream) { expected_stream_ = stream; }
-  void SetExpectedPriority(SpdyPriority priority) {
-    expected_priority_ = priority;
+  void SetExpectedPriority(const spdy::SpdyStreamPrecedence& precedence) {
+    expected_precedence_ = precedence;
   }
 
  private:
   QuicSpdyStream* expected_stream_;
-  SpdyPriority expected_priority_;
+  spdy::SpdyStreamPrecedence expected_precedence_;
 };
 
 class QuicSpdyStreamTest : public QuicTestWithParam<ParsedQuicVersion> {
@@ -245,7 +249,8 @@
 TEST_P(QuicSpdyStreamTest, ProcessHeaderList) {
   Initialize(kShouldProcessData);
 
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
   ProcessHeaders(false, headers_);
   EXPECT_EQ("", stream_->data());
   EXPECT_FALSE(stream_->header_list().empty());
@@ -256,7 +261,8 @@
   Initialize(kShouldProcessData);
 
   QuicHeaderList headers;
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
   const bool version_uses_qpack =
       VersionUsesQpack(GetParam().transport_version);
@@ -288,7 +294,8 @@
     headers.OnHeader(p.first, p.second);
     total_bytes += p.first.size() + p.second.size();
   }
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
   stream_->OnStreamHeaderList(true, total_bytes, headers);
   EXPECT_EQ("", stream_->data());
   EXPECT_FALSE(stream_->header_list().empty());
@@ -925,7 +932,8 @@
     total_bytes += p.first.size() + p.second.size();
   }
 
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
   stream_->OnStreamHeaderList(/*fin=*/false, total_bytes, headers);
   stream_->ConsumeHeaderList();
 
@@ -1432,8 +1440,9 @@
 
 TEST_P(QuicSpdyStreamTest, OnPriorityFrame) {
   Initialize(kShouldProcessData);
-  stream_->OnPriorityFrame(kV3HighestPriority);
-  EXPECT_EQ(kV3HighestPriority, stream_->priority());
+  stream_->OnPriorityFrame(spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  EXPECT_EQ(spdy::SpdyStreamPrecedence(kV3HighestPriority),
+            stream_->precedence());
 }
 
 TEST_P(QuicSpdyStreamTest, OnPriorityFrameAfterSendingData) {
@@ -1451,8 +1460,9 @@
   }
   EXPECT_CALL(*session_, WritevData(_, _, 4, _, FIN));
   stream_->WriteOrBufferBody("data", true);
-  stream_->OnPriorityFrame(kV3HighestPriority);
-  EXPECT_EQ(kV3HighestPriority, stream_->priority());
+  stream_->OnPriorityFrame(spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  EXPECT_EQ(spdy::SpdyStreamPrecedence(kV3HighestPriority),
+            stream_->precedence());
 }
 
 TEST_P(QuicSpdyStreamTest, SetPriorityBeforeUpdateStreamPriority) {
@@ -1473,11 +1483,11 @@
   // if called within UpdateStreamPriority(). This expectation is enforced in
   // TestMockUpdateStreamSession::UpdateStreamPriority().
   session->SetExpectedStream(stream);
-  session->SetExpectedPriority(kV3HighestPriority);
-  stream->SetPriority(kV3HighestPriority);
+  session->SetExpectedPriority(spdy::SpdyStreamPrecedence(kV3HighestPriority));
+  stream->SetPriority(spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
-  session->SetExpectedPriority(kV3LowestPriority);
-  stream->SetPriority(kV3LowestPriority);
+  session->SetExpectedPriority(spdy::SpdyStreamPrecedence(kV3LowestPriority));
+  stream->SetPriority(spdy::SpdyStreamPrecedence(kV3LowestPriority));
 }
 
 TEST_P(QuicSpdyStreamTest, StreamWaitsForAcks) {
@@ -2155,7 +2165,8 @@
   QuicStreamFrame frame(stream_->id(), false, 0, buffer.get(), length);
   // TODO(lassey): Check for HTTP_WRONG_STREAM error code.
   EXPECT_CALL(*connection_, CloseConnection(QUIC_HTTP_DECODER_ERROR, _, _));
-  stream_->OnStreamHeadersPriority(kV3HighestPriority);
+  stream_->OnStreamHeadersPriority(
+      spdy::SpdyStreamPrecedence(kV3HighestPriority));
   ProcessHeaders(false, headers_);
   stream_->ConsumeHeaderList();
   stream_->OnStreamFrame(frame);

quic/core/quic_session.cc

diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 221d75e..964ddc1 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -1155,19 +1155,21 @@
 void QuicSession::OnCryptoHandshakeMessageReceived(
     const CryptoHandshakeMessage& /*message*/) {}
 
-void QuicSession::RegisterStreamPriority(QuicStreamId id,
-                                         bool is_static,
-                                         SpdyPriority priority) {
-  write_blocked_streams()->RegisterStream(id, is_static, priority);
+void QuicSession::RegisterStreamPriority(
+    QuicStreamId id,
+    bool is_static,
+    const spdy::SpdyStreamPrecedence& precedence) {
+  write_blocked_streams()->RegisterStream(id, is_static, precedence);
 }
 
 void QuicSession::UnregisterStreamPriority(QuicStreamId id, bool is_static) {
   write_blocked_streams()->UnregisterStream(id, is_static);
 }
 
-void QuicSession::UpdateStreamPriority(QuicStreamId id,
-                                       SpdyPriority new_priority) {
-  write_blocked_streams()->UpdateStreamPriority(id, new_priority);
+void QuicSession::UpdateStreamPriority(
+    QuicStreamId id,
+    const spdy::SpdyStreamPrecedence& new_precedence) {
+  write_blocked_streams()->UpdateStreamPriority(id, new_precedence);
 }
 
 QuicConfig* QuicSession::config() {

quic/core/quic_session.h

diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index b7c0212..ba5592a 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -256,16 +256,18 @@
       const CryptoHandshakeMessage& message);
 
   // Called by the stream on creation to set priority in the write blocked list.
-  virtual void RegisterStreamPriority(QuicStreamId id,
-                                      bool is_static,
-                                      spdy::SpdyPriority priority);
+  virtual void RegisterStreamPriority(
+      QuicStreamId id,
+      bool is_static,
+      const spdy::SpdyStreamPrecedence& precedence);
   // Called by the stream on deletion to clear priority from the write blocked
   // list.
   virtual void UnregisterStreamPriority(QuicStreamId id, bool is_static);
   // Called by the stream on SetPriority to update priority on the write blocked
   // list.
-  virtual void UpdateStreamPriority(QuicStreamId id,
-                                    spdy::SpdyPriority new_priority);
+  virtual void UpdateStreamPriority(
+      QuicStreamId id,
+      const spdy::SpdyStreamPrecedence& new_precedence);
 
   // Returns mutable config for this session. Returned config is owned
   // by QuicSession.

quic/core/quic_session_test.cc

diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 90577d5..2e15df1 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -890,7 +890,7 @@
   // Now let stream 4 do the 2nd of its 3 writes, but add a block for a high
   // priority stream 6.  4 should be preempted.  6 will write but *not* block so
   // will cede back to 4.
-  stream6->SetPriority(kV3HighestPriority);
+  stream6->SetPriority(spdy::SpdyStreamPrecedence(kV3HighestPriority));
   EXPECT_CALL(*stream4, OnCanWrite())
       .WillOnce(Invoke([this, stream4, stream6]() {
         session_.SendLargeFakeData(stream4, 6000);

quic/core/quic_stream.cc

diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index 8ef4717..a44be4e 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -236,7 +236,7 @@
     : sequencer_(std::move(sequencer)),
       id_(id),
       session_(session),
-      priority_(kDefaultPriority),
+      precedence_(spdy::SpdyStreamPrecedence(kDefaultPriority)),
       stream_bytes_read_(stream_bytes_read),
       stream_error_(QUIC_STREAM_NO_ERROR),
       connection_error_(QUIC_NO_ERROR),
@@ -276,7 +276,7 @@
   }
   SetFromConfig();
   if (type_ != CRYPTO) {
-    session_->RegisterStreamPriority(id, is_static_, priority_);
+    session_->RegisterStreamPriority(id, is_static_, precedence_);
   }
 }
 
@@ -432,13 +432,13 @@
       error, details, ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
 }
 
-SpdyPriority QuicStream::priority() const {
-  return priority_;
+const spdy::SpdyStreamPrecedence& QuicStream::precedence() const {
+  return precedence_;
 }
 
-void QuicStream::SetPriority(SpdyPriority priority) {
-  priority_ = priority;
-  session_->UpdateStreamPriority(id(), priority);
+void QuicStream::SetPriority(const spdy::SpdyStreamPrecedence& precedence) {
+  precedence_ = precedence;
+  session_->UpdateStreamPriority(id(), precedence);
 }
 
 void QuicStream::WriteOrBufferData(

quic/core/quic_stream.h

diff --git a/quic/core/quic_stream.h b/quic/core/quic_stream.h
index 6f5536d..b747451 100644
--- a/quic/core/quic_stream.h
+++ b/quic/core/quic_stream.h
@@ -176,11 +176,11 @@
   virtual void OnConnectionClosed(QuicErrorCode error,
                                   ConnectionCloseSource source);
 
-  spdy::SpdyPriority priority() const;
+  const spdy::SpdyStreamPrecedence& precedence() const;
 
   // Sets priority_ to priority.  This should only be called before bytes are
   // written to the server.
-  void SetPriority(spdy::SpdyPriority priority);
+  void SetPriority(const spdy::SpdyStreamPrecedence& precedence);
 
   // Returns true if this stream is still waiting for acks of sent data.
   // This will return false if all data has been acked, or if the stream
@@ -456,8 +456,8 @@
   QuicStreamId id_;
   // Pointer to the owning QuicSession object.
   QuicSession* session_;
-  // The priority of the stream, once parsed.
-  spdy::SpdyPriority priority_;
+  // The precedence of the stream, once parsed.
+  spdy::SpdyStreamPrecedence precedence_;
   // Bytes read refers to payload bytes only: they do not include framing,
   // encryption overhead etc.
   uint64_t stream_bytes_read_;

quic/core/quic_write_blocked_list.h

diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index eca7c1a..4b49816 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -92,15 +92,14 @@
 
   void RegisterStream(QuicStreamId stream_id,
                       bool is_static_stream,
-                      spdy::SpdyPriority priority) {
+                      const spdy::SpdyStreamPrecedence& precedence) {
     DCHECK(!priority_write_scheduler_.StreamRegistered(stream_id));
     if (is_static_stream) {
       static_stream_collection_.Register(stream_id);
       return;
     }
 
-    priority_write_scheduler_.RegisterStream(
-        stream_id, spdy::SpdyStreamPrecedence(priority));
+    priority_write_scheduler_.RegisterStream(stream_id, precedence);
   }
 
   void UnregisterStream(QuicStreamId stream_id, bool is_static) {
@@ -112,10 +111,9 @@
   }
 
   void UpdateStreamPriority(QuicStreamId stream_id,
-                            spdy::SpdyPriority new_priority) {
+                            const spdy::SpdyStreamPrecedence& new_precedence) {
     DCHECK(!static_stream_collection_.IsRegistered(stream_id));
-    priority_write_scheduler_.UpdateStreamPrecedence(
-        stream_id, spdy::SpdyStreamPrecedence(new_priority));
+    priority_write_scheduler_.UpdateStreamPrecedence(stream_id, new_precedence);
   }
 
   void UpdateBytesForStream(QuicStreamId stream_id, size_t bytes) {

quic/core/quic_write_blocked_list_test.cc

diff --git a/quic/core/quic_write_blocked_list_test.cc b/quic/core/quic_write_blocked_list_test.cc
index 30bb08e..f26fc56 100644
--- a/quic/core/quic_write_blocked_list_test.cc
+++ b/quic/core/quic_write_blocked_list_test.cc
@@ -26,11 +26,16 @@
 TEST_F(QuicWriteBlockedListTest, PriorityOrder) {
   // Mark streams blocked in roughly reverse priority order, and
   // verify that streams are sorted.
-  write_blocked_list_.RegisterStream(40, false, kV3LowestPriority);
-  write_blocked_list_.RegisterStream(23, false, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(17, false, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(1, true, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
+  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));
@@ -70,7 +75,8 @@
 }
 
 TEST_F(QuicWriteBlockedListTest, CryptoStream) {
-  write_blocked_list_.RegisterStream(1, true, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(
+      1, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
   write_blocked_list_.AddStream(1);
 
   EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
@@ -81,7 +87,8 @@
 }
 
 TEST_F(QuicWriteBlockedListTest, HeadersStream) {
-  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(
+      3, true, spdy::SpdyStreamPrecedence(kV3HighestPriority));
   write_blocked_list_.AddStream(3);
 
   EXPECT_EQ(1u, write_blocked_list_.NumBlockedStreams());
@@ -92,8 +99,10 @@
 }
 
 TEST_F(QuicWriteBlockedListTest, VerifyHeadersStream) {
-  write_blocked_list_.RegisterStream(5, false, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
+  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);
 
@@ -114,7 +123,8 @@
   // Try to add a stream to the write blocked list multiple times at the same
   // priority.
   const QuicStreamId kBlockedId = 3 + 2;
-  write_blocked_list_.RegisterStream(kBlockedId, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(
+      kBlockedId, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
   write_blocked_list_.AddStream(kBlockedId);
   write_blocked_list_.AddStream(kBlockedId);
   write_blocked_list_.AddStream(kBlockedId);
@@ -133,9 +143,12 @@
   const QuicStreamId id1 = 3 + 2;
   const QuicStreamId id2 = id1 + 2;
   const QuicStreamId id3 = id2 + 2;
-  write_blocked_list_.RegisterStream(id1, false, kV3LowestPriority);
-  write_blocked_list_.RegisterStream(id2, false, kV3LowestPriority);
-  write_blocked_list_.RegisterStream(id3, false, kV3HighestPriority);
+  write_blocked_list_.RegisterStream(
+      id1, false, spdy::SpdyStreamPrecedence(kV3LowestPriority));
+  write_blocked_list_.RegisterStream(
+      id2, false, spdy::SpdyStreamPrecedence(kV3LowestPriority));
+  write_blocked_list_.RegisterStream(
+      id3, false, spdy::SpdyStreamPrecedence(kV3HighestPriority));
 
   write_blocked_list_.AddStream(id1);
   write_blocked_list_.AddStream(id2);
@@ -180,13 +193,17 @@
 }
 
 TEST_F(QuicWriteBlockedListTest, Ceding) {
-  write_blocked_list_.RegisterStream(15, false, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(16, false, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(5, false, 5);
-  write_blocked_list_.RegisterStream(4, false, 5);
-  write_blocked_list_.RegisterStream(7, false, 7);
-  write_blocked_list_.RegisterStream(1, true, kV3HighestPriority);
-  write_blocked_list_.RegisterStream(3, true, kV3HighestPriority);
+  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));

quic/quartc/quartc_session.cc

diff --git a/quic/quartc/quartc_session.cc b/quic/quartc/quartc_session.cc
index 8a918ca..f851579 100644
--- a/quic/quartc/quartc_session.cc
+++ b/quic/quartc/quartc_session.cc
@@ -301,7 +301,8 @@
   // Register the stream to the QuicWriteBlockedList. |priority| is clamped
   // between 0 and 7, with 0 being the highest priority and 7 the lowest
   // priority.
-  write_blocked_streams()->UpdateStreamPriority(stream->id(), priority);
+  write_blocked_streams()->UpdateStreamPriority(
+      stream->id(), spdy::SpdyStreamPrecedence(priority));
 
   if (IsIncomingStream(stream->id())) {
     DCHECK(session_delegate_);

quic/quartc/quartc_stream_test.cc

diff --git a/quic/quartc/quartc_stream_test.cc b/quic/quartc/quartc_stream_test.cc
index be23b75..719cca7 100644
--- a/quic/quartc/quartc_stream_test.cc
+++ b/quic/quartc/quartc_stream_test.cc
@@ -107,9 +107,9 @@
   // Tracks whether the stream is write blocked and its priority.
   void RegisterReliableStream(QuicStreamId stream_id,
                               spdy::SpdyPriority priority) {
-    write_blocked_streams()->RegisterStream(stream_id,
-                                            /*is_static_stream=*/false,
-                                            priority);
+    write_blocked_streams()->RegisterStream(
+        stream_id,
+        /*is_static_stream=*/false, spdy::SpdyStreamPrecedence(priority));
   }
 
   // The session take ownership of the stream.

quic/test_tools/quic_spdy_session_peer.cc

diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index 68552a8..d63c2d9 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -58,10 +58,10 @@
     QuicStreamId id,
     spdy::SpdyHeaderBlock headers,
     bool fin,
-    spdy::SpdyPriority priority,
+    const spdy::SpdyStreamPrecedence& precedence,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
   return session->WriteHeadersOnHeadersStream(
-      id, std::move(headers), fin, priority, std::move(ack_listener));
+      id, std::move(headers), fin, precedence, std::move(ack_listener));
 }
 
 // static

quic/test_tools/quic_spdy_session_peer.h

diff --git a/quic/test_tools/quic_spdy_session_peer.h b/quic/test_tools/quic_spdy_session_peer.h
index aacf712..7d6cea7 100644
--- a/quic/test_tools/quic_spdy_session_peer.h
+++ b/quic/test_tools/quic_spdy_session_peer.h
@@ -41,7 +41,7 @@
       QuicStreamId id,
       spdy::SpdyHeaderBlock headers,
       bool fin,
-      spdy::SpdyPriority priority,
+      const spdy::SpdyStreamPrecedence& precedence,
       QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
   // |session| can't be nullptr.
   static QuicStreamId GetNextOutgoingUnidirectionalStreamId(

quic/test_tools/quic_test_client.cc

diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index ef92cb0..402a231 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -547,7 +547,8 @@
   if (!latest_created_stream_) {
     SetLatestCreatedStream(client_->CreateClientStream());
     if (latest_created_stream_) {
-      latest_created_stream_->SetPriority(priority_);
+      latest_created_stream_->SetPriority(
+          spdy::SpdyStreamPrecedence(priority_));
     }
   }
 

quic/test_tools/quic_test_utils.h

diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index 20494d7..52f0e2d 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -702,7 +702,8 @@
   MOCK_METHOD2(OnStreamHeaders,
                void(QuicStreamId stream_id, QuicStringPiece headers_data));
   MOCK_METHOD2(OnStreamHeadersPriority,
-               void(QuicStreamId stream_id, spdy::SpdyPriority priority));
+               void(QuicStreamId stream_id,
+                    const spdy::SpdyStreamPrecedence& precedence));
   MOCK_METHOD3(OnStreamHeadersComplete,
                void(QuicStreamId stream_id, bool fin, size_t frame_len));
   MOCK_METHOD4(OnStreamHeaderList,
@@ -723,7 +724,8 @@
                     size_t frame_len,
                     const QuicHeaderList& header_list));
   MOCK_METHOD2(OnPriorityFrame,
-               void(QuicStreamId id, spdy::SpdyPriority priority));
+               void(QuicStreamId id,
+                    const spdy::SpdyStreamPrecedence& precedence));
 
   MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta));
   MOCK_METHOD4(

quic/tools/quic_simple_server_session.cc

diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index 2e98cdd..ef70fdb 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -216,7 +216,8 @@
     DCHECK_EQ(promised_info.stream_id, promised_stream->id());
     QUIC_DLOG(INFO) << "created server push stream " << promised_stream->id();
 
-    promised_stream->SetPriority(promised_info.priority);
+    promised_stream->SetPriority(
+        spdy::SpdyStreamPrecedence(promised_info.priority));
 
     spdy::SpdyHeaderBlock request_headers(
         std::move(promised_info.request_headers));

quic/tools/quic_simple_server_session_test.cc

diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index cef24b7..a3d7d12 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -483,7 +483,8 @@
   QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
   session_->RegisterStreamPriority(
       QuicUtils::GetHeadersStreamId(connection_->transport_version()),
-      /*is_static=*/true, QuicStream::kDefaultPriority);
+      /*is_static=*/true,
+      spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority));
 
   // Create push streams till reaching the upper limit of allowed open streams.
   for (size_t i = 0; i < kMaxStreamsForTest; ++i) {
@@ -587,7 +588,8 @@
     QuicSimpleServerSessionPeer::SetCryptoStream(session_.get(), crypto_stream);
     session_->RegisterStreamPriority(
         QuicUtils::GetHeadersStreamId(connection_->transport_version()),
-        /*is_static=*/true, QuicStream::kDefaultPriority);
+        /*is_static=*/true,
+        spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority));
   }
 
   // Given |num_resources|, create this number of fake push resources and push

quic/tools/quic_simple_server_stream_test.cc

diff --git a/quic/tools/quic_simple_server_stream_test.cc b/quic/tools/quic_simple_server_stream_test.cc
index 7bac18e..fca04ff 100644
--- a/quic/tools/quic_simple_server_stream_test.cc
+++ b/quic/tools/quic_simple_server_stream_test.cc
@@ -133,7 +133,8 @@
                     size_t frame_len,
                     const QuicHeaderList& header_list));
   MOCK_METHOD2(OnStreamHeadersPriority,
-               void(QuicStreamId stream_id, spdy::SpdyPriority priority));
+               void(QuicStreamId stream_id,
+                    const spdy::SpdyStreamPrecedence& precedence));
   MOCK_METHOD3(SendRstStream,
                void(QuicStreamId stream_id,
                     QuicRstStreamErrorCode error,

quic/tools/quic_spdy_client_base.cc

diff --git a/quic/tools/quic_spdy_client_base.cc b/quic/tools/quic_spdy_client_base.cc
index 3a3bafe..09a1998 100644
--- a/quic/tools/quic_spdy_client_base.cc
+++ b/quic/tools/quic_spdy_client_base.cc
@@ -174,7 +174,8 @@
   auto* stream = static_cast<QuicSpdyClientStream*>(
       client_session()->CreateOutgoingBidirectionalStream());
   if (stream) {
-    stream->SetPriority(QuicStream::kDefaultPriority);
+    stream->SetPriority(
+        spdy::SpdyStreamPrecedence(QuicStream::kDefaultPriority));
     stream->set_visitor(this);
   }
   return stream;