Change ParsePriorityFieldValue() return value.

Use std::optional<> instead of homebrew struct with bool.

PiperOrigin-RevId: 495015412

quiche/quic/core/http/quic_receive_control_stream.cc

diff --git a/quiche/quic/core/http/quic_receive_control_stream.cc b/quiche/quic/core/http/quic_receive_control_stream.cc
index 87e9bd7..b23fc57 100644
--- a/quiche/quic/core/http/quic_receive_control_stream.cc
+++ b/quiche/quic/core/http/quic_receive_control_stream.cc
@@ -9,6 +9,7 @@
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "quiche/quic/core/http/http_constants.h"
 #include "quiche/quic/core/http/http_decoder.h"
 #include "quiche/quic/core/http/quic_spdy_session.h"
@@ -138,10 +139,10 @@
 
   if (GetQuicReloadableFlag(quic_priority_update_structured_headers_parser)) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_priority_update_structured_headers_parser);
-    const ParsePriorityFieldValueResult result =
+    absl::optional<QuicStreamPriority> priority =
         ParsePriorityFieldValue(frame.priority_field_value);
 
-    if (!result.success) {
+    if (!priority.has_value()) {
       stream_delegate()->OnStreamError(
           QUIC_INVALID_PRIORITY_UPDATE,
           "Invalid PRIORITY_UPDATE frame payload.");
@@ -150,7 +151,7 @@
 
     const QuicStreamId stream_id = frame.prioritized_element_id;
     return spdy_session_->OnPriorityUpdateForRequestStream(stream_id,
-                                                           result.priority);
+                                                           *priority);
   }
 
   for (absl::string_view key_value :

quiche/quic/core/quic_stream_priority.cc

diff --git a/quiche/quic/core/quic_stream_priority.cc b/quiche/quic/core/quic_stream_priority.cc
index 9729706..1209258 100644
--- a/quiche/quic/core/quic_stream_priority.cc
+++ b/quiche/quic/core/quic_stream_priority.cc
@@ -38,12 +38,12 @@
   return *priority_field_value;
 }
 
-ParsePriorityFieldValueResult ParsePriorityFieldValue(
+absl::optional<QuicStreamPriority> ParsePriorityFieldValue(
     absl::string_view priority_field_value) {
   absl::optional<quiche::structured_headers::Dictionary> parsed_dictionary =
       quiche::structured_headers::ParseDictionary(priority_field_value);
   if (!parsed_dictionary.has_value()) {
-    return {false, {}};
+    return std::nullopt;
   }
 
   uint8_t urgency = QuicStreamPriority::kDefaultUrgency;
@@ -77,7 +77,7 @@
     }
   }
 
-  return {true, {urgency, incremental}};
+  return QuicStreamPriority{urgency, incremental};
 }
 
 }  // namespace quic

quiche/quic/core/quic_stream_priority.h

diff --git a/quiche/quic/core/quic_stream_priority.h b/quiche/quic/core/quic_stream_priority.h
index 33f1183..04db767 100644
--- a/quiche/quic/core/quic_stream_priority.h
+++ b/quiche/quic/core/quic_stream_priority.h
@@ -10,6 +10,7 @@
 #include <tuple>
 
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "quiche/quic/platform/api/quic_export.h"
 
 namespace quic {
@@ -43,15 +44,10 @@
 QUICHE_EXPORT std::string SerializePriorityFieldValue(
     QuicStreamPriority priority);
 
-// Return type of ParsePriorityFieldValue().
-struct QUICHE_EXPORT ParsePriorityFieldValueResult {
-  bool success;
-  QuicStreamPriority priority;
-};
-
 // Parses the Priority Field Value field of a PRIORITY_UPDATE frame.
-QUICHE_EXPORT ParsePriorityFieldValueResult
-ParsePriorityFieldValue(absl::string_view priority_field_value);
+// Returns nullopt on failure.
+QUICHE_EXPORT absl::optional<QuicStreamPriority> ParsePriorityFieldValue(
+    absl::string_view priority_field_value);
 
 }  // namespace quic
 

quiche/quic/core/quic_stream_priority_test.cc

diff --git a/quiche/quic/core/quic_stream_priority_test.cc b/quiche/quic/core/quic_stream_priority_test.cc
index 1ebbabb..f379a2a 100644
--- a/quiche/quic/core/quic_stream_priority_test.cc
+++ b/quiche/quic/core/quic_stream_priority_test.cc
@@ -47,70 +47,70 @@
 
 TEST(ParsePriorityFieldValueTest, ParsePriorityFieldValue) {
   // Default values
-  ParsePriorityFieldValueResult result = ParsePriorityFieldValue("");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(3, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  absl::optional<QuicStreamPriority> result = ParsePriorityFieldValue("");
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(3, result->urgency);
+  EXPECT_FALSE(result->incremental);
 
   result = ParsePriorityFieldValue("i=?1");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(3, result.priority.urgency);
-  EXPECT_TRUE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(3, result->urgency);
+  EXPECT_TRUE(result->incremental);
 
   result = ParsePriorityFieldValue("u=5");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(5, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(5, result->urgency);
+  EXPECT_FALSE(result->incremental);
 
   result = ParsePriorityFieldValue("u=5, i");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(5, result.priority.urgency);
-  EXPECT_TRUE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(5, result->urgency);
+  EXPECT_TRUE(result->incremental);
 
   result = ParsePriorityFieldValue("i, u=1");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(1, result.priority.urgency);
-  EXPECT_TRUE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(1, result->urgency);
+  EXPECT_TRUE(result->incremental);
 
   // Duplicate values are allowed.
   result = ParsePriorityFieldValue("u=5, i=?1, i=?0, u=2");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(2, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(2, result->urgency);
+  EXPECT_FALSE(result->incremental);
 
   // Unknown parameters MUST be ignored.
   result = ParsePriorityFieldValue("a=42, u=4, i=?0");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(4, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(4, result->urgency);
+  EXPECT_FALSE(result->incremental);
 
   // Out-of-range values MUST be ignored.
   result = ParsePriorityFieldValue("u=-2, i");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(3, result.priority.urgency);
-  EXPECT_TRUE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(3, result->urgency);
+  EXPECT_TRUE(result->incremental);
 
   // Values of unexpected types MUST be ignored.
   result = ParsePriorityFieldValue("u=4.2, i=\"foo\"");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(3, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(3, result->urgency);
+  EXPECT_FALSE(result->incremental);
 
   // Values of the right type but different names are ignored.
   result = ParsePriorityFieldValue("a=4, b=?1");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(3, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(3, result->urgency);
+  EXPECT_FALSE(result->incremental);
 
   // Cannot be parsed as structured headers.
   result = ParsePriorityFieldValue("000");
-  EXPECT_FALSE(result.success);
+  EXPECT_FALSE(result.has_value());
 
   // Inner list dictionary values are ignored.
   result = ParsePriorityFieldValue("a=(1 2), u=1");
-  EXPECT_TRUE(result.success);
-  EXPECT_EQ(1, result.priority.urgency);
-  EXPECT_FALSE(result.priority.incremental);
+  ASSERT_TRUE(result.has_value());
+  EXPECT_EQ(1, result->urgency);
+  EXPECT_FALSE(result->incremental);
 }
 
 }  // namespace quic::test