support paused priority

Reviewed By: lnicco

Differential Revision: D68019424

fbshipit-source-id: 30eeb0acc341f3120d59901150d0a27d91d720ff

Author: pfarcasanu

proxygen/lib/http/HTTPMessage.cpp

@@ -36,7 +36,8 @@ std::string httpPriorityToString(const HTTPPriority& pri) {
       "u=",
       std::min(static_cast<uint8_t>(proxygen::kMaxPriority), pri.urgency),
       pri.incremental ? ",i" : "",
-      pri.orderId > 0 ? folly::to<std::string>(",o=", pri.orderId) : "");
+      pri.orderId > 0 ? folly::to<std::string>(",o=", pri.orderId) : "",
+      pri.paused ? ",p" : "");
 }
 
 std::mutex HTTPMessage::mutexDump_;

proxygen/lib/http/HTTPMessage.h

@@ -36,32 +36,37 @@ constexpr uint8_t kDefaultHttpPriorityUrgency = 3;
 // We default incremental to True, different from the draft
 constexpr bool kDefaultHttpPriorityIncremental = true;
 constexpr uint64_t kDefaultOrderId = 0;
+constexpr bool kDefaultPaused = false;
 constexpr int8_t kMinPriority = 0;
 constexpr int8_t kMaxPriority = 7;
 
 struct HTTPPriority {
   uint8_t urgency : 3;
   bool incremental : 1;
-  uint64_t orderId : 58;
+  uint64_t orderId : 57;
+  bool paused : 1;
 
   HTTPPriority()
       : urgency(kDefaultHttpPriorityUrgency),
         incremental(kDefaultHttpPriorityIncremental),
-        orderId(kDefaultOrderId) {
+        orderId(kDefaultOrderId),
+        paused(kDefaultPaused) {
   }
 
   HTTPPriority(uint8_t urgencyIn,
                bool incrementalIn,
-               uint64_t orderIdIn = kDefaultOrderId)
+               uint64_t orderIdIn = kDefaultOrderId,
+               bool pausedIn = kDefaultPaused)
       : urgency(std::min(urgencyIn, static_cast<uint8_t>(kMaxPriority))),
         incremental(incrementalIn),
-        orderId(orderIdIn) {
+        orderId(orderIdIn),
+        paused(pausedIn) {
   }
 };
 
 inline bool operator==(const HTTPPriority& a, const HTTPPriority& b) {
   return a.urgency == b.urgency && a.incremental == b.incremental &&
-         a.orderId == b.orderId;
+         a.orderId == b.orderId && a.paused == b.paused;
 }
 
 // Convert Priority to a string representation in the form of "u=urgency[,i]"

proxygen/lib/http/HTTPPriorityFunctions.cpp

@@ -63,19 +63,22 @@ folly::Optional<HTTPPriority> httpPriorityFromString(
   bool uMissing = false;
   bool iMissing = false;
   bool oMissing = false;
+  bool pMissing = false;
   bool malformed = false;
   int64_t urgency = getWithDefault<int64_t>(
       dict, "u", (int64_t)kDefaultHttpPriorityUrgency, uMissing, malformed);
   bool incremental = getWithDefault(dict, "i", false, iMissing, malformed);
   auto orderId = getWithDefault<int64_t>(dict, "o", 0, oMissing, malformed);
+  auto paused = getWithDefault(dict, "p", false, pMissing, malformed);
   if ((urgency > kMaxPriority || urgency < kMinPriority) || (orderId < 0) ||
-      (uMissing && iMissing && oMissing) || malformed) {
+      (uMissing && iMissing && oMissing && pMissing) || malformed) {
     logBadHeader = true;
     return folly::none;
   }
   return HTTPPriority(static_cast<uint8_t>(urgency),
                       incremental,
-                      static_cast<uint64_t>(orderId));
+                      static_cast<uint64_t>(orderId),
+                      paused);
 }
 
 } // namespace proxygen

proxygen/lib/http/session/HQDownstreamSession.cpp

@@ -285,8 +285,10 @@ folly::Optional<HTTPHeaders> HQDownstreamSession::getExtraHeaders(
   }
   HTTPHeaders extraHeaders;
   extraHeaders.add(HTTP_HEADER_PRIORITY,
-                   httpPriorityToString(
-                       HTTPPriority(priority->level, priority->incremental)));
+                   httpPriorityToString(HTTPPriority(priority->level,
+                                                     priority->incremental,
+                                                     priority->orderId,
+                                                     priority->paused)));
   return extraHeaders;
 }
 

proxygen/lib/http/session/HQSession.cpp

@@ -88,7 +88,7 @@ quic::QuicErrorCode quicControlStreamError(quic::QuicErrorCode error) {
 }
 
 quic::Priority toQuicPriority(const proxygen::HTTPPriority& pri) {
-  return quic::Priority(pri.urgency, pri.incremental, pri.orderId);
+  return {pri.urgency, pri.incremental, pri.orderId, pri.paused};
 }
 
 // Get the size of the WebTransport stream preface without actually encoding it

proxygen/lib/http/test/HTTPMessageTest.cpp

@@ -776,6 +776,14 @@ TEST(HTTPMessage, HTTPPriorityOrderIdSetGet) {
   EXPECT_EQ(priHeaderViaGetter->orderId, 10);
 }
 
+TEST(HTTPMessage, HTTPPriorityPausedSetGet) {
+  HTTPMessage message;
+  message.setHTTPPriority(HTTPPriority(7, false, 0, true /* paused */));
+  EXPECT_TRUE(httpPriorityFromHTTPMessage(message)->paused);
+  auto& priHeader = message.getHeaders().getSingleOrEmpty(HTTP_HEADER_PRIORITY);
+  EXPECT_EQ("u=7,p", priHeader);
+}
+
 TEST(HTTPHeaders, GetSetOnResize) {
   HTTPHeaders headers;
   for (size_t i = 0; i < kInitialVectorReserve - 1; i++) {

proxygen/lib/http/test/HTTPPriorityFunctionsTest.cpp

@@ -94,12 +94,12 @@ TEST(HTTPPriorityFunctionsTest, PriorityHeaderUrgencyAndIncrementalUppercase) {
 
 TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadUrgency) {
   HTTPMessage req;
-  req.getHeaders().add(HTTP_HEADER_PRIORITY, "p=3");
+  req.getHeaders().add(HTTP_HEADER_PRIORITY, "x=3");
   auto priority = httpPriorityFromHTTPMessage(req);
   EXPECT_FALSE(priority.hasValue());
 
   // same as above but with incremental flag
-  req.getHeaders().set(HTTP_HEADER_PRIORITY, "p=2, i");
+  req.getHeaders().set(HTTP_HEADER_PRIORITY, "x=2, i");
   priority = httpPriorityFromHTTPMessage(req);
   // default to u=3 if urgency is missing but incremental is present
   ASSERT_TRUE(priority.hasValue());
@@ -122,13 +122,20 @@ TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadUrgency) {
   EXPECT_FALSE(priority.hasValue());
 }
 
-TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadPriority) {
+TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadIncremental) {
   HTTPMessage req;
   req.getHeaders().add(HTTP_HEADER_PRIORITY, "u=3, i=0");
   auto priority = httpPriorityFromHTTPMessage(req);
   EXPECT_FALSE(priority.hasValue());
 }
 
+TEST(HTTPPriorityFunctionsTest, PriorityHeaderBadPaused) {
+  HTTPMessage req;
+  req.getHeaders().add(HTTP_HEADER_PRIORITY, "u=3, p=0");
+  auto priority = httpPriorityFromHTTPMessage(req);
+  EXPECT_FALSE(priority.hasValue());
+}
+
 TEST(HTTPPriorityFunctionsTest, PriorityHeaderDefaultOrderId) {
   HTTPMessage req;
   req.getHeaders().add(HTTP_HEADER_PRIORITY, "u=3");
@@ -143,3 +150,17 @@ TEST(HTTPPriorityFunctionsTest, PriorityHeaderCustomOrderId) {
   EXPECT_EQ(priority->urgency, 3);
   EXPECT_EQ(priority->orderId, 100);
 }
+
+TEST(HTTPPriorityFunctionsTest, PriorityHeaderDefaultUnpaused) {
+  HTTPMessage req;
+  req.getHeaders().add(HTTP_HEADER_PRIORITY, "u=3");
+  auto priority = httpPriorityFromHTTPMessage(req);
+  EXPECT_FALSE(priority->paused);
+}
+
+TEST(HTTPPriorityFunctionsTest, PriorityHeaderPaused) {
+  HTTPMessage req;
+  req.getHeaders().add(HTTP_HEADER_PRIORITY, "u=3, p");
+  auto priority = httpPriorityFromHTTPMessage(req);
+  EXPECT_TRUE(priority->paused);
+}