Add convenience constructors for items and members with empty parameters

Many callers do not provide parameters.

PiperOrigin-RevId: 974525383

quiche/common/structured_headers.cc

diff --git a/quiche/common/structured_headers.cc b/quiche/common/structured_headers.cc
index 1bfdbd6..b0ca288 100644
--- a/quiche/common/structured_headers.cc
+++ b/quiche/common/structured_headers.cc
@@ -894,8 +894,9 @@
     default;
 ParameterizedItem::ParameterizedItem(ParameterizedItem&&) = default;
 ParameterizedItem& ParameterizedItem::operator=(ParameterizedItem&&) = default;
-ParameterizedItem::ParameterizedItem(Item id, Parameters ps)
-    : item(std::move(id)), params(std::move(ps)) {}
+ParameterizedItem::ParameterizedItem(Item item, Parameters params)
+    : item(std::move(item)), params(std::move(params)) {}
+ParameterizedItem::ParameterizedItem(Item item) : item(std::move(item)) {}
 ParameterizedItem::~ParameterizedItem() = default;
 
 ParameterizedMember::ParameterizedMember() = default;
@@ -905,21 +906,25 @@
 ParameterizedMember::ParameterizedMember(ParameterizedMember&&) = default;
 ParameterizedMember& ParameterizedMember::operator=(ParameterizedMember&&) =
     default;
-ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> id,
+ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> items,
                                          bool member_is_inner_list,
-                                         Parameters ps)
-    : member(std::move(id)),
+                                         Parameters params)
+    : member(std::move(items)),
       member_is_inner_list(member_is_inner_list),
-      params(std::move(ps)) {}
-ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> id,
-                                         Parameters ps)
-    : member(std::move(id)),
+      params(std::move(params)) {}
+ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> items,
+                                         Parameters params)
+    : member(std::move(items)),
       member_is_inner_list(true),
-      params(std::move(ps)) {}
-ParameterizedMember::ParameterizedMember(Item id, Parameters ps)
-    : member({{std::move(id), {}}}),
+      params(std::move(params)) {}
+ParameterizedMember::ParameterizedMember(std::vector<ParameterizedItem> items)
+    : member(std::move(items)), member_is_inner_list(true) {}
+ParameterizedMember::ParameterizedMember(Item item, Parameters params)
+    : member({{std::move(item), {}}}),
       member_is_inner_list(false),
-      params(std::move(ps)) {}
+      params(std::move(params)) {}
+ParameterizedMember::ParameterizedMember(Item item)
+    : member({{std::move(item), {}}}), member_is_inner_list(false) {}
 ParameterizedMember::~ParameterizedMember() = default;
 
 std::optional<std::pair<const Item&, const Parameters&>>

quiche/common/structured_headers.h

diff --git a/quiche/common/structured_headers.h b/quiche/common/structured_headers.h
index 4c8b6b2..0ee810a 100644
--- a/quiche/common/structured_headers.h
+++ b/quiche/common/structured_headers.h
@@ -203,11 +203,18 @@
   Parameters params;
 
   ParameterizedItem();
+
+  // Convenience constructor for empty parameters.
+  explicit ParameterizedItem(Item);
+
+  ParameterizedItem(Item, Parameters);
+
   ParameterizedItem(const ParameterizedItem&);
   ParameterizedItem& operator=(const ParameterizedItem&);
+
   ParameterizedItem(ParameterizedItem&&);
   ParameterizedItem& operator=(ParameterizedItem&&);
-  ParameterizedItem(Item, Parameters);
+
   ~ParameterizedItem();
 
   friend bool operator==(const ParameterizedItem&,
@@ -224,9 +231,17 @@
   // Constructor for a member that is an inner list.
   ParameterizedMember(std::vector<ParameterizedItem>, Parameters);
 
+  // Convenience constructor for a member that is an inner list with empty
+  // parameters.
+  explicit ParameterizedMember(std::vector<ParameterizedItem>);
+
   // Constructor for a member that is a single Item.
   ParameterizedMember(Item, Parameters);
 
+  // Convenience constructor for a member that is a single Item with empty
+  // parameters.
+  explicit ParameterizedMember(Item);
+
   ParameterizedMember(const ParameterizedMember&);
   ParameterizedMember& operator=(const ParameterizedMember&);
 

quiche/common/structured_headers_test.cc

diff --git a/quiche/common/structured_headers_test.cc b/quiche/common/structured_headers_test.cc
index e99e1a5..a139ac6 100644
--- a/quiche/common/structured_headers_test.cc
+++ b/quiche/common/structured_headers_test.cc
@@ -687,8 +687,8 @@
 TEST(StructuredHeaderTest, DictionaryConstructors) {
   const std::string key0 = "key0";
   const std::string key1 = "key1";
-  const ParameterizedMember member0{Item("Applepie"), {}};
-  const ParameterizedMember member1{Item("hello", Item::kByteSequenceType), {}};
+  const ParameterizedMember member0(Item("Applepie"));
+  const ParameterizedMember member1(Item("hello", Item::kByteSequenceType));
 
   Dictionary dict;
   EXPECT_TRUE(dict.empty());
@@ -711,7 +711,7 @@
 
 TEST(StructuredHeaderTest, DictionaryClear) {
   const std::string key0 = "key0";
-  const ParameterizedMember member0{Item("Applepie"), {}};
+  const ParameterizedMember member0(Item("Applepie"));
 
   Dictionary dict({{key0, member0}});
   EXPECT_EQ(1U, dict.size());
@@ -728,9 +728,9 @@
   const std::string key0 = "key0";
   const std::string key1 = "key1";
 
-  const ParameterizedMember nonempty_member0{Item("Applepie"), {}};
-  const ParameterizedMember nonempty_member1{
-      Item("hello", Item::kByteSequenceType), {}};
+  const ParameterizedMember nonempty_member0(Item("Applepie"));
+  const ParameterizedMember nonempty_member1(
+      Item("hello", Item::kByteSequenceType));
   const ParameterizedMember empty_member;
 
   Dictionary dict{{{key0, nonempty_member0}}};

quiche/web_transport/web_transport_headers.cc

diff --git a/quiche/web_transport/web_transport_headers.cc b/quiche/web_transport/web_transport_headers.cc
index cb98de5..93c00d7 100644
--- a/quiche/web_transport/web_transport_headers.cc
+++ b/quiche/web_transport/web_transport_headers.cc
@@ -100,7 +100,7 @@
   quiche::structured_headers::List list;
   list.reserve(subprotocols.size());
   for (const std::string& subprotocol : subprotocols) {
-    list.push_back(ParameterizedMember(Item(subprotocol), {}));
+    list.emplace_back(Item(subprotocol));
   }
 
   std::optional<std::string> serialized =
@@ -189,9 +189,8 @@
   std::vector<DictionaryMember> members;
   members.reserve(kInitHeaderFields.size());
   for (const auto& [field_name, field_accessor] : kInitHeaderFields) {
-    Item item(static_cast<int64_t>(header.*field_accessor));
-    members.push_back(std::make_pair(
-        field_name, ParameterizedMember(item, /*parameters=*/{})));
+    members.emplace_back(field_name,
+                         Item(static_cast<int64_t>(header.*field_accessor)));
   }
   std::optional<std::string> result =
       quiche::structured_headers::SerializeDictionary(