http2: Update priorities of pushed streams

net/spdy/spdy_session.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 313 matching lines @@
     return spdy_session_key_;
   }
   // Get a pushed stream for a given |url|.  If the server initiates a
   // stream, it might already exist for a given path.  The server
   // might also not have initiated the stream yet, but indicated it
   // will via X-Associated-Content.  Returns OK if a stream was found
   // and put into |spdy_stream|, or if one was not found but it is
   // okay to create a new stream (in which case |spdy_stream| is
   // reset).  Returns an error (not ERR_IO_PENDING) otherwise, and
   // resets |spdy_stream|.
+  //
+  // If a stream was found and the stream is still open, the priority
+  // of that stream is updated to match |priority|.
   int GetPushStream(const GURL& url,
+                    RequestPriority priority,
                     base::WeakPtr<SpdyStream>* spdy_stream,
                     const NetLogWithSource& stream_net_log);
 
   void set_push_delegate(ServerPushDelegate* push_delegate) {
     push_delegate_ = push_delegate;
   }
 
   // Called when the pushed stream should be cancelled. If the pushed stream is
   // not claimed and active, sends RST to the server to cancel the stream.
   void CancelPush(const GURL& url);
@@ skipping 332 matching lines @@
   // there is none.
   base::WeakPtr<SpdyStreamRequest> GetNextPendingStreamRequest();
 
   // Called when there is room to create more streams (e.g., a stream
   // was closed). Processes as many pending stream requests as
   // possible.
   void ProcessPendingStreamRequests();
 
   void TryCreatePushStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
-                           SpdyPriority priority,
                            SpdyHeaderBlock headers);
 
   // Close the stream pointed to by the given iterator. Note that that
   // stream may hold the last reference to the session.
   void CloseActiveStreamIterator(ActiveStreamMap::iterator it, int status);
 
   // Close the stream pointed to by the given iterator. Note that that
   // stream may hold the last reference to the session.
   void CloseCreatedStreamIterator(CreatedStreamSet::iterator it, int status);
 
   // Calls EnqueueResetStreamFrame() and then
   // CloseActiveStreamIterator().
   void ResetStreamIterator(ActiveStreamMap::iterator it,
                            SpdyRstStreamStatus status,
                            const std::string& description);
 
   // Send a RST_STREAM frame with the given parameters. There should
   // either be no active stream with the given ID, or that active
   // stream should be closed shortly after this function is called.
-  //
-  // TODO(akalin): Rename this to EnqueueResetStreamFrame().

[Bence, 2017/01/05 17:14:46]

Lol.  Thank you for removing this obviously stale comment.

   void EnqueueResetStreamFrame(SpdyStreamId stream_id,
                                RequestPriority priority,
                                SpdyRstStreamStatus status,
                                const std::string& description);
 
+  // Send a PRIORITY frame with the given parameters.
+  void EnqueuePriorityFrame(SpdyStreamId stream_id,
+                            SpdyStreamId dependency_id,
+                            int weight,
+                            bool exclusive);
+
   // Calls DoReadLoop. Use this function instead of DoReadLoop when
   // posting a task to pump the read loop.
   void PumpReadLoop(ReadState expected_read_state, int result);
 
   // Advance the ReadState state machine. |expected_read_state| is the
   // expected starting read state.
   //
   // This function must always be called via PumpReadLoop().
   int DoReadLoop(ReadState expected_read_state, int result);
   // The implementations of the states of the ReadState state machine.
@@ skipping 482 matching lines @@
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_