Add a new priority level, THROTTLED, below IDLE.

net/quic/quic_http_utils.cc

Index: net/quic/quic_http_utils.cc
diff --git a/net/quic/quic_http_utils.cc b/net/quic/quic_http_utils.cc
index c6dd505f2c64a6ca10cdbf7e2c516f2cf68cdbe6..d05c51a46f6240013930ad2d594425d0ef53ba25 100644
--- a/net/quic/quic_http_utils.cc
+++ b/net/quic/quic_http_utils.cc
@@ -12,14 +12,15 @@ SpdyPriority ConvertRequestPriorityToQuicPriority(
     const RequestPriority priority) {
   DCHECK_GE(priority, MINIMUM_PRIORITY);
   DCHECK_LE(priority, MAXIMUM_PRIORITY);
-  return static_cast<SpdyPriority>(HIGHEST - priority);
+  return static_cast<SpdyPriority>(MAXIMUM_PRIORITY - priority);

[mmenke, 2016/05/09 19:25:42]

Should run this by the SPDY/QUIC teams.  There's a constant that claims spdy
priorities range from 0 to 7, so I think we're good, but not positive.

[Randy Smith (Not in Mondays), 2016/05/11 21:30:24]

Makes sense.  Ryan?

(I've also modified this to be more in line with the changes below.)

 }
 
 NET_EXPORT_PRIVATE RequestPriority
 ConvertQuicPriorityToRequestPriority(SpdyPriority priority) {

[mmenke, 2016/05/09 19:25:42]

The fact that this is not the inverse of ConvertRequestPriorityToQuicPriority is
unexpected.  Note that this method is only used for testing, making sure we send
the right priorities (And those tests should be updated to include the new
priority).

[Randy Smith (Not in Mondays), 2016/05/11 21:30:25]

I've updated the test.  In what ways is this not the inverse?  (I have made
changes to both the above function and this one, so it's possible it used to not
be the inverse and now is.)

[mmenke, 2016/05/11 21:56:08]

This never returns THROTTLED, does it?  I had assumed that was deliberate.

[Randy Smith (Not in Mondays), 2016/05/11 22:04:28]

Nope; it was a mistake on my part.  I don't see a reason to treat THROTTLED
differently than other priorities WRT QUIC/SPDY.  Let me know if you do.

[mmenke, 2016/05/11 22:10:50]

Pushed streams with the QUIC/H2 priority corresponding to THROTTLED seem kinda
weird...  But we aren't using this in production code, anyways, so I guess that
doesn't matter.

[Ryan Hamilton, 2016/05/12 22:25:46]

I'm not following the pushed stream == throttled comment. Can you elaborate?

   // Handle invalid values gracefully.
-  return (priority >= 5) ? IDLE
-                         : static_cast<RequestPriority>(HIGHEST - priority);
+  return (priority >= (MAXIMUM_PRIORITY - MINIMUM_PRIORITY))

[mmenke, 2016/05/09 19:25:42]

Hrm...The is right, but weird.

"priority - kV3HighestPriority >= MAXIMUM_PRIORITY - MINIMUM_PRIORITY" (We're
comparing two priority deltas, not a priority and a delta - same goes for the
MAXIMUM_PRIORITY line)

[Randy Smith (Not in Mondays), 2016/05/11 21:30:24]

Fixed here; not sure what you meant by "the same goes for the MAXIMUM_PRIORITY
line", but if you meant that it should be relative to kV3HighestPriority, fixed.

[mmenke, 2016/05/11 21:56:08]

Yea, that's what I mean (Weird to do math on priorities on two different
"priority units", relying on one or more values being 0, rather than find the
delta on one scale, and apply it to the other)

+             ? IDLE
+             : static_cast<RequestPriority>(MAXIMUM_PRIORITY - priority);
 }
 
 std::unique_ptr<base::Value> QuicRequestNetLogCallback(