Allow EndOfGroup status with payload in MoQT datagrams.

This is new in draft-12.

PiperOrigin-RevId: 791686611
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index d647785..fdaac7e 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -340,8 +340,10 @@
         << "Payload length does not match payload";
     return quiche::QuicheBuffer();
   }
-  MoqtDatagramType datagram_type(/*has_status=*/payload.empty(),
-                                 !message.extension_headers.empty());
+  MoqtDatagramType datagram_type(
+      /*has_status=*/payload.empty(), !message.extension_headers.empty(),
+      !payload.empty() &&
+          message.object_status == MoqtObjectStatus::kEndOfGroup);
   std::optional<absl::string_view> extensions =
       datagram_type.has_extension()
           ? std::optional<absl::string_view>(message.extension_headers)
@@ -827,6 +829,7 @@
 bool MoqtFramer::ValidateObjectMetadata(const MoqtObject& object,
                                         bool is_datagram) {
   if (object.object_status != MoqtObjectStatus::kNormal &&
+      object.object_status != MoqtObjectStatus::kEndOfGroup &&
       object.payload_length > 0) {
     return false;
   }
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index 3ee0fc1..db3252b 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -324,7 +324,7 @@
   quiche::QuicheBuffer buffer;
 
   // Non-normal status must have no payload.
-  object.object_status = MoqtObjectStatus::kEndOfGroup;
+  object.object_status = MoqtObjectStatus::kObjectDoesNotExist;
   EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
                       object, MoqtDataStreamType::Subgroup(8, 0, false), false),
                   "Object metadata is invalid");
@@ -346,7 +346,7 @@
   };
   quiche::QuicheBuffer buffer;
 
-  object.object_status = MoqtObjectStatus::kEndOfGroup;
+  object.object_status = MoqtObjectStatus::kObjectDoesNotExist;
   EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foo"),
                   "Object metadata is invalid");
   EXPECT_TRUE(buffer.empty());
@@ -365,7 +365,8 @@
 
 TEST_F(MoqtFramerSimpleTest, Datagram) {
   auto datagram = std::make_unique<ObjectDatagramMessage>(
-      MoqtDatagramType(/*has_status=*/false, /*has_extension=*/true));
+      MoqtDatagramType(/*has_status=*/false, /*has_extension=*/true,
+                       /*end_of_group=*/false));
   MoqtObject object = {
       /*track_alias=*/4,
       /*group_id=*/5,
@@ -384,8 +385,28 @@
 }
 
 TEST_F(MoqtFramerSimpleTest, DatagramStatus) {
-  auto datagram =
-      std::make_unique<ObjectDatagramMessage>(MoqtDatagramType(true, true));
+  auto datagram = std::make_unique<ObjectDatagramMessage>(
+      MoqtDatagramType(true, true, false));
+  MoqtObject object = {
+      /*track_alias=*/4,
+      /*group_id=*/5,
+      /*object_id=*/6,
+      /*publisher_priority=*/7,
+      std::string(kDefaultExtensionBlob),
+      /*object_status=*/MoqtObjectStatus::kObjectDoesNotExist,
+      /*subgroup_id=*/6,
+      /*payload_length=*/0,
+  };
+  quiche::QuicheBuffer buffer;
+  buffer = framer_.SerializeObjectDatagram(object, "");
+  EXPECT_EQ(buffer.size(), datagram->total_message_size());
+  EXPECT_EQ(buffer.AsStringView(), datagram->PacketSample());
+}
+
+TEST_F(MoqtFramerSimpleTest, DatagramEndOfGroup) {
+  auto datagram = std::make_unique<ObjectDatagramMessage>(
+      MoqtDatagramType(/*has_status=*/false, /*has_extension=*/true,
+                       /*end_of_group=*/true));
   MoqtObject object = {
       /*track_alias=*/4,
       /*group_id=*/5,
@@ -394,10 +415,11 @@
       std::string(kDefaultExtensionBlob),
       /*object_status=*/MoqtObjectStatus::kEndOfGroup,
       /*subgroup_id=*/6,
-      /*payload_length=*/0,
+      /*payload_length=*/3,
   };
+  std::string payload = "foo";
   quiche::QuicheBuffer buffer;
-  buffer = framer_.SerializeObjectDatagram(object, "");
+  buffer = framer_.SerializeObjectDatagram(object, payload);
   EXPECT_EQ(buffer.size(), datagram->total_message_size());
   EXPECT_EQ(buffer.AsStringView(), datagram->PacketSample());
 }
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index c5c2a79..4c19e6a 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -193,24 +193,38 @@
 
 class QUICHE_EXPORT MoqtDatagramType {
  public:
-  MoqtDatagramType(bool has_status, bool has_extension) : value_(0) {
-    if (has_status) {
-      value_ |= 0x02;
-    }
+  MoqtDatagramType(bool has_status, bool has_extension, bool end_of_group)
+      : value_(0) {
     if (has_extension) {
       value_ |= 0x01;
     }
+    if (end_of_group) {
+      value_ |= 0x02;
+    }
+    if (has_status) {
+      value_ |= 0x04;
+    }
+    if (value_ > 0x5) {
+      QUICHE_BUG(Moqt_invalid_datagram_type)
+          << "Invalid datagram type: " << value_;
+      // Clear the end of group bit.
+      value_ &= 0x5;
+      return;
+    }
   }
   static std::optional<MoqtDatagramType> FromValue(uint64_t value) {
-    if (value <= 3) {
+    if (value <= 5) {
       return MoqtDatagramType(value);
     }
     return std::nullopt;
   }
-  bool has_status() const { return value_ & 0x02; }
+  bool has_status() const { return value_ & 0x04; }
+  bool end_of_group() const { return value_ & 0x02; }
   bool has_extension() const { return value_ & 0x01; }
   uint64_t value() const { return value_; }
 
+  bool operator==(const MoqtDatagramType& other) const = default;
+
  private:
   uint64_t value_;
   explicit MoqtDatagramType(uint64_t value) : value_(value) {}
diff --git a/quiche/quic/moqt/moqt_messages_test.cc b/quiche/quic/moqt/moqt_messages_test.cc
index 1eafaa7..c799137 100644
--- a/quiche/quic/moqt/moqt_messages_test.cc
+++ b/quiche/quic/moqt/moqt_messages_test.cc
@@ -4,6 +4,7 @@
 
 #include "quiche/quic/moqt/moqt_messages.h"
 
+#include <optional>
 #include <vector>
 
 #include "absl/hash/hash.h"
@@ -94,5 +95,26 @@
                     "Constructing a namespace that is too large.");
 }
 
+TEST(MoqtMessagesTest, MoqtDatagramType) {
+  for (bool has_status : {false, true}) {
+    for (bool has_extension : {false, true}) {
+      for (bool end_of_group : {false, true}) {
+        if (has_status && end_of_group) {
+          EXPECT_QUICHE_BUG(
+              MoqtDatagramType(has_status, has_extension, end_of_group),
+              "Invalid datagram type");
+          continue;
+        }
+        MoqtDatagramType type(has_status, has_extension, end_of_group);
+        EXPECT_EQ(type.has_status(), has_status);
+        EXPECT_EQ(type.has_extension(), has_extension);
+        std::optional<MoqtDatagramType> from_value =
+            MoqtDatagramType::FromValue(type.value());
+        EXPECT_TRUE(from_value.has_value() && type == *from_value);
+      }
+    }
+  }
+}
+
 }  // namespace
 }  // namespace moqt::test
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index fd7078a..c623693 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -1300,6 +1300,16 @@
   if (!datagram_type.has_value()) {
     return std::nullopt;
   }
+  if (datagram_type->end_of_group()) {
+    object_metadata.object_status = MoqtObjectStatus::kEndOfGroup;
+    if (datagram_type->has_status()) {
+      QUICHE_BUG(Moqt_invalid_datagram_type)
+          << "Invalid datagram type: " << type_raw;
+      return std::nullopt;
+    }
+  } else {
+    object_metadata.object_status = MoqtObjectStatus::kNormal;
+  }
   if (datagram_type->has_extension()) {
     if (!reader.ReadStringPieceVarInt62(&extensions)) {
       return std::nullopt;
@@ -1319,7 +1329,6 @@
     return "";
   }
   absl::string_view payload = reader.ReadRemainingPayload();
-  object_metadata.object_status = MoqtObjectStatus::kNormal;
   object_metadata.payload_length = payload.length();
   return payload;
 }
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index ae42a62..d93b3f0 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -1317,7 +1317,7 @@
 }
 
 TEST_F(MoqtMessageSpecificTest, TruncatedDatagram) {
-  ObjectDatagramMessage message(MoqtDatagramType(false, true));
+  ObjectDatagramMessage message(MoqtDatagramType(false, true, false));
   message.set_wire_image_size(4);
   MoqtObject object;
   std::optional<absl::string_view> payload =
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index 313000c..850af54 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -33,10 +33,10 @@
     "\x00\x0c\x01\x03\x66\x6f\x6f", 7);
 
 const MoqtDatagramType kMoqtDatagramTypes[] = {
-    MoqtDatagramType(false, false),
-    MoqtDatagramType(false, true),
-    MoqtDatagramType(true, false),
-    MoqtDatagramType(true, true),
+    MoqtDatagramType(false, false, true), MoqtDatagramType(false, false, false),
+    MoqtDatagramType(false, true, true),  MoqtDatagramType(false, true, false),
+    MoqtDatagramType(true, false, false), MoqtDatagramType(true, true, false),
+    // Cannot have status and end_of_group both be true.
 };
 
 const MoqtDataStreamType kMoqtDataStreamTypes[] = {
@@ -239,10 +239,12 @@
     object_.subgroup_id = object_.object_id;
     // Update ObjectMessage::object_ to match the datagram type.
     if (datagram_type.has_status()) {
-      object_.object_status = MoqtObjectStatus::kEndOfGroup;
+      object_.object_status = MoqtObjectStatus::kObjectDoesNotExist;
       object_.payload_length = 0;
     } else {
-      object_.object_status = MoqtObjectStatus::kNormal;
+      object_.object_status = datagram_type.end_of_group()
+                                  ? MoqtObjectStatus::kEndOfGroup
+                                  : MoqtObjectStatus::kNormal;
       object_.payload_length = 3;
     }
     if (datagram_type.has_extension()) {