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:
