Clone MoqtLiveRelayQueue to MoqtRelayTrackPublisher. This begins a total refactor to fully support a pure MoQT relay. We will eventually delete MoqtLiveRelayQueue for now, as it supports moq-chat, and in turn some moq-chat tests that provide useful coverage. The classes are identical at this time, to make changes clear as they happen. PiperOrigin-RevId: 795496700
diff --git a/build/source_list.bzl b/build/source_list.bzl index 4836be9..7511956 100644 --- a/build/source_list.bzl +++ b/build/source_list.bzl
@@ -1559,6 +1559,7 @@ "quic/moqt/moqt_priority.h", "quic/moqt/moqt_probe_manager.h", "quic/moqt/moqt_publisher.h", + "quic/moqt/moqt_relay_track_publisher.h", "quic/moqt/moqt_session.h", "quic/moqt/moqt_session_callbacks.h", "quic/moqt/moqt_session_interface.h", @@ -1598,6 +1599,8 @@ "quic/moqt/moqt_priority_test.cc", "quic/moqt/moqt_probe_manager.cc", "quic/moqt/moqt_probe_manager_test.cc", + "quic/moqt/moqt_relay_track_publisher.cc", + "quic/moqt/moqt_relay_track_publisher_test.cc", "quic/moqt/moqt_session.cc", "quic/moqt/moqt_session_test.cc", "quic/moqt/moqt_subscribe_windows.cc",
diff --git a/build/source_list.gni b/build/source_list.gni index cea3274..eb1d406 100644 --- a/build/source_list.gni +++ b/build/source_list.gni
@@ -1563,6 +1563,7 @@ "src/quiche/quic/moqt/moqt_priority.h", "src/quiche/quic/moqt/moqt_probe_manager.h", "src/quiche/quic/moqt/moqt_publisher.h", + "src/quiche/quic/moqt/moqt_relay_track_publisher.h", "src/quiche/quic/moqt/moqt_session.h", "src/quiche/quic/moqt/moqt_session_callbacks.h", "src/quiche/quic/moqt/moqt_session_interface.h", @@ -1602,6 +1603,8 @@ "src/quiche/quic/moqt/moqt_priority_test.cc", "src/quiche/quic/moqt/moqt_probe_manager.cc", "src/quiche/quic/moqt/moqt_probe_manager_test.cc", + "src/quiche/quic/moqt/moqt_relay_track_publisher.cc", + "src/quiche/quic/moqt/moqt_relay_track_publisher_test.cc", "src/quiche/quic/moqt/moqt_session.cc", "src/quiche/quic/moqt/moqt_session_test.cc", "src/quiche/quic/moqt/moqt_subscribe_windows.cc",
diff --git a/build/source_list.json b/build/source_list.json index d36463d..b25abff 100644 --- a/build/source_list.json +++ b/build/source_list.json
@@ -1562,6 +1562,7 @@ "quiche/quic/moqt/moqt_priority.h", "quiche/quic/moqt/moqt_probe_manager.h", "quiche/quic/moqt/moqt_publisher.h", + "quiche/quic/moqt/moqt_relay_track_publisher.h", "quiche/quic/moqt/moqt_session.h", "quiche/quic/moqt/moqt_session_callbacks.h", "quiche/quic/moqt/moqt_session_interface.h", @@ -1601,6 +1602,8 @@ "quiche/quic/moqt/moqt_priority_test.cc", "quiche/quic/moqt/moqt_probe_manager.cc", "quiche/quic/moqt/moqt_probe_manager_test.cc", + "quiche/quic/moqt/moqt_relay_track_publisher.cc", + "quiche/quic/moqt/moqt_relay_track_publisher_test.cc", "quiche/quic/moqt/moqt_session.cc", "quiche/quic/moqt/moqt_session_test.cc", "quiche/quic/moqt/moqt_subscribe_windows.cc",
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.cc b/quiche/quic/moqt/moqt_relay_track_publisher.cc new file mode 100644 index 0000000..275caf1 --- /dev/null +++ b/quiche/quic/moqt/moqt_relay_track_publisher.cc
@@ -0,0 +1,231 @@ +// Copyright 2024 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "quiche/quic/moqt/moqt_relay_track_publisher.h" + +#include <cstdint> +#include <memory> +#include <optional> + +#include "absl/base/attributes.h" +#include "absl/strings/string_view.h" +#include "quiche/quic/moqt/moqt_cached_object.h" +#include "quiche/quic/moqt/moqt_messages.h" +#include "quiche/quic/moqt/moqt_publisher.h" +#include "quiche/common/platform/api/quiche_logging.h" +#include "quiche/common/quiche_buffer_allocator.h" +#include "quiche/common/quiche_callbacks.h" +#include "quiche/common/quiche_mem_slice.h" +#include "quiche/common/simple_buffer_allocator.h" +#include "quiche/web_transport/web_transport.h" + +namespace moqt { + +bool MoqtRelayTrackPublisher::AddFin(Location sequence, uint64_t subgroup) { + if (!forwarding_preference_.has_value() || + *forwarding_preference_ == MoqtForwardingPreference::kDatagram) { + return false; + } + auto group_it = queue_.find(sequence.group); + if (group_it == queue_.end()) { + // Group does not exist. + return false; + } + Group& group = group_it->second; + auto subgroup_it = group.subgroups.find(subgroup); + if (subgroup_it == group.subgroups.end()) { + // Subgroup does not exist. + return false; + } + if (subgroup_it->second.empty()) { + // Cannot FIN an empty subgroup. + return false; + } + if (subgroup_it->second.rbegin()->first != sequence.object) { + // The queue does not yet have the last object. + return false; + } + subgroup_it->second.rbegin()->second.fin_after_this = true; + for (MoqtObjectListener* listener : listeners_) { + listener->OnNewFinAvailable(sequence, subgroup); + } + return true; +} + +bool MoqtRelayTrackPublisher::OnStreamReset( + uint64_t group_id, uint64_t subgroup_id, + webtransport::StreamErrorCode error_code) { + if (!forwarding_preference_.has_value() || + *forwarding_preference_ == MoqtForwardingPreference::kDatagram) { + return false; + } + auto group_it = queue_.find(group_id); + if (group_it == queue_.end()) { + // Group does not exist. + return false; + } + Group& group = group_it->second; + auto subgroup_it = group.subgroups.find(subgroup_id); + if (subgroup_it == group.subgroups.end()) { + // Subgroup does not exist. + return false; + } + for (MoqtObjectListener* listener : listeners_) { + listener->OnSubgroupAbandoned(group_id, subgroup_id, error_code); + } + group.subgroups.erase(subgroup_id); + return true; +} + +bool MoqtRelayTrackPublisher::AddObject(const PublishedObjectMetadata& metadata, + absl::string_view payload, bool fin) { + const Location& sequence = metadata.location; + bool last_object_in_stream = fin; + if (queue_.size() == kMaxQueuedGroups) { + if (queue_.begin()->first > sequence.group) { + QUICHE_DLOG(INFO) << "Skipping object from group " << sequence.group + << " because it is too old."; + return true; + } + if (queue_.find(sequence.group) == queue_.end()) { + // Erase the oldest group. + for (MoqtObjectListener* listener : listeners_) { + listener->OnGroupAbandoned(queue_.begin()->first); + } + queue_.erase(queue_.begin()); + } + } + // Validate the input given previously received markers. + if (end_of_track_.has_value() && sequence > *end_of_track_) { + QUICHE_DLOG(INFO) << "Skipping object because it is after the end of the " + << "track"; + return false; + } + if (metadata.status == MoqtObjectStatus::kEndOfTrack) { + if (sequence < next_sequence_) { + QUICHE_DLOG(INFO) << "EndOfTrack is too early."; + return false; + } + // TODO(martinduke): Check that EndOfTrack has normal IDs. + end_of_track_ = sequence; + } + auto group_it = queue_.try_emplace(sequence.group); + Group& group = group_it.first->second; + if (!group_it.second) { // Group already exists. + if (group.complete && sequence.object >= group.next_object) { + QUICHE_DLOG(INFO) << "Skipping object because it is after the end of the " + << "group"; + return false; + } + if (metadata.status == MoqtObjectStatus::kEndOfGroup && + sequence.object < group.next_object) { + QUICHE_DLOG(INFO) << "Skipping EndOfGroup because it is not the last " + << "object in the group."; + return false; + } + } + auto subgroup_it = group.subgroups.try_emplace(metadata.subgroup); + auto& subgroup = subgroup_it.first->second; + if (!subgroup.empty()) { // Check if the new object is valid + CachedObject& last_object = subgroup.rbegin()->second; + if (last_object.metadata.publisher_priority != + metadata.publisher_priority) { + QUICHE_DLOG(INFO) << "Publisher priority changing in a subgroup"; + return false; + } + if (last_object.fin_after_this) { + QUICHE_DLOG(INFO) << "Skipping object because it is after the end of the " + << "subgroup"; + return false; + } + // If last_object has stream-ending status, it should have been caught by + // the fin_after_this check above. + QUICHE_DCHECK( + last_object.metadata.status != MoqtObjectStatus::kEndOfGroup && + last_object.metadata.status != MoqtObjectStatus::kEndOfTrack); + if (last_object.metadata.location.object >= sequence.object) { + QUICHE_DLOG(INFO) << "Skipping object because it does not increase the " + << "object ID monotonically in the subgroup."; + return false; + } + } + // Object is valid. Update state. + if (next_sequence_ <= sequence) { + next_sequence_ = Location{sequence.group, sequence.object + 1}; + } + if (sequence.object >= group.next_object) { + group.next_object = sequence.object + 1; + } + // Anticipate stream FIN with most non-normal objects. + switch (metadata.status) { + case MoqtObjectStatus::kEndOfTrack: + end_of_track_ = sequence; + last_object_in_stream = true; + ABSL_FALLTHROUGH_INTENDED; + case MoqtObjectStatus::kEndOfGroup: + group.complete = true; + last_object_in_stream = true; + break; + default: + break; + } + std::shared_ptr<quiche::QuicheMemSlice> slice = + payload.empty() + ? nullptr + : std::make_shared<quiche::QuicheMemSlice>(quiche::QuicheBuffer::Copy( + quiche::SimpleBufferAllocator::Get(), payload)); + subgroup.emplace(sequence.object, + CachedObject{metadata, slice, last_object_in_stream}); + for (MoqtObjectListener* listener : listeners_) { + listener->OnNewObjectAvailable(sequence, metadata.subgroup, + metadata.publisher_priority); + } + return true; +} + +std::optional<PublishedObject> MoqtRelayTrackPublisher::GetCachedObject( + uint64_t group_id, uint64_t subgroup_id, uint64_t min_object_id) const { + auto group_it = queue_.find(group_id); + if (group_it == queue_.end()) { + // Group does not exist. + return std::nullopt; + } + const Group& group = group_it->second; + auto subgroup_it = group.subgroups.find(subgroup_id); + if (subgroup_it == group.subgroups.end()) { + // Subgroup does not exist. + return std::nullopt; + } + const Subgroup& subgroup = subgroup_it->second; + if (subgroup.empty()) { + return std::nullopt; // There are no objects. + } + // Find an object with ID of at least min_object_id. + auto object_it = subgroup.lower_bound(min_object_id); + if (object_it == subgroup.end()) { + // No object after the last one received. + return std::nullopt; + } + return CachedObjectToPublishedObject(object_it->second); +} + +void MoqtRelayTrackPublisher::ForAllObjects( + quiche::UnretainedCallback<void(const CachedObject&)> callback) { + for (auto& group_it : queue_) { + for (auto& subgroup_it : group_it.second.subgroups) { + for (auto& object_it : subgroup_it.second) { + callback(object_it.second); + } + } + } +} + +std::optional<Location> MoqtRelayTrackPublisher::largest_location() const { + if (queue_.empty()) { + return std::nullopt; + } + return Location{next_sequence_.group, next_sequence_.object - 1}; +} + +} // namespace moqt
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.h b/quiche/quic/moqt/moqt_relay_track_publisher.h new file mode 100644 index 0000000..22cba24 --- /dev/null +++ b/quiche/quic/moqt/moqt_relay_track_publisher.h
@@ -0,0 +1,193 @@ +// Copyright 2024 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef QUICHE_QUIC_MOQT_MOQT_RELAY_TRACK_PUBLISHER_H_ +#define QUICHE_QUIC_MOQT_MOQT_RELAY_TRACK_PUBLISHER_H_ + +#include <cstddef> +#include <cstdint> +#include <memory> +#include <optional> +#include <utility> + +#include "absl/container/btree_map.h" +#include "absl/container/flat_hash_set.h" +#include "absl/status/status.h" +#include "absl/strings/string_view.h" +#include "quiche/quic/core/quic_clock.h" +#include "quiche/quic/core/quic_default_clock.h" +#include "quiche/quic/core/quic_time.h" +#include "quiche/quic/moqt/moqt_cached_object.h" +#include "quiche/quic/moqt/moqt_failed_fetch.h" +#include "quiche/quic/moqt/moqt_messages.h" +#include "quiche/quic/moqt/moqt_priority.h" +#include "quiche/quic/moqt/moqt_publisher.h" +#include "quiche/common/quiche_callbacks.h" +#include "quiche/web_transport/web_transport.h" + +namespace moqt { + +// MoqtRelayTrackPublisher lets the user send objects by providing the contents +// of the object and the object metadata. It will store these by sequence +// number. When called on to provide a range of objects, it will fill in any +// missing objects and groups. +// +// The queue will maintain a buffer of three most recent groups that will be +// provided to subscribers automatically. +// +// This class is primarily meant to be used by live relays to buffer the +// frames that arrive for a short time. +class MoqtRelayTrackPublisher : public MoqtTrackPublisher { + public: + MoqtRelayTrackPublisher( + FullTrackName track, + std::optional<MoqtForwardingPreference> forwarding_preference, + std::optional<MoqtDeliveryOrder> delivery_order, + std::optional<quic::QuicTime> expiration = quic::QuicTime::Infinite(), + const quic::QuicClock* clock = quic::QuicDefaultClock::Get()) + : clock_(clock), + track_(std::move(track)), + forwarding_preference_(forwarding_preference), + delivery_order_(delivery_order), + expiration_(expiration), + next_sequence_(0, 0) {} + + MoqtRelayTrackPublisher(const MoqtRelayTrackPublisher&) = delete; + MoqtRelayTrackPublisher(MoqtRelayTrackPublisher&&) = default; + MoqtRelayTrackPublisher& operator=(const MoqtRelayTrackPublisher&) = delete; + MoqtRelayTrackPublisher& operator=(MoqtRelayTrackPublisher&&) = default; + + // Publish a received object. Returns false if the object is invalid, given + // other non-normal objects indicate that the sequence number should not + // occur. A false return value might result in a session error on the + // inbound session, but this queue is the only place that retains enough state + // to check. + bool AddObject(const PublishedObjectMetadata& metadata, + absl::string_view payload, bool fin); + + // Convenience methods primarily for use in tests. Prefer the + // `PublishedObjectMetadata` version in real forwarding code to ensure all + // metadata is copied correctly. + bool AddObject(Location location, uint64_t subgroup, MoqtObjectStatus status, + bool fin = false) { + PublishedObjectMetadata metadata; + metadata.location = location; + metadata.subgroup = subgroup; + metadata.status = status; + metadata.publisher_priority = 0; + return AddObject(metadata, "", fin); + } + bool AddObject(Location location, uint64_t subgroup, absl::string_view object, + bool fin = false) { + PublishedObjectMetadata metadata; + metadata.location = location; + metadata.subgroup = subgroup; + metadata.status = MoqtObjectStatus::kNormal; + metadata.publisher_priority = 0; + return AddObject(metadata, object, fin); + } + + // Record a received FIN from upstream that did not come with the last object. + // If the forwarding preference is kDatagram or kTrack, |sequence| is ignored. + // Otherwise, |sequence| is used to determine which stream is being FINed. If + // the object ID does not match the last object ID in the stream, no action + // is taken. + bool AddFin(Location sequence, uint64_t subgroup_id); + // Record a received RESET_STREAM from upstream. Returns false on datagram + // tracks, or if the stream does not exist. + bool OnStreamReset(uint64_t group_id, uint64_t subgroup_id, + webtransport::StreamErrorCode error_code); + + // MoqtTrackPublisher implementation. + const FullTrackName& GetTrackName() const override { return track_; } + std::optional<PublishedObject> GetCachedObject( + uint64_t group_id, uint64_t subgroup_id, + uint64_t min_object) const override; + void AddObjectListener(MoqtObjectListener* listener) override { + listeners_.insert(listener); + listener->OnSubscribeAccepted(); + } + void RemoveObjectListener(MoqtObjectListener* listener) override { + listeners_.erase(listener); + } + std::optional<Location> largest_location() const override; + std::optional<MoqtForwardingPreference> forwarding_preference() + const override { + return forwarding_preference_; + } + std::optional<MoqtDeliveryOrder> delivery_order() const override { + return delivery_order_; + } + std::optional<quic::QuicTimeDelta> expiration() const override { + if (!expiration_.has_value()) { + return std::nullopt; + } + if (expiration_ == quic::QuicTime::Infinite()) { + return quic::QuicTimeDelta::Zero(); + } + if (expiration_ < clock_->Now()) { + // TODO(martinduke): Tear everything down; the track is expired. + return quic::QuicTimeDelta::Zero(); + } + return clock_->Now() - *expiration_; + } + std::unique_ptr<MoqtFetchTask> StandaloneFetch( + Location /*start*/, Location /*end*/, + std::optional<MoqtDeliveryOrder> /*order*/) override { + return std::make_unique<MoqtFailedFetch>( + absl::UnimplementedError("Fetch not implemented")); + } + std::unique_ptr<MoqtFetchTask> RelativeFetch( + uint64_t /*group_diff*/, + std::optional<MoqtDeliveryOrder> /*order*/) override { + return std::make_unique<MoqtFailedFetch>( + absl::UnimplementedError("Fetch not implemented")); + } + std::unique_ptr<MoqtFetchTask> AbsoluteFetch( + uint64_t /*group*/, std::optional<MoqtDeliveryOrder> /*order*/) override { + return std::make_unique<MoqtFailedFetch>( + absl::UnimplementedError("Fetch not implemented")); + } + + bool HasSubscribers() const { return !listeners_.empty(); } + + // Since MoqtTrackPublisher is generally held in a shared_ptr, an explicit + // call allows all the listeners to delete their reference and actually + // destroy the object. + void RemoveAllSubscriptions() { + for (MoqtObjectListener* listener : listeners_) { + listener->OnTrackPublisherGone(); + } + } + + void ForAllObjects( + quiche::UnretainedCallback<void(const CachedObject&)> callback); + + private: + // The number of recent groups to keep around for newly joined subscribers. + static constexpr size_t kMaxQueuedGroups = 3; + + // Ordered by object id. + using Subgroup = absl::btree_map<uint64_t, CachedObject>; + + struct Group { + uint64_t next_object = 0; + bool complete = false; // If true, kEndOfGroup has been received. + absl::btree_map<uint64_t, Subgroup> subgroups; // Ordered by subgroup id. + }; + + const quic::QuicClock* clock_; + FullTrackName track_; + std::optional<MoqtForwardingPreference> forwarding_preference_; + std::optional<MoqtDeliveryOrder> delivery_order_; + std::optional<quic::QuicTime> expiration_; + absl::btree_map<uint64_t, Group> queue_; // Ordered by group id. + absl::flat_hash_set<MoqtObjectListener*> listeners_; + std::optional<Location> end_of_track_; + Location next_sequence_; +}; + +} // namespace moqt + +#endif // QUICHE_QUIC_MOQT_MOQT_RELAY_TRACK_PUBLISHER_H_
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc new file mode 100644 index 0000000..6b24c91 --- /dev/null +++ b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
@@ -0,0 +1,476 @@ +// Copyright 2024 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "quiche/quic/moqt/moqt_relay_track_publisher.h" + +#include <cstdint> +#include <optional> + +#include "absl/strings/string_view.h" +#include "quiche/quic/core/quic_time.h" +#include "quiche/quic/moqt/moqt_cached_object.h" +#include "quiche/quic/moqt/moqt_messages.h" +#include "quiche/quic/moqt/moqt_priority.h" +#include "quiche/quic/moqt/moqt_publisher.h" +#include "quiche/quic/moqt/moqt_subscribe_windows.h" +#include "quiche/common/platform/api/quiche_logging.h" +#include "quiche/common/platform/api/quiche_test.h" +#include "quiche/web_transport/web_transport.h" + +namespace moqt::test { + +namespace { + +class TestMoqtRelayTrackPublisher : public MoqtRelayTrackPublisher, + public MoqtObjectListener { + public: + TestMoqtRelayTrackPublisher() + : MoqtRelayTrackPublisher( + FullTrackName{"test", "track"}, MoqtForwardingPreference::kSubgroup, + MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite()) { + AddObjectListener(this); + } + + void OnNewObjectAvailable(Location sequence, uint64_t subgroup_id, + MoqtPriority /*publisher_priority*/) { + std::optional<PublishedObject> object = + GetCachedObject(sequence.group, subgroup_id, sequence.object); + QUICHE_CHECK(object.has_value()); + if (!object.has_value()) { + return; + } + switch (object->metadata.status) { + case MoqtObjectStatus::kNormal: + PublishObject(object->metadata.location.group, + object->metadata.location.object, + object->payload.AsStringView()); + break; + case MoqtObjectStatus::kObjectDoesNotExist: + SkipObject(object->metadata.location.group, + object->metadata.location.object); + break; + case MoqtObjectStatus::kEndOfGroup: + CloseStreamForGroup(object->metadata.location.group); + break; + case MoqtObjectStatus::kEndOfTrack: + CloseTrack(); + break; + default: + EXPECT_TRUE(false); + } + if (object->fin_after_this) { + CloseStreamForSubgroup(object->metadata.location.group, + object->metadata.subgroup); + } + } + + void GetObjectsFromPast(const SubscribeWindow& window) { + ForAllObjects([&](const CachedObject& object) { + if (window.InWindow(object.metadata.location)) { + OnNewObjectAvailable(object.metadata.location, object.metadata.subgroup, + object.metadata.publisher_priority); + } + }); + } + + MOCK_METHOD(void, OnNewFinAvailable, (Location sequence, uint64_t subgroup)); + MOCK_METHOD(void, OnSubgroupAbandoned, + (uint64_t group, uint64_t subgroup, + webtransport::StreamErrorCode error_code)); + MOCK_METHOD(void, OnGroupAbandoned, (uint64_t group_id)); + MOCK_METHOD(void, CloseStreamForGroup, (uint64_t group_id), ()); + MOCK_METHOD(void, CloseStreamForSubgroup, + (uint64_t group_id, uint64_t subgroup_id), ()); + MOCK_METHOD(void, PublishObject, + (uint64_t group_id, uint64_t object_id, + absl::string_view payload), + ()); + MOCK_METHOD(void, SkipObject, (uint64_t group_id, uint64_t object_id), ()); + MOCK_METHOD(void, CloseTrack, (), ()); + MOCK_METHOD(void, OnTrackPublisherGone, (), (override)); + MOCK_METHOD(void, OnSubscribeAccepted, (), (override)); + MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason), + (override)); +}; + +// Duplicates of MoqtOutgoingQueue test cases. +TEST(MoqtRelayTrackPublisher, SingleGroup) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + EXPECT_TRUE( + queue.AddObject(Location{0, 3}, 0, MoqtObjectStatus::kEndOfGroup)); +} + +TEST(MoqtRelayTrackPublisher, SingleGroupPastSubscribeFromZero) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + queue.GetObjectsFromPast(SubscribeWindow()); +} + +TEST(MoqtRelayTrackPublisher, SingleGroupPastSubscribeFromMidGroup) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + queue.GetObjectsFromPast(SubscribeWindow(Location(0, 1))); +} + +TEST(MoqtRelayTrackPublisher, TwoGroups) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + EXPECT_CALL(queue, PublishObject(1, 0, "d")); + EXPECT_CALL(queue, PublishObject(1, 1, "e")); + EXPECT_CALL(queue, PublishObject(1, 2, "f")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + EXPECT_TRUE( + queue.AddObject(Location{0, 3}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{1, 0}, 0, "d")); + EXPECT_TRUE(queue.AddObject(Location{1, 1}, 0, "e")); + EXPECT_TRUE(queue.AddObject(Location{1, 2}, 0, "f")); +} + +TEST(MoqtRelayTrackPublisher, TwoGroupsPastSubscribe) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + EXPECT_CALL(queue, PublishObject(1, 0, "d")); + EXPECT_CALL(queue, PublishObject(1, 1, "e")); + EXPECT_CALL(queue, PublishObject(1, 2, "f")); + + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + EXPECT_CALL(queue, PublishObject(1, 0, "d")); + EXPECT_CALL(queue, PublishObject(1, 1, "e")); + EXPECT_CALL(queue, PublishObject(1, 2, "f")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + EXPECT_TRUE( + queue.AddObject(Location{0, 3}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{1, 0}, 0, "d")); + EXPECT_TRUE(queue.AddObject(Location{1, 1}, 0, "e")); + EXPECT_TRUE(queue.AddObject(Location{1, 2}, 0, "f")); + queue.GetObjectsFromPast(SubscribeWindow(Location(0, 1))); +} + +TEST(MoqtRelayTrackPublisher, FiveGroups) { + TestMoqtRelayTrackPublisher queue; + ; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + EXPECT_CALL(queue, PublishObject(1, 0, "c")); + EXPECT_CALL(queue, PublishObject(1, 1, "d")); + EXPECT_CALL(queue, CloseStreamForGroup(1)); + EXPECT_CALL(queue, PublishObject(2, 0, "e")); + EXPECT_CALL(queue, PublishObject(2, 1, "f")); + EXPECT_CALL(queue, CloseStreamForGroup(2)); + EXPECT_CALL(queue, OnGroupAbandoned(0)); + EXPECT_CALL(queue, PublishObject(3, 0, "g")); + EXPECT_CALL(queue, PublishObject(3, 1, "h")); + EXPECT_CALL(queue, CloseStreamForGroup(3)); + EXPECT_CALL(queue, OnGroupAbandoned(1)); + EXPECT_CALL(queue, PublishObject(4, 0, "i")); + EXPECT_CALL(queue, PublishObject(4, 1, "j")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE( + queue.AddObject(Location{0, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{1, 0}, 0, "c")); + EXPECT_TRUE(queue.AddObject(Location{1, 1}, 0, "d")); + EXPECT_TRUE( + queue.AddObject(Location{1, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{2, 0}, 0, "e")); + EXPECT_TRUE(queue.AddObject(Location{2, 1}, 0, "f")); + EXPECT_TRUE( + queue.AddObject(Location{2, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{3, 0}, 0, "g")); + EXPECT_TRUE(queue.AddObject(Location{3, 1}, 0, "h")); + EXPECT_TRUE( + queue.AddObject(Location{3, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{4, 0}, 0, "i")); + EXPECT_TRUE(queue.AddObject(Location{4, 1}, 0, "j")); +} + +TEST(MoqtRelayTrackPublisher, FiveGroupsPastSubscribe) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + EXPECT_CALL(queue, PublishObject(1, 0, "c")); + EXPECT_CALL(queue, PublishObject(1, 1, "d")); + EXPECT_CALL(queue, CloseStreamForGroup(1)); + EXPECT_CALL(queue, PublishObject(2, 0, "e")); + EXPECT_CALL(queue, PublishObject(2, 1, "f")); + EXPECT_CALL(queue, CloseStreamForGroup(2)); + EXPECT_CALL(queue, OnGroupAbandoned(0)); + EXPECT_CALL(queue, PublishObject(3, 0, "g")); + EXPECT_CALL(queue, PublishObject(3, 1, "h")); + EXPECT_CALL(queue, CloseStreamForGroup(3)); + EXPECT_CALL(queue, OnGroupAbandoned(1)); + EXPECT_CALL(queue, PublishObject(4, 0, "i")); + EXPECT_CALL(queue, PublishObject(4, 1, "j")); + + // Past SUBSCRIBE would only get the three most recent groups. + EXPECT_CALL(queue, PublishObject(2, 0, "e")); + EXPECT_CALL(queue, PublishObject(2, 1, "f")); + EXPECT_CALL(queue, CloseStreamForGroup(2)); + EXPECT_CALL(queue, PublishObject(3, 0, "g")); + EXPECT_CALL(queue, PublishObject(3, 1, "h")); + EXPECT_CALL(queue, CloseStreamForGroup(3)); + EXPECT_CALL(queue, PublishObject(4, 0, "i")); + EXPECT_CALL(queue, PublishObject(4, 1, "j")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE( + queue.AddObject(Location{0, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{1, 0}, 0, "c")); + EXPECT_TRUE(queue.AddObject(Location{1, 1}, 0, "d")); + EXPECT_TRUE( + queue.AddObject(Location{1, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{2, 0}, 0, "e")); + EXPECT_TRUE(queue.AddObject(Location{2, 1}, 0, "f")); + EXPECT_TRUE( + queue.AddObject(Location{2, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{3, 0}, 0, "g")); + EXPECT_TRUE(queue.AddObject(Location{3, 1}, 0, "h")); + EXPECT_TRUE( + queue.AddObject(Location{3, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{4, 0}, 0, "i")); + EXPECT_TRUE(queue.AddObject(Location{4, 1}, 0, "j")); + queue.GetObjectsFromPast(SubscribeWindow()); +} + +TEST(MoqtRelayTrackPublisher, FiveGroupsPastSubscribeFromMidGroup) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(1, 0, "c")); + EXPECT_CALL(queue, PublishObject(1, 1, "d")); + EXPECT_CALL(queue, CloseStreamForGroup(1)); + EXPECT_CALL(queue, PublishObject(2, 0, "e")); + EXPECT_CALL(queue, PublishObject(2, 1, "f")); + EXPECT_CALL(queue, CloseStreamForGroup(2)); + EXPECT_CALL(queue, OnGroupAbandoned(0)); + EXPECT_CALL(queue, PublishObject(3, 0, "g")); + EXPECT_CALL(queue, PublishObject(3, 1, "h")); + EXPECT_CALL(queue, CloseStreamForGroup(3)); + EXPECT_CALL(queue, OnGroupAbandoned(1)); + EXPECT_CALL(queue, PublishObject(4, 0, "i")); + EXPECT_CALL(queue, PublishObject(4, 1, "j")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{1, 0}, 0, "c")); + EXPECT_TRUE(queue.AddObject(Location{1, 1}, 0, "d")); + EXPECT_TRUE( + queue.AddObject(Location{1, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{2, 0}, 0, "e")); + EXPECT_TRUE(queue.AddObject(Location{2, 1}, 0, "f")); + EXPECT_TRUE( + queue.AddObject(Location{2, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{3, 0}, 0, "g")); + EXPECT_TRUE(queue.AddObject(Location{3, 1}, 0, "h")); + EXPECT_TRUE( + queue.AddObject(Location{3, 2}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE(queue.AddObject(Location{4, 0}, 0, "i")); + EXPECT_TRUE(queue.AddObject(Location{4, 1}, 0, "j")); + // This object will be ignored, but this is not an error. + EXPECT_TRUE( + queue.AddObject(Location{0, 2}, 0, MoqtObjectStatus::kEndOfGroup)); +} + +TEST(MoqtRelayTrackPublisher, EndOfTrack) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, CloseTrack()); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + EXPECT_FALSE( + queue.AddObject(Location{0, 1}, 0, MoqtObjectStatus::kEndOfTrack)); + EXPECT_TRUE( + queue.AddObject(Location{1, 0}, 0, MoqtObjectStatus::kEndOfTrack)); +} + +TEST(MoqtRelayTrackPublisher, EndOfGroup) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, CloseStreamForGroup(0)); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + EXPECT_FALSE( + queue.AddObject(Location{0, 1}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_TRUE( + queue.AddObject(Location{0, 3}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_FALSE(queue.AddObject(Location{0, 4}, 0, "e")); +} + +TEST(MoqtRelayTrackPublisher, OverwriteObject) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 0, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 0, "c")); + EXPECT_TRUE( + queue.AddObject(Location{0, 3}, 0, MoqtObjectStatus::kEndOfGroup)); + EXPECT_FALSE(queue.AddObject(Location{0, 1}, 0, "invalid")); +} + +TEST(MoqtRelayTrackPublisher, DifferentSubgroups) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 3, "d")); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, OnNewFinAvailable(Location{0, 3}, 0)); + EXPECT_CALL(queue, PublishObject(0, 5, "e")); + EXPECT_CALL(queue, PublishObject(0, 7, "f")); + EXPECT_CALL(queue, OnNewFinAvailable(Location{0, 5}, 1)); + EXPECT_CALL(queue, OnNewFinAvailable(Location{0, 7}, 2)); + + // Serve them back in strict subgroup order. + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, PublishObject(0, 3, "d")); + EXPECT_CALL(queue, CloseStreamForSubgroup(0, 0)); + EXPECT_CALL(queue, PublishObject(0, 1, "b")); + EXPECT_CALL(queue, PublishObject(0, 5, "e")); + EXPECT_CALL(queue, CloseStreamForSubgroup(0, 1)); + EXPECT_CALL(queue, PublishObject(0, 2, "c")); + EXPECT_CALL(queue, PublishObject(0, 7, "f")); + EXPECT_CALL(queue, CloseStreamForSubgroup(0, 2)); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddObject(Location{0, 1}, 1, "b")); + EXPECT_TRUE(queue.AddObject(Location{0, 3}, 0, "d")); + EXPECT_TRUE(queue.AddObject(Location{0, 2}, 2, "c")); + EXPECT_TRUE(queue.AddFin(Location{0, 3}, 0)); + EXPECT_TRUE(queue.AddObject(Location{0, 5}, 1, "e")); + EXPECT_TRUE(queue.AddObject(Location{0, 7}, 2, "f")); + EXPECT_TRUE(queue.AddFin(Location{0, 5}, 1)); + EXPECT_TRUE(queue.AddFin(Location{0, 7}, 2)); + queue.GetObjectsFromPast(SubscribeWindow()); +} + +TEST(MoqtRelayTrackPublisher, EndOfSubgroup) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, OnNewFinAvailable(Location{0, 0}, 0)); + EXPECT_CALL(queue, PublishObject(0, 2, "b")).Times(0); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.AddFin(Location{0, 0}, 0)); + EXPECT_FALSE(queue.AddObject(Location{0, 2}, 0, "b")); +} + +TEST(MoqtRelayTrackPublisher, AddObjectWithFin) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a", true)); + std::optional<PublishedObject> object = queue.GetCachedObject(0, 0, 0); + ASSERT_TRUE(object.has_value()); + EXPECT_EQ(object->metadata.status, MoqtObjectStatus::kNormal); + EXPECT_TRUE(object->fin_after_this); +} + +TEST(MoqtRelayTrackPublisher, LateFin) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a", false)); + EXPECT_CALL(queue, OnNewFinAvailable(Location{0, 0}, 0)); + EXPECT_TRUE(queue.AddFin(Location{0, 0}, 0)); + std::optional<PublishedObject> object = queue.GetCachedObject(0, 0, 0); + ASSERT_TRUE(object.has_value()); + EXPECT_EQ(object->metadata.status, MoqtObjectStatus::kNormal); + EXPECT_TRUE(object->fin_after_this); +} + +TEST(MoqtRelayTrackPublisher, StreamReset) { + TestMoqtRelayTrackPublisher queue; + { + testing::InSequence seq; + EXPECT_CALL(queue, PublishObject(0, 0, "a")); + EXPECT_CALL(queue, OnSubgroupAbandoned(0, 0, 0x1)); + } + EXPECT_TRUE(queue.AddObject(Location{0, 0}, 0, "a")); + EXPECT_TRUE(queue.OnStreamReset(0, 0, 0x1)); +} + +} // namespace + +} // namespace moqt::test