Rename max_subscribe_id to max_request_id. PiperOrigin-RevId: 754909511
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc index b6cf1b3..7c7f649 100644 --- a/quiche/quic/moqt/moqt_framer.cc +++ b/quiche/quic/moqt/moqt_framer.cc
@@ -206,8 +206,8 @@ parameters.perspective == quic::Perspective::IS_CLIENT) { out.insert(SetupParameter::kPath, parameters.path); } - if (parameters.max_subscribe_id > 0) { - out.insert(SetupParameter::kMaxRequestId, parameters.max_subscribe_id); + if (parameters.max_request_id > 0) { + out.insert(SetupParameter::kMaxRequestId, parameters.max_request_id); } if (parameters.max_auth_token_cache_size > 0) { out.insert(SetupParameter::kMaxAuthTokenCacheSize, @@ -658,10 +658,10 @@ WireFullTrackName(message.track_namespace, false)); } -quiche::QuicheBuffer MoqtFramer::SerializeMaxSubscribeId( - const MoqtMaxSubscribeId& message) { - return SerializeControlMessage(MoqtMessageType::kMaxSubscribeId, - WireVarInt62(message.max_subscribe_id)); +quiche::QuicheBuffer MoqtFramer::SerializeMaxRequestId( + const MoqtMaxRequestId& message) { + return SerializeControlMessage(MoqtMessageType::kMaxRequestId, + WireVarInt62(message.max_request_id)); } quiche::QuicheBuffer MoqtFramer::SerializeFetch(const MoqtFetch& message) {
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h index 6dae728..d0c7996 100644 --- a/quiche/quic/moqt/moqt_framer.h +++ b/quiche/quic/moqt/moqt_framer.h
@@ -64,8 +64,7 @@ const MoqtSubscribeAnnouncesError& message); quiche::QuicheBuffer SerializeUnsubscribeAnnounces( const MoqtUnsubscribeAnnounces& message); - quiche::QuicheBuffer SerializeMaxSubscribeId( - const MoqtMaxSubscribeId& message); + quiche::QuicheBuffer SerializeMaxRequestId(const MoqtMaxRequestId& message); quiche::QuicheBuffer SerializeFetch(const MoqtFetch& message); quiche::QuicheBuffer SerializeFetchCancel(const MoqtFetchCancel& message); quiche::QuicheBuffer SerializeFetchOk(const MoqtFetchOk& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc index 96780f6..80002a2 100644 --- a/quiche/quic/moqt/moqt_framer_test.cc +++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -52,7 +52,7 @@ MoqtMessageType::kSubscribeAnnouncesOk, MoqtMessageType::kSubscribeAnnouncesError, MoqtMessageType::kUnsubscribeAnnounces, - MoqtMessageType::kMaxSubscribeId, + MoqtMessageType::kMaxRequestId, MoqtMessageType::kFetch, MoqtMessageType::kFetchCancel, MoqtMessageType::kFetchOk, @@ -184,9 +184,9 @@ auto data = std::get<MoqtUnsubscribeAnnounces>(structured_data); return framer_.SerializeUnsubscribeAnnounces(data); } - case moqt::MoqtMessageType::kMaxSubscribeId: { - auto data = std::get<MoqtMaxSubscribeId>(structured_data); - return framer_.SerializeMaxSubscribeId(data); + case moqt::MoqtMessageType::kMaxRequestId: { + auto data = std::get<MoqtMaxRequestId>(structured_data); + return framer_.SerializeMaxRequestId(data); } case moqt::MoqtMessageType::kFetch: { auto data = std::get<MoqtFetch>(structured_data);
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc index 967a816..e8aed25 100644 --- a/quiche/quic/moqt/moqt_messages.cc +++ b/quiche/quic/moqt/moqt_messages.cc
@@ -232,8 +232,8 @@ return "SUBSCRIBE_NAMESPACE_ERROR"; case MoqtMessageType::kUnsubscribeAnnounces: return "UNSUBSCRIBE_NAMESPACE"; - case MoqtMessageType::kMaxSubscribeId: - return "MAX_SUBSCRIBE_ID"; + case MoqtMessageType::kMaxRequestId: + return "MAX_REQUEST_ID"; case MoqtMessageType::kFetch: return "FETCH"; case MoqtMessageType::kFetchCancel:
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h index 51b5861..c227832 100644 --- a/quiche/quic/moqt/moqt_messages.h +++ b/quiche/quic/moqt/moqt_messages.h
@@ -58,20 +58,19 @@ using_webtrans(false), path(std::move(path)) {} MoqtSessionParameters(quic::Perspective perspective, std::string path, - uint64_t max_subscribe_id) + uint64_t max_request_id) : perspective(perspective), using_webtrans(true), path(std::move(path)), - max_subscribe_id(max_subscribe_id) {} - MoqtSessionParameters(quic::Perspective perspective, - uint64_t max_subscribe_id) - : perspective(perspective), max_subscribe_id(max_subscribe_id) {} + max_request_id(max_request_id) {} + MoqtSessionParameters(quic::Perspective perspective, uint64_t max_request_id) + : perspective(perspective), max_request_id(max_request_id) {} bool operator==(const MoqtSessionParameters& other) { return version == other.version && deliver_partial_objects == other.deliver_partial_objects && perspective == other.perspective && using_webtrans == other.using_webtrans && path == other.path && - max_subscribe_id == other.max_subscribe_id && + max_request_id == other.max_request_id && max_auth_token_cache_size == other.max_auth_token_cache_size && support_object_acks == other.support_object_acks; } @@ -81,7 +80,7 @@ quic::Perspective perspective = quic::Perspective::IS_SERVER; bool using_webtrans = true; std::string path = ""; - uint64_t max_subscribe_id = kDefaultInitialMaxRequestId; + uint64_t max_request_id = kDefaultInitialMaxRequestId; uint64_t max_auth_token_cache_size = kDefaultMaxAuthTokenCacheSize; bool support_object_acks = false; }; @@ -123,7 +122,7 @@ kSubscribeAnnouncesOk = 0x12, kSubscribeAnnouncesError = 0x13, kUnsubscribeAnnounces = 0x14, - kMaxSubscribeId = 0x15, + kMaxRequestId = 0x15, kFetch = 0x16, kFetchCancel = 0x17, kFetchOk = 0x18, @@ -674,8 +673,8 @@ FullTrackName track_namespace; }; -struct QUICHE_EXPORT MoqtMaxSubscribeId { - uint64_t max_subscribe_id; +struct QUICHE_EXPORT MoqtMaxRequestId { + uint64_t max_request_id; }; enum class QUICHE_EXPORT FetchType : uint64_t {
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc index 8b3ba02..2776499 100644 --- a/quiche/quic/moqt/moqt_parser.cc +++ b/quiche/quic/moqt/moqt_parser.cc
@@ -139,7 +139,7 @@ SetupParameter parameter = static_cast<SetupParameter>(key); switch (parameter) { case SetupParameter::kMaxRequestId: - out.max_subscribe_id = value; + out.max_request_id = value; break; case SetupParameter::kMaxAuthTokenCacheSize: out.max_auth_token_cache_size = value; @@ -304,8 +304,8 @@ case MoqtMessageType::kUnsubscribeAnnounces: bytes_read = ProcessUnsubscribeAnnounces(reader); break; - case MoqtMessageType::kMaxSubscribeId: - bytes_read = ProcessMaxSubscribeId(reader); + case MoqtMessageType::kMaxRequestId: + bytes_read = ProcessMaxRequestId(reader); break; case MoqtMessageType::kFetch: bytes_read = ProcessFetch(reader); @@ -767,12 +767,12 @@ return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessMaxSubscribeId(quic::QuicDataReader& reader) { - MoqtMaxSubscribeId max_subscribe_id; - if (!reader.ReadVarInt62(&max_subscribe_id.max_subscribe_id)) { +size_t MoqtControlParser::ProcessMaxRequestId(quic::QuicDataReader& reader) { + MoqtMaxRequestId max_request_id; + if (!reader.ReadVarInt62(&max_request_id.max_request_id)) { return 0; } - visitor_.OnMaxSubscribeIdMessage(max_subscribe_id); + visitor_.OnMaxRequestIdMessage(max_request_id); return reader.PreviouslyReadPayload().length(); }
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h index 36c8f31..efd90dd 100644 --- a/quiche/quic/moqt/moqt_parser.h +++ b/quiche/quic/moqt/moqt_parser.h
@@ -56,7 +56,7 @@ const MoqtSubscribeAnnouncesError& message) = 0; virtual void OnUnsubscribeAnnouncesMessage( const MoqtUnsubscribeAnnounces& message) = 0; - virtual void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) = 0; + virtual void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) = 0; virtual void OnFetchMessage(const MoqtFetch& message) = 0; virtual void OnFetchCancelMessage(const MoqtFetchCancel& message) = 0; virtual void OnFetchOkMessage(const MoqtFetchOk& message) = 0; @@ -125,7 +125,7 @@ size_t ProcessSubscribeAnnouncesOk(quic::QuicDataReader& reader); size_t ProcessSubscribeAnnouncesError(quic::QuicDataReader& reader); size_t ProcessUnsubscribeAnnounces(quic::QuicDataReader& reader); - size_t ProcessMaxSubscribeId(quic::QuicDataReader& reader); + size_t ProcessMaxRequestId(quic::QuicDataReader& reader); size_t ProcessFetch(quic::QuicDataReader& reader); size_t ProcessFetchCancel(quic::QuicDataReader& reader); size_t ProcessFetchOk(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc index 84f4f60..d5b189c 100644 --- a/quiche/quic/moqt/moqt_parser_test.cc +++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -52,7 +52,7 @@ MoqtMessageType::kSubscribeAnnouncesOk, MoqtMessageType::kSubscribeAnnouncesError, MoqtMessageType::kUnsubscribeAnnounces, - MoqtMessageType::kMaxSubscribeId, + MoqtMessageType::kMaxRequestId, MoqtMessageType::kFetch, MoqtMessageType::kFetchCancel, MoqtMessageType::kFetchOk, @@ -198,7 +198,7 @@ const MoqtUnsubscribeAnnounces& message) override { OnControlMessage(message); } - void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) override { + void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override { OnControlMessage(message); } void OnFetchMessage(const MoqtFetch& message) override { @@ -642,7 +642,7 @@ EXPECT_EQ(visitor_.parsing_error_code_, MoqtError::kInvalidPath); } -TEST_F(MoqtMessageSpecificTest, ServerSetupMaxSubscribeIdAppearsTwice) { +TEST_F(MoqtMessageSpecificTest, ServerSetupMaxRequestIdAppearsTwice) { webtransport::test::InMemoryStream stream(/*stream_id=*/0); MoqtControlParser parser(kRawQuic, &stream, visitor_); char setup[] = {
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc index b04a678..25a133b 100644 --- a/quiche/quic/moqt/moqt_session.cc +++ b/quiche/quic/moqt/moqt_session.cc
@@ -99,7 +99,7 @@ callbacks_(std::move(callbacks)), framer_(quiche::SimpleBufferAllocator::Get(), parameters.using_webtrans), publisher_(DefaultPublisher::GetInstance()), - local_max_request_id_(parameters.max_subscribe_id), + local_max_request_id_(parameters.max_request_id), alarm_factory_(std::move(alarm_factory)), liveness_token_(std::make_shared<Empty>()) { if (parameters_.using_webtrans) { @@ -383,11 +383,11 @@ MoqtPriority priority, std::optional<MoqtDeliveryOrder> delivery_order, VersionSpecificParameters parameters) { - if (next_subscribe_id_ >= peer_max_subscribe_id_) { + if (next_request_id_ >= peer_max_request_id_) { QUIC_DLOG(INFO) << ENDPOINT << "Tried to send FETCH with ID " - << next_subscribe_id_ + << next_request_id_ << " which is greater than the maximum ID " - << peer_max_subscribe_id_; + << peer_max_request_id_; return false; } if (received_goaway_ || sent_goaway_) { @@ -396,7 +396,7 @@ } MoqtFetch message; message.full_track_name = name; - message.fetch_id = next_subscribe_id_++; + message.fetch_id = next_request_id_++; message.start_object = start; message.end_group = end_group; message.end_object = end_object; @@ -417,8 +417,7 @@ VersionSpecificParameters parameters) { return JoiningFetch( name, visitor, - [this, - id = next_subscribe_id_](std::unique_ptr<MoqtFetchTask> fetch_task) { + [this, id = next_request_id_](std::unique_ptr<MoqtFetchTask> fetch_task) { // Move the fetch_task to the subscribe to plumb into its visitor. RemoteTrack* track = RemoteTrackById(id); if (track == nullptr || track->is_fetch()) { @@ -440,11 +439,11 @@ MoqtPriority priority, std::optional<MoqtDeliveryOrder> delivery_order, VersionSpecificParameters parameters) { - if ((next_subscribe_id_ + 1) >= peer_max_subscribe_id_) { + if ((next_request_id_ + 1) >= peer_max_request_id_) { QUIC_DLOG(INFO) << ENDPOINT << "Tried to send JOINING_FETCH with ID " - << (next_subscribe_id_ + 1) + << (next_request_id_ + 1) << " which is greater than the maximum ID " - << peer_max_subscribe_id_; + << peer_max_request_id_; return false; } MoqtSubscribe subscribe; @@ -459,7 +458,7 @@ return false; } MoqtFetch fetch; - fetch.fetch_id = next_subscribe_id_++; + fetch.fetch_id = next_request_id_++; fetch.subscriber_priority = priority; fetch.group_order = delivery_order; fetch.joining_fetch = {subscribe.subscribe_id, num_previous_groups}; @@ -586,19 +585,19 @@ SubscribeRemoteTrack::Visitor* visitor, std::optional<uint64_t> provided_track_alias) { // TODO(martinduke): support authorization info - if (next_subscribe_id_ >= peer_max_subscribe_id_) { + if (next_request_id_ >= peer_max_request_id_) { if (!last_subscribes_blocked_sent_.has_value() || - peer_max_subscribe_id_ > *last_subscribes_blocked_sent_) { + peer_max_request_id_ > *last_subscribes_blocked_sent_) { MoqtSubscribesBlocked subscribes_blocked; - subscribes_blocked.max_subscribe_id = peer_max_subscribe_id_; + subscribes_blocked.max_subscribe_id = peer_max_request_id_; SendControlMessage( framer_.SerializeSubscribesBlocked(subscribes_blocked)); - last_subscribes_blocked_sent_ = peer_max_subscribe_id_; + last_subscribes_blocked_sent_ = peer_max_request_id_; } QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE with ID " - << next_subscribe_id_ + << next_request_id_ << " which is greater than the maximum ID " - << peer_max_subscribe_id_; + << peer_max_request_id_; return false; } if (subscribe_by_name_.contains(message.full_track_name)) { @@ -616,7 +615,7 @@ QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE after GOAWAY"; return false; } - message.subscribe_id = next_subscribe_id_++; + message.subscribe_id = next_request_id_++; if (provided_track_alias.has_value()) { message.track_alias = *provided_track_alias; next_remote_track_alias_ = @@ -777,11 +776,11 @@ } } -void MoqtSession::GrantMoreSubscribes(uint64_t num_subscribes) { - local_max_request_id_ += num_subscribes; - MoqtMaxSubscribeId message; - message.max_subscribe_id = local_max_request_id_; - SendControlMessage(framer_.SerializeMaxSubscribeId(message)); +void MoqtSession::GrantMoreRequests(uint64_t num_requests) { + local_max_request_id_ += num_requests; + MoqtMaxRequestId message; + message.max_request_id = local_max_request_id_; + SendControlMessage(framer_.SerializeMaxRequestId(message)); } bool MoqtSession::ValidateRequestId(uint64_t request_id) { @@ -791,7 +790,7 @@ return false; } if (request_id < next_incoming_request_id_) { - QUIC_DLOG(INFO) << ENDPOINT << "Subscribe ID not monotonically increasing"; + QUIC_DLOG(INFO) << ENDPOINT << "Request ID not monotonically increasing"; Error(MoqtError::kInvalidRequestId, "Request ID not monotonically increasing"); return false; @@ -855,7 +854,7 @@ QUIC_DLOG(INFO) << ENDPOINT << "Sent the SETUP message"; } // TODO: handle path. - session_->peer_max_subscribe_id_ = message.parameters.max_subscribe_id; + session_->peer_max_request_id_ = message.parameters.max_request_id; std::move(session_->callbacks_.session_established_callback)(); } @@ -876,7 +875,7 @@ session_->peer_supports_object_ack_ = message.parameters.support_object_acks; QUIC_DLOG(INFO) << ENDPOINT << "Received the SETUP message"; // TODO: handle path. - session_->peer_max_subscribe_id_ = message.parameters.max_subscribe_id; + session_->peer_max_request_id_ = message.parameters.max_request_id; std::move(session_->callbacks_.session_established_callback)(); } @@ -1237,17 +1236,17 @@ message.track_namespace, std::nullopt); } -void MoqtSession::ControlStream::OnMaxSubscribeIdMessage( - const MoqtMaxSubscribeId& message) { - if (message.max_subscribe_id < session_->peer_max_subscribe_id_) { +void MoqtSession::ControlStream::OnMaxRequestIdMessage( + const MoqtMaxRequestId& message) { + if (message.max_request_id < session_->peer_max_request_id_) { QUIC_DLOG(INFO) << ENDPOINT - << "Peer sent MAX_SUBSCRIBE_ID message with " + << "Peer sent MAX_REQUEST_ID message with " "lower value than previous"; session_->Error(MoqtError::kProtocolViolation, - "MAX_SUBSCRIBE_ID message has lower value than previous"); + "MAX_REQUEST_ID has lower value than previous"); return; } - session_->peer_max_subscribe_id_ = message.max_subscribe_id; + session_->peer_max_request_id_ = message.max_request_id; } void MoqtSession::ControlStream::OnFetchMessage(const MoqtFetch& message) {
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h index 78fabf3..70a7b59 100644 --- a/quiche/quic/moqt/moqt_session.h +++ b/quiche/quic/moqt/moqt_session.h
@@ -192,7 +192,7 @@ std::optional<webtransport::SendOrder> old_send_order, std::optional<webtransport::SendOrder> new_send_order); - void GrantMoreSubscribes(uint64_t num_subscribes); + void GrantMoreRequests(uint64_t num_requests); void UseAlternateDeliveryTimeout() { alternate_delivery_timeout_ = true; } @@ -240,7 +240,7 @@ const MoqtSubscribeAnnouncesError& message) override; void OnUnsubscribeAnnouncesMessage( const MoqtUnsubscribeAnnounces& message) override; - void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) override; + void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override; void OnFetchMessage(const MoqtFetch& message) override; void OnFetchCancelMessage(const MoqtFetchCancel& message) override {} void OnFetchOkMessage(const MoqtFetchOk& message) override; @@ -684,9 +684,9 @@ // The next track alias to guess on a SUBSCRIBE. uint64_t next_remote_track_alias_ = 0; // The next subscribe ID that the local endpoint can send. - uint64_t next_subscribe_id_ = 0; + uint64_t next_request_id_ = 0; // The local endpoint can send subscribe IDs less than this value. - uint64_t peer_max_subscribe_id_ = 0; + uint64_t peer_max_request_id_ = 0; std::optional<uint64_t> last_subscribes_blocked_sent_; // All open incoming subscriptions, indexed by track name, used to check for
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc index af38819..bdfb51c 100644 --- a/quiche/quic/moqt/moqt_session_test.cc +++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -112,8 +112,8 @@ std::make_unique<quic::test::TestAlarmFactory>(), session_callbacks_.AsSessionCallbacks()) { session_.set_publisher(&publisher_); - MoqtSessionPeer::set_peer_max_subscribe_id(&session_, - kDefaultInitialMaxRequestId); + MoqtSessionPeer::set_peer_max_request_id(&session_, + kDefaultInitialMaxRequestId); ON_CALL(mock_session_, GetStreamById).WillByDefault(Return(&mock_stream_)); } ~MoqtSessionTest() { @@ -597,8 +597,8 @@ } TEST_F(MoqtSessionTest, TooManySubscribes) { - MoqtSessionPeer::set_next_subscribe_id(&session_, - kDefaultInitialMaxRequestId - 1); + MoqtSessionPeer::set_next_request_id(&session_, + kDefaultInitialMaxRequestId - 1); MockSubscribeRemoteTrackVisitor remote_track_visitor; std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); @@ -663,9 +663,8 @@ stream_input->OnSubscribeOkMessage(ok); } -TEST_F(MoqtSessionTest, MaxSubscribeIdChangesResponse) { - MoqtSessionPeer::set_next_subscribe_id(&session_, - kDefaultInitialMaxRequestId); +TEST_F(MoqtSessionTest, MaxRequestIdChangesResponse) { + MoqtSessionPeer::set_next_request_id(&session_, kDefaultInitialMaxRequestId); MockSubscribeRemoteTrackVisitor remote_track_visitor; std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); @@ -677,10 +676,10 @@ EXPECT_FALSE(session_.SubscribeCurrentObject(FullTrackName("foo", "bar"), &remote_track_visitor, VersionSpecificParameters())); - MoqtMaxSubscribeId max_subscribe_id = { - /*max_subscribe_id=*/kDefaultInitialMaxRequestId + 1, + MoqtMaxRequestId max_request_id = { + /*max_request_id=*/kDefaultInitialMaxRequestId + 1, }; - stream_input->OnMaxSubscribeIdMessage(max_subscribe_id); + stream_input->OnMaxRequestIdMessage(max_request_id); EXPECT_CALL(mock_stream_, Writev(ControlMessageOfType(MoqtMessageType::kSubscribe), _)); @@ -689,27 +688,25 @@ VersionSpecificParameters())); } -TEST_F(MoqtSessionTest, LowerMaxSubscribeIdIsAnError) { - MoqtMaxSubscribeId max_subscribe_id = { - /*max_subscribe_id=*/kDefaultInitialMaxRequestId - 1, +TEST_F(MoqtSessionTest, LowerMaxRequestIdIsAnError) { + MoqtMaxRequestId max_request_id = { + /*max_request_id=*/kDefaultInitialMaxRequestId - 1, }; std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); - EXPECT_CALL( - mock_session_, - CloseSession(static_cast<uint64_t>(MoqtError::kProtocolViolation), - "MAX_SUBSCRIBE_ID message has lower value than previous")) + EXPECT_CALL(mock_session_, + CloseSession(static_cast<uint64_t>(MoqtError::kProtocolViolation), + "MAX_REQUEST_ID has lower value than previous")) .Times(1); - stream_input->OnMaxSubscribeIdMessage(max_subscribe_id); + stream_input->OnMaxRequestIdMessage(max_request_id); } -TEST_F(MoqtSessionTest, GrantMoreSubscribes) { +TEST_F(MoqtSessionTest, GrantMoreRequests) { std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); - EXPECT_CALL( - mock_stream_, - Writev(ControlMessageOfType(MoqtMessageType::kMaxSubscribeId), _)); - session_.GrantMoreSubscribes(1); + EXPECT_CALL(mock_stream_, + Writev(ControlMessageOfType(MoqtMessageType::kMaxRequestId), _)); + session_.GrantMoreRequests(1); // Peer subscribes to (0, 0) MoqtSubscribe request = DefaultSubscribe(); request.subscribe_id = kDefaultInitialMaxRequestId;
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc index 9f7aadf..534ddf0 100644 --- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc +++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -86,8 +86,8 @@ MoqtMessageType operator()(const MoqtUnsubscribeAnnounces&) { return MoqtMessageType::kUnsubscribeAnnounces; } - MoqtMessageType operator()(const MoqtMaxSubscribeId&) { - return MoqtMessageType::kMaxSubscribeId; + MoqtMessageType operator()(const MoqtMaxRequestId&) { + return MoqtMessageType::kMaxRequestId; } MoqtMessageType operator()(const MoqtFetch&) { return MoqtMessageType::kFetch; @@ -170,8 +170,8 @@ quiche::QuicheBuffer operator()(const MoqtUnsubscribeAnnounces& message) { return framer.SerializeUnsubscribeAnnounces(message); } - quiche::QuicheBuffer operator()(const MoqtMaxSubscribeId& message) { - return framer.SerializeMaxSubscribeId(message); + quiche::QuicheBuffer operator()(const MoqtMaxRequestId& message) { + return framer.SerializeMaxRequestId(message); } quiche::QuicheBuffer operator()(const MoqtFetch& message) { return framer.SerializeFetch(message); @@ -261,7 +261,7 @@ void OnUnsubscribeAnnouncesMessage(const MoqtUnsubscribeAnnounces& message) { frames_.push_back(message); } - void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) { + void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) { frames_.push_back(message); } void OnFetchMessage(const MoqtFetch& message) { frames_.push_back(message); }
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h index ac5760b..7b39419 100644 --- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h +++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -32,7 +32,7 @@ MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus, MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk, MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces, - MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, + MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>; MoqtMessageType MessageTypeForGenericMessage(const MoqtGenericFrame& frame);
diff --git a/quiche/quic/moqt/test_tools/moqt_session_peer.h b/quiche/quic/moqt/test_tools/moqt_session_peer.h index d654aff..9fa1bf3 100644 --- a/quiche/quic/moqt/test_tools/moqt_session_peer.h +++ b/quiche/quic/moqt/test_tools/moqt_session_peer.h
@@ -143,12 +143,12 @@ return session->RemoteTrackByAlias(track_alias); } - static void set_next_subscribe_id(MoqtSession* session, uint64_t id) { - session->next_subscribe_id_ = id; + static void set_next_request_id(MoqtSession* session, uint64_t id) { + session->next_request_id_ = id; } - static void set_peer_max_subscribe_id(MoqtSession* session, uint64_t id) { - session->peer_max_subscribe_id_ = id; + static void set_peer_max_request_id(MoqtSession* session, uint64_t id) { + session->peer_max_request_id_ = id; } static MoqtSession::PublishedFetch* GetFetch(MoqtSession* session,
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h index 8478fcd..3b14ad5 100644 --- a/quiche/quic/moqt/test_tools/moqt_test_message.h +++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -46,7 +46,7 @@ MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus, MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk, MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces, - MoqtMaxSubscribeId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, + MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, MoqtFetchError, MoqtSubscribesBlocked, MoqtObjectAck>; // The total actual size of the message. @@ -1256,16 +1256,16 @@ }; }; -class QUICHE_NO_EXPORT MaxSubscribeIdMessage : public TestMessageBase { +class QUICHE_NO_EXPORT MaxRequestIdMessage : public TestMessageBase { public: - MaxSubscribeIdMessage() : TestMessageBase() { + MaxRequestIdMessage() : TestMessageBase() { SetWireImage(raw_packet_, sizeof(raw_packet_)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtMaxSubscribeId>(values); - if (cast.max_subscribe_id != max_subscribe_id_.max_subscribe_id) { - QUIC_LOG(INFO) << "MAX_SUBSCRIBE_ID mismatch"; + auto cast = std::get<MoqtMaxRequestId>(values); + if (cast.max_request_id != max_request_id_.max_request_id) { + QUIC_LOG(INFO) << "MAX_REQUEST_ID mismatch"; return false; } return true; @@ -1274,7 +1274,7 @@ void ExpandVarints() override { ExpandVarintsImpl("vvv"); } MessageStructuredData structured_data() const override { - return TestMessageBase::MessageStructuredData(max_subscribe_id_); + return TestMessageBase::MessageStructuredData(max_request_id_); } private: @@ -1284,8 +1284,8 @@ 0x0b, }; - MoqtMaxSubscribeId max_subscribe_id_ = { - /*max_subscribe_id =*/11, + MoqtMaxRequestId max_request_id_ = { + /*max_request_id =*/11, }; }; @@ -1741,8 +1741,8 @@ return std::make_unique<SubscribeAnnouncesErrorMessage>(); case MoqtMessageType::kUnsubscribeAnnounces: return std::make_unique<UnsubscribeAnnouncesMessage>(); - case MoqtMessageType::kMaxSubscribeId: - return std::make_unique<MaxSubscribeIdMessage>(); + case MoqtMessageType::kMaxRequestId: + return std::make_unique<MaxRequestIdMessage>(); case MoqtMessageType::kFetch: return std::make_unique<FetchMessage>(); case MoqtMessageType::kFetchCancel: