Rename ANNOUNCE* to PUBLISH_NAMESPACE* (draft-14)
PiperOrigin-RevId: 805409434
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index 2858390..4717cf2 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -531,46 +531,46 @@
WireBoolean(message.forward), WireKeyValuePairList(parameters));
}
-quiche::QuicheBuffer MoqtFramer::SerializeAnnounce(
- const MoqtAnnounce& message) {
+quiche::QuicheBuffer MoqtFramer::SerializePublishNamespace(
+ const MoqtPublishNamespace& message) {
KeyValuePairList parameters;
VersionSpecificParametersToKeyValuePairList(message.parameters, parameters);
if (!ValidateVersionSpecificParameters(parameters,
- MoqtMessageType::kAnnounce)) {
+ MoqtMessageType::kPublishNamespace)) {
QUICHE_BUG(QUICHE_BUG_invalid_parameters)
<< "Serializing invalid MoQT parameters";
return quiche::QuicheBuffer();
}
- return SerializeControlMessage(MoqtMessageType::kAnnounce,
+ return SerializeControlMessage(MoqtMessageType::kPublishNamespace,
WireVarInt62(message.request_id),
WireTrackNamespace(message.track_namespace),
WireKeyValuePairList(parameters));
}
-quiche::QuicheBuffer MoqtFramer::SerializeAnnounceOk(
- const MoqtAnnounceOk& message) {
- return SerializeControlMessage(MoqtMessageType::kAnnounceOk,
+quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceOk(
+ const MoqtPublishNamespaceOk& message) {
+ return SerializeControlMessage(MoqtMessageType::kPublishNamespaceOk,
WireVarInt62(message.request_id));
}
-quiche::QuicheBuffer MoqtFramer::SerializeAnnounceError(
- const MoqtAnnounceError& message) {
+quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceError(
+ const MoqtPublishNamespaceError& message) {
return SerializeControlMessage(
- MoqtMessageType::kAnnounceError, WireVarInt62(message.request_id),
+ MoqtMessageType::kPublishNamespaceError, WireVarInt62(message.request_id),
WireVarInt62(message.error_code),
WireStringWithVarInt62Length(message.error_reason));
}
-quiche::QuicheBuffer MoqtFramer::SerializeUnannounce(
- const MoqtUnannounce& message) {
- return SerializeControlMessage(MoqtMessageType::kUnannounce,
+quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceDone(
+ const MoqtPublishNamespaceDone& message) {
+ return SerializeControlMessage(MoqtMessageType::kPublishNamespaceDone,
WireTrackNamespace(message.track_namespace));
}
-quiche::QuicheBuffer MoqtFramer::SerializeAnnounceCancel(
- const MoqtAnnounceCancel& message) {
+quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceCancel(
+ const MoqtPublishNamespaceCancel& message) {
return SerializeControlMessage(
- MoqtMessageType::kAnnounceCancel,
+ MoqtMessageType::kPublishNamespaceCancel,
WireTrackNamespace(message.track_namespace),
WireVarInt62(message.error_code),
WireStringWithVarInt62Length(message.error_reason));
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h
index 0168758..e5a4a52 100644
--- a/quiche/quic/moqt/moqt_framer.h
+++ b/quiche/quic/moqt/moqt_framer.h
@@ -56,12 +56,16 @@
quiche::QuicheBuffer SerializePublishDone(const MoqtPublishDone& message);
quiche::QuicheBuffer SerializeSubscribeUpdate(
const MoqtSubscribeUpdate& message);
- quiche::QuicheBuffer SerializeAnnounce(const MoqtAnnounce& message);
- quiche::QuicheBuffer SerializeAnnounceOk(const MoqtAnnounceOk& message);
- quiche::QuicheBuffer SerializeAnnounceError(const MoqtAnnounceError& message);
- quiche::QuicheBuffer SerializeUnannounce(const MoqtUnannounce& message);
- quiche::QuicheBuffer SerializeAnnounceCancel(
- const MoqtAnnounceCancel& message);
+ quiche::QuicheBuffer SerializePublishNamespace(
+ const MoqtPublishNamespace& message);
+ quiche::QuicheBuffer SerializePublishNamespaceOk(
+ const MoqtPublishNamespaceOk& message);
+ quiche::QuicheBuffer SerializePublishNamespaceError(
+ const MoqtPublishNamespaceError& message);
+ quiche::QuicheBuffer SerializePublishNamespaceDone(
+ const MoqtPublishNamespaceDone& message);
+ quiche::QuicheBuffer SerializePublishNamespaceCancel(
+ const MoqtPublishNamespaceCancel& message);
quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message);
quiche::QuicheBuffer SerializeTrackStatusOk(const MoqtTrackStatusOk& message);
quiche::QuicheBuffer SerializeTrackStatusError(
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index a63dfb3..47c2fe2 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -39,11 +39,11 @@
MoqtMessageType::kSubscribeError,
MoqtMessageType::kUnsubscribe,
MoqtMessageType::kPublishDone,
- MoqtMessageType::kAnnounce,
- MoqtMessageType::kAnnounceOk,
- MoqtMessageType::kAnnounceError,
- MoqtMessageType::kUnannounce,
- MoqtMessageType::kAnnounceCancel,
+ MoqtMessageType::kPublishNamespace,
+ MoqtMessageType::kPublishNamespaceOk,
+ MoqtMessageType::kPublishNamespaceError,
+ MoqtMessageType::kPublishNamespaceDone,
+ MoqtMessageType::kPublishNamespaceCancel,
MoqtMessageType::kTrackStatus,
MoqtMessageType::kTrackStatusOk,
MoqtMessageType::kTrackStatusError,
@@ -144,25 +144,25 @@
auto data = std::get<MoqtPublishDone>(structured_data);
return framer_.SerializePublishDone(data);
}
- case MoqtMessageType::kAnnounce: {
- auto data = std::get<MoqtAnnounce>(structured_data);
- return framer_.SerializeAnnounce(data);
+ case MoqtMessageType::kPublishNamespace: {
+ auto data = std::get<MoqtPublishNamespace>(structured_data);
+ return framer_.SerializePublishNamespace(data);
}
- case moqt::MoqtMessageType::kAnnounceOk: {
- auto data = std::get<MoqtAnnounceOk>(structured_data);
- return framer_.SerializeAnnounceOk(data);
+ case moqt::MoqtMessageType::kPublishNamespaceOk: {
+ auto data = std::get<MoqtPublishNamespaceOk>(structured_data);
+ return framer_.SerializePublishNamespaceOk(data);
}
- case moqt::MoqtMessageType::kAnnounceError: {
- auto data = std::get<MoqtAnnounceError>(structured_data);
- return framer_.SerializeAnnounceError(data);
+ case moqt::MoqtMessageType::kPublishNamespaceError: {
+ auto data = std::get<MoqtPublishNamespaceError>(structured_data);
+ return framer_.SerializePublishNamespaceError(data);
}
- case MoqtMessageType::kUnannounce: {
- auto data = std::get<MoqtUnannounce>(structured_data);
- return framer_.SerializeUnannounce(data);
+ case MoqtMessageType::kPublishNamespaceDone: {
+ auto data = std::get<MoqtPublishNamespaceDone>(structured_data);
+ return framer_.SerializePublishNamespaceDone(data);
}
- case moqt::MoqtMessageType::kAnnounceCancel: {
- auto data = std::get<MoqtAnnounceCancel>(structured_data);
- return framer_.SerializeAnnounceCancel(data);
+ case moqt::MoqtMessageType::kPublishNamespaceCancel: {
+ auto data = std::get<MoqtPublishNamespaceCancel>(structured_data);
+ return framer_.SerializePublishNamespaceCancel(data);
}
case moqt::MoqtMessageType::kTrackStatus: {
auto data = std::get<MoqtTrackStatus>(structured_data);
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc
index 6eeb973..5c232f9 100644
--- a/quiche/quic/moqt/moqt_integration_test.cc
+++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -144,23 +144,24 @@
EXPECT_TRUE(success);
}
-TEST_F(MoqtIntegrationTest, AnnounceSuccessThenUnannounce) {
+TEST_F(MoqtIntegrationTest, PublishNamespaceSuccessThenPublishNamespaceDone) {
EstablishSession();
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- EXPECT_CALL(server_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(server_callbacks_.incoming_publish_namespace_callback,
Call(TrackNamespace{"foo"}, parameters))
.WillOnce(Return(std::nullopt));
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_callback;
- client_->session()->Announce(TrackNamespace{"foo"},
- announce_callback.AsStdFunction(), *parameters);
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_callback;
+ client_->session()->PublishNamespace(
+ TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
+ *parameters);
bool matches = false;
- EXPECT_CALL(announce_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
matches = true;
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
EXPECT_FALSE(error.has_value());
@@ -169,7 +170,7 @@
test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
EXPECT_TRUE(success);
matches = false;
- EXPECT_CALL(server_callbacks_.incoming_announce_callback, Call(_, _))
+ EXPECT_CALL(server_callbacks_.incoming_publish_namespace_callback, Call(_, _))
.WillOnce([&](TrackNamespace name,
std::optional<VersionSpecificParameters> parameters) {
matches = true;
@@ -177,28 +178,29 @@
EXPECT_FALSE(parameters.has_value());
return std::nullopt;
});
- client_->session()->Unannounce(TrackNamespace{"foo"});
+ client_->session()->PublishNamespaceDone(TrackNamespace{"foo"});
success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
EXPECT_TRUE(success);
}
-TEST_F(MoqtIntegrationTest, AnnounceSuccessThenCancel) {
+TEST_F(MoqtIntegrationTest, PublishNamespaceSuccessThenCancel) {
EstablishSession();
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- EXPECT_CALL(server_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(server_callbacks_.incoming_publish_namespace_callback,
Call(TrackNamespace{"foo"}, parameters))
.WillOnce(Return(std::nullopt));
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_callback;
- client_->session()->Announce(TrackNamespace{"foo"},
- announce_callback.AsStdFunction(), *parameters);
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_callback;
+ client_->session()->PublishNamespace(
+ TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
+ *parameters);
bool matches = false;
- EXPECT_CALL(announce_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
matches = true;
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
EXPECT_FALSE(error.has_value());
@@ -207,40 +209,41 @@
test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
EXPECT_TRUE(success);
matches = false;
- EXPECT_CALL(announce_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
matches = true;
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
ASSERT_TRUE(error.has_value());
EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
EXPECT_EQ(error->reason_phrase, "internal error");
});
- server_->session()->CancelAnnounce(TrackNamespace{"foo"},
- RequestErrorCode::kInternalError,
- "internal error");
+ server_->session()->CancelPublishNamespace(TrackNamespace{"foo"},
+ RequestErrorCode::kInternalError,
+ "internal error");
success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
EXPECT_TRUE(success);
}
-TEST_F(MoqtIntegrationTest, AnnounceSuccessSubscribeInResponse) {
+TEST_F(MoqtIntegrationTest, PublishNamespaceSuccessSubscribeInResponse) {
EstablishSession();
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- EXPECT_CALL(server_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(server_callbacks_.incoming_publish_namespace_callback,
Call(TrackNamespace{"foo"}, parameters))
.WillOnce(Return(std::nullopt));
MockSubscribeRemoteTrackVisitor server_visitor;
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_callback;
- client_->session()->Announce(TrackNamespace{"foo"},
- announce_callback.AsStdFunction(), *parameters);
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_callback;
+ client_->session()->PublishNamespace(
+ TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
+ *parameters);
bool matches = false;
- EXPECT_CALL(announce_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
FullTrackName track_name(track_namespace, "/catalog");
EXPECT_FALSE(error.has_value());
@@ -255,22 +258,23 @@
EXPECT_TRUE(success);
}
-TEST_F(MoqtIntegrationTest, AnnounceSuccessSendDataInResponse) {
+TEST_F(MoqtIntegrationTest, PublishNamespaceSuccessSendDataInResponse) {
EstablishSession();
- // Set up the server to subscribe to "data" track for the namespace announce
- // it receives.
+ // Set up the server to subscribe to "data" track for the namespace
+ // publish_namespace it receives.
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
MockSubscribeRemoteTrackVisitor server_visitor;
- EXPECT_CALL(server_callbacks_.incoming_announce_callback, Call(_, parameters))
+ EXPECT_CALL(server_callbacks_.incoming_publish_namespace_callback,
+ Call(_, parameters))
.WillOnce([&](const TrackNamespace& track_namespace,
std::optional<VersionSpecificParameters> /*parameters*/) {
FullTrackName track_name(track_namespace, "data");
server_->session()->SubscribeAbsolute(
track_name, /*start_group=*/0, /*start_object=*/0, &server_visitor,
VersionSpecificParameters());
- return std::optional<MoqtAnnounceErrorReason>();
+ return std::optional<MoqtPublishNamespaceErrorReason>();
});
auto queue = std::make_shared<MoqtOutgoingQueue>(
@@ -282,9 +286,9 @@
EXPECT_CALL(server_visitor, OnReply(_, _, _)).WillOnce([&]() {
received_subscribe_ok = true;
});
- client_->session()->Announce(
+ client_->session()->PublishNamespace(
TrackNamespace{"test"},
- [](TrackNamespace, std::optional<MoqtAnnounceErrorReason>) {},
+ [](TrackNamespace, std::optional<MoqtPublishNamespaceErrorReason>) {},
*parameters);
bool success = test_harness_.RunUntilWithDefaultTimeout(
[&]() { return received_subscribe_ok; });
@@ -474,19 +478,19 @@
EXPECT_EQ(expected, Location(99, 1));
}
-TEST_F(MoqtIntegrationTest, AnnounceFailure) {
+TEST_F(MoqtIntegrationTest, PublishNamespaceFailure) {
EstablishSession();
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_callback;
- client_->session()->Announce(TrackNamespace{"foo"},
- announce_callback.AsStdFunction(),
- VersionSpecificParameters());
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_callback;
+ client_->session()->PublishNamespace(
+ TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(),
+ VersionSpecificParameters());
bool matches = false;
- EXPECT_CALL(announce_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
matches = true;
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
ASSERT_TRUE(error.has_value());
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
index c1f5dce..af3cba9 100644
--- a/quiche/quic/moqt/moqt_messages.cc
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -185,7 +185,7 @@
MoqtMessageType::kSubscribe,
MoqtMessageType::kSubscribeUpdate,
MoqtMessageType::kSubscribeNamespace,
- MoqtMessageType::kAnnounce,
+ MoqtMessageType::kPublishNamespace,
MoqtMessageType::kTrackStatus,
MoqtMessageType::kFetch};
const std::array<MoqtMessageType, 7> kAllowsDeliveryTimeout = {
@@ -241,22 +241,22 @@
return "SUBSCRIBE_DONE";
case MoqtMessageType::kSubscribeUpdate:
return "SUBSCRIBE_UPDATE";
- case MoqtMessageType::kAnnounceCancel:
- return "ANNOUNCE_CANCEL";
+ case MoqtMessageType::kPublishNamespaceCancel:
+ return "PUBLISH_NAMESPACE_CANCEL";
case MoqtMessageType::kTrackStatus:
return "TRACK_STATUS";
case MoqtMessageType::kTrackStatusOk:
return "TRACK_STATUS_OK";
case MoqtMessageType::kTrackStatusError:
return "TRACK_STATUS_ERROR";
- case MoqtMessageType::kAnnounce:
- return "ANNOUNCE";
- case MoqtMessageType::kAnnounceOk:
- return "ANNOUNCE_OK";
- case MoqtMessageType::kAnnounceError:
- return "ANNOUNCE_ERROR";
- case MoqtMessageType::kUnannounce:
- return "UNANNOUNCE";
+ case MoqtMessageType::kPublishNamespace:
+ return "PUBLISH_NAMESPACE";
+ case MoqtMessageType::kPublishNamespaceOk:
+ return "PUBLISH_NAMESPACE_OK";
+ case MoqtMessageType::kPublishNamespaceError:
+ return "PUBLISH_NAMESPACE_ERROR";
+ case MoqtMessageType::kPublishNamespaceDone:
+ return "PUBLISH_NAMESPACE_DONE";
case MoqtMessageType::kGoAway:
return "GOAWAY";
case MoqtMessageType::kSubscribeNamespace:
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index e208d06..2ab3320 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -254,13 +254,13 @@
kSubscribe = 0x03,
kSubscribeOk = 0x04,
kSubscribeError = 0x05,
- kAnnounce = 0x06,
- kAnnounceOk = 0x7,
- kAnnounceError = 0x08,
- kUnannounce = 0x09,
+ kPublishNamespace = 0x06,
+ kPublishNamespaceOk = 0x7,
+ kPublishNamespaceError = 0x08,
+ kPublishNamespaceDone = 0x09,
kUnsubscribe = 0x0a,
kPublishDone = 0x0b,
- kAnnounceCancel = 0x0c,
+ kPublishNamespaceCancel = 0x0c,
kTrackStatus = 0x0d,
kTrackStatusOk = 0x0e,
kTrackStatusError = 0x0f,
@@ -368,15 +368,16 @@
bool operator==(const VersionSpecificParameters& other) const = default;
};
-// Used for SUBSCRIBE_ERROR, ANNOUNCE_ERROR, ANNOUNCE_CANCEL,
+// Used for SUBSCRIBE_ERROR, PUBLISH_NAMESPACE_ERROR, PUBLISH_NAMESPACE_CANCEL,
// SUBSCRIBE_NAMESPACE_ERROR, and FETCH_ERROR.
enum class QUICHE_EXPORT RequestErrorCode : uint64_t {
kInternalError = 0x0,
kUnauthorized = 0x1,
kTimeout = 0x2,
kNotSupported = 0x3,
- kTrackDoesNotExist = 0x4, // SUBSCRIBE_ERROR and FETCH_ERROR only.
- kUninterested = 0x4, // ANNOUNCE_ERROR and ANNOUNCE_CANCEL only.
+ kTrackDoesNotExist = 0x4, // SUBSCRIBE_ERROR and FETCH_ERROR only.
+ kUninterested =
+ 0x4, // PUBLISH_NAMESPACE_ERROR and PUBLISH_NAMESPACE_CANCEL only.
kNamespacePrefixUnknown = 0x4, // SUBSCRIBE_NAMESPACE_ERROR only.
kInvalidRange = 0x5, // SUBSCRIBE_ERROR and FETCH_ERROR only.
kNamespacePrefixOverlap = 0x5, // SUBSCRIBE_NAMESPACE_ERROR only.
@@ -394,7 +395,7 @@
};
// TODO(martinduke): These are deprecated. Replace them in the code.
using MoqtSubscribeErrorReason = MoqtRequestError;
-using MoqtAnnounceErrorReason = MoqtSubscribeErrorReason;
+using MoqtPublishNamespaceErrorReason = MoqtSubscribeErrorReason;
class TrackNamespace {
public:
@@ -730,27 +731,27 @@
VersionSpecificParameters parameters;
};
-struct QUICHE_EXPORT MoqtAnnounce {
+struct QUICHE_EXPORT MoqtPublishNamespace {
uint64_t request_id;
TrackNamespace track_namespace;
VersionSpecificParameters parameters;
};
-struct QUICHE_EXPORT MoqtAnnounceOk {
+struct QUICHE_EXPORT MoqtPublishNamespaceOk {
uint64_t request_id;
};
-struct QUICHE_EXPORT MoqtAnnounceError {
+struct QUICHE_EXPORT MoqtPublishNamespaceError {
uint64_t request_id;
RequestErrorCode error_code;
std::string error_reason;
};
-struct QUICHE_EXPORT MoqtUnannounce {
+struct QUICHE_EXPORT MoqtPublishNamespaceDone {
TrackNamespace track_namespace;
};
-struct QUICHE_EXPORT MoqtAnnounceCancel {
+struct QUICHE_EXPORT MoqtPublishNamespaceCancel {
TrackNamespace track_namespace;
RequestErrorCode error_code;
std::string error_reason;
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index afe7e5e..f40dfd2 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -238,20 +238,20 @@
case MoqtMessageType::kSubscribeUpdate:
bytes_read = ProcessSubscribeUpdate(reader);
break;
- case MoqtMessageType::kAnnounce:
- bytes_read = ProcessAnnounce(reader);
+ case MoqtMessageType::kPublishNamespace:
+ bytes_read = ProcessPublishNamespace(reader);
break;
- case MoqtMessageType::kAnnounceOk:
- bytes_read = ProcessAnnounceOk(reader);
+ case MoqtMessageType::kPublishNamespaceOk:
+ bytes_read = ProcessPublishNamespaceOk(reader);
break;
- case MoqtMessageType::kAnnounceError:
- bytes_read = ProcessAnnounceError(reader);
+ case MoqtMessageType::kPublishNamespaceError:
+ bytes_read = ProcessPublishNamespaceError(reader);
break;
- case MoqtMessageType::kUnannounce:
- bytes_read = ProcessUnannounce(reader);
+ case MoqtMessageType::kPublishNamespaceDone:
+ bytes_read = ProcessPublishNamespaceDone(reader);
break;
- case MoqtMessageType::kAnnounceCancel:
- bytes_read = ProcessAnnounceCancel(reader);
+ case MoqtMessageType::kPublishNamespaceCancel:
+ bytes_read = ProcessPublishNamespaceCancel(reader);
break;
case MoqtMessageType::kTrackStatus:
bytes_read = ProcessTrackStatus(reader);
@@ -581,10 +581,11 @@
return reader.PreviouslyReadPayload().length();
}
-size_t MoqtControlParser::ProcessAnnounce(quic::QuicDataReader& reader) {
- MoqtAnnounce announce;
- if (!reader.ReadVarInt62(&announce.request_id) ||
- !ReadTrackNamespace(reader, announce.track_namespace)) {
+size_t MoqtControlParser::ProcessPublishNamespace(
+ quic::QuicDataReader& reader) {
+ MoqtPublishNamespace publish_namespace;
+ if (!reader.ReadVarInt62(&publish_namespace.request_id) ||
+ !ReadTrackNamespace(reader, publish_namespace.track_namespace)) {
return 0;
}
KeyValuePairList parameters;
@@ -592,61 +593,67 @@
return 0;
}
if (!ValidateVersionSpecificParameters(parameters,
- MoqtMessageType::kAnnounce)) {
- ParseError("ANNOUNCE contains invalid parameters");
+ MoqtMessageType::kPublishNamespace)) {
+ ParseError("PUBLISH_NAMESPACE contains invalid parameters");
return 0;
}
- if (!KeyValuePairListToVersionSpecificParameters(parameters,
- announce.parameters)) {
+ if (!KeyValuePairListToVersionSpecificParameters(
+ parameters, publish_namespace.parameters)) {
return 0;
}
- visitor_.OnAnnounceMessage(announce);
+ visitor_.OnPublishNamespaceMessage(publish_namespace);
return reader.PreviouslyReadPayload().length();
}
-size_t MoqtControlParser::ProcessAnnounceOk(quic::QuicDataReader& reader) {
- MoqtAnnounceOk announce_ok;
- if (!reader.ReadVarInt62(&announce_ok.request_id)) {
+size_t MoqtControlParser::ProcessPublishNamespaceOk(
+ quic::QuicDataReader& reader) {
+ MoqtPublishNamespaceOk publish_namespace_ok;
+ if (!reader.ReadVarInt62(&publish_namespace_ok.request_id)) {
return 0;
}
- visitor_.OnAnnounceOkMessage(announce_ok);
+ visitor_.OnPublishNamespaceOkMessage(publish_namespace_ok);
return reader.PreviouslyReadPayload().length();
}
-size_t MoqtControlParser::ProcessAnnounceError(quic::QuicDataReader& reader) {
- MoqtAnnounceError announce_error;
+size_t MoqtControlParser::ProcessPublishNamespaceError(
+ quic::QuicDataReader& reader) {
+ MoqtPublishNamespaceError publish_namespace_error;
uint64_t error_code;
- if (!reader.ReadVarInt62(&announce_error.request_id) ||
+ if (!reader.ReadVarInt62(&publish_namespace_error.request_id) ||
!reader.ReadVarInt62(&error_code) ||
- !reader.ReadStringVarInt62(announce_error.error_reason)) {
+ !reader.ReadStringVarInt62(publish_namespace_error.error_reason)) {
return 0;
}
- announce_error.error_code = static_cast<RequestErrorCode>(error_code);
- visitor_.OnAnnounceErrorMessage(announce_error);
+ publish_namespace_error.error_code =
+ static_cast<RequestErrorCode>(error_code);
+ visitor_.OnPublishNamespaceErrorMessage(publish_namespace_error);
return reader.PreviouslyReadPayload().length();
}
-size_t MoqtControlParser::ProcessUnannounce(quic::QuicDataReader& reader) {
- MoqtUnannounce unannounce;
- if (!ReadTrackNamespace(reader, unannounce.track_namespace)) {
+size_t MoqtControlParser::ProcessPublishNamespaceDone(
+ quic::QuicDataReader& reader) {
+ MoqtPublishNamespaceDone unpublish_namespace;
+ if (!ReadTrackNamespace(reader, unpublish_namespace.track_namespace)) {
return 0;
}
- visitor_.OnUnannounceMessage(unannounce);
+ visitor_.OnPublishNamespaceDoneMessage(unpublish_namespace);
return reader.PreviouslyReadPayload().length();
}
-size_t MoqtControlParser::ProcessAnnounceCancel(quic::QuicDataReader& reader) {
- MoqtAnnounceCancel announce_cancel;
- if (!ReadTrackNamespace(reader, announce_cancel.track_namespace)) {
+size_t MoqtControlParser::ProcessPublishNamespaceCancel(
+ quic::QuicDataReader& reader) {
+ MoqtPublishNamespaceCancel publish_namespace_cancel;
+ if (!ReadTrackNamespace(reader, publish_namespace_cancel.track_namespace)) {
return 0;
}
uint64_t error_code;
if (!reader.ReadVarInt62(&error_code) ||
- !reader.ReadStringVarInt62(announce_cancel.error_reason)) {
+ !reader.ReadStringVarInt62(publish_namespace_cancel.error_reason)) {
return 0;
}
- announce_cancel.error_code = static_cast<RequestErrorCode>(error_code);
- visitor_.OnAnnounceCancelMessage(announce_cancel);
+ publish_namespace_cancel.error_code =
+ static_cast<RequestErrorCode>(error_code);
+ visitor_.OnPublishNamespaceCancelMessage(publish_namespace_cancel);
return reader.PreviouslyReadPayload().length();
}
@@ -674,9 +681,9 @@
size_t MoqtControlParser::ProcessSubscribeNamespace(
quic::QuicDataReader& reader) {
- MoqtSubscribeNamespace subscribe_announces;
- if (!reader.ReadVarInt62(&subscribe_announces.request_id) ||
- !ReadTrackNamespace(reader, subscribe_announces.track_namespace)) {
+ MoqtSubscribeNamespace subscribe_namespace;
+ if (!reader.ReadVarInt62(&subscribe_namespace.request_id) ||
+ !ReadTrackNamespace(reader, subscribe_namespace.track_namespace)) {
return 0;
}
KeyValuePairList parameters;
@@ -689,10 +696,10 @@
return 0;
}
if (!KeyValuePairListToVersionSpecificParameters(
- parameters, subscribe_announces.parameters)) {
+ parameters, subscribe_namespace.parameters)) {
return 0;
}
- visitor_.OnSubscribeNamespaceMessage(subscribe_announces);
+ visitor_.OnSubscribeNamespaceMessage(subscribe_namespace);
return reader.PreviouslyReadPayload().length();
}
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index e10beb9..8ee32cb 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -41,11 +41,16 @@
virtual void OnUnsubscribeMessage(const MoqtUnsubscribe& message) = 0;
virtual void OnPublishDoneMessage(const MoqtPublishDone& message) = 0;
virtual void OnSubscribeUpdateMessage(const MoqtSubscribeUpdate& message) = 0;
- virtual void OnAnnounceMessage(const MoqtAnnounce& message) = 0;
- virtual void OnAnnounceOkMessage(const MoqtAnnounceOk& message) = 0;
- virtual void OnAnnounceErrorMessage(const MoqtAnnounceError& message) = 0;
- virtual void OnUnannounceMessage(const MoqtUnannounce& message) = 0;
- virtual void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) = 0;
+ virtual void OnPublishNamespaceMessage(
+ const MoqtPublishNamespace& message) = 0;
+ virtual void OnPublishNamespaceOkMessage(
+ const MoqtPublishNamespaceOk& message) = 0;
+ virtual void OnPublishNamespaceErrorMessage(
+ const MoqtPublishNamespaceError& message) = 0;
+ virtual void OnPublishNamespaceDoneMessage(
+ const MoqtPublishNamespaceDone& message) = 0;
+ virtual void OnPublishNamespaceCancelMessage(
+ const MoqtPublishNamespaceCancel& message) = 0;
virtual void OnTrackStatusMessage(const MoqtTrackStatus& message) = 0;
virtual void OnTrackStatusOkMessage(const MoqtTrackStatusOk& message) = 0;
virtual void OnTrackStatusErrorMessage(
@@ -128,11 +133,11 @@
size_t ProcessUnsubscribe(quic::QuicDataReader& reader);
size_t ProcessPublishDone(quic::QuicDataReader& reader);
size_t ProcessSubscribeUpdate(quic::QuicDataReader& reader);
- size_t ProcessAnnounce(quic::QuicDataReader& reader);
- size_t ProcessAnnounceOk(quic::QuicDataReader& reader);
- size_t ProcessAnnounceError(quic::QuicDataReader& reader);
- size_t ProcessUnannounce(quic::QuicDataReader& reader);
- size_t ProcessAnnounceCancel(quic::QuicDataReader& reader);
+ size_t ProcessPublishNamespace(quic::QuicDataReader& reader);
+ size_t ProcessPublishNamespaceOk(quic::QuicDataReader& reader);
+ size_t ProcessPublishNamespaceError(quic::QuicDataReader& reader);
+ size_t ProcessPublishNamespaceDone(quic::QuicDataReader& reader);
+ size_t ProcessPublishNamespaceCancel(quic::QuicDataReader& reader);
size_t ProcessTrackStatus(quic::QuicDataReader& reader);
size_t ProcessTrackStatusOk(quic::QuicDataReader& reader);
size_t ProcessTrackStatusError(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index eaee5c4..9b70469 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -38,14 +38,14 @@
MoqtMessageType::kSubscribeUpdate,
MoqtMessageType::kUnsubscribe,
MoqtMessageType::kPublishDone,
- MoqtMessageType::kAnnounceCancel,
MoqtMessageType::kTrackStatus,
MoqtMessageType::kTrackStatusOk,
MoqtMessageType::kTrackStatusError,
- MoqtMessageType::kAnnounce,
- MoqtMessageType::kAnnounceOk,
- MoqtMessageType::kAnnounceError,
- MoqtMessageType::kUnannounce,
+ MoqtMessageType::kPublishNamespace,
+ MoqtMessageType::kPublishNamespaceOk,
+ MoqtMessageType::kPublishNamespaceError,
+ MoqtMessageType::kPublishNamespaceDone,
+ MoqtMessageType::kPublishNamespaceCancel,
MoqtMessageType::kClientSetup,
MoqtMessageType::kServerSetup,
MoqtMessageType::kGoAway,
@@ -955,35 +955,38 @@
EXPECT_EQ(visitor_.parsing_error_code_, MoqtError::kProtocolViolation);
}
-TEST_F(MoqtMessageSpecificTest, AnnounceAuthorizationTokenTwice) {
+TEST_F(MoqtMessageSpecificTest, PublishNamespaceAuthorizationTokenTwice) {
webtransport::test::InMemoryStream stream(/*stream_id=*/0);
MoqtControlParser parser(kWebTrans, &stream, visitor_);
- char announce[] = {
+ char publish_namespace[] = {
0x06, 0x00, 0x15, 0x02, 0x01, 0x03, 0x66,
0x6f, 0x6f, // track_namespace = "foo"
0x02, // 2 params
0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72, // authorization = "bar"
0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72, // authorization = "bar"
};
- stream.Receive(absl::string_view(announce, sizeof(announce)), false);
+ stream.Receive(
+ absl::string_view(publish_namespace, sizeof(publish_namespace)), false);
parser.ReadAndDispatchMessages();
EXPECT_EQ(visitor_.messages_received_, 1);
}
-TEST_F(MoqtMessageSpecificTest, AnnounceHasDeliveryTimeout) {
+TEST_F(MoqtMessageSpecificTest, PublishNamespaceHasDeliveryTimeout) {
webtransport::test::InMemoryStream stream(/*stream_id=*/0);
MoqtControlParser parser(kWebTrans, &stream, visitor_);
- char announce[] = {
+ char publish_namespace[] = {
0x06, 0x00, 0x11, 0x02, 0x01, 0x03, 0x66,
0x6f, 0x6f, // track_namespace = "foo"
0x02, // 2 params
0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72, // authorization_info = "bar"
0x02, 0x67, 0x10, // delivery_timeout = 10000
};
- stream.Receive(absl::string_view(announce, sizeof(announce)), false);
+ stream.Receive(
+ absl::string_view(publish_namespace, sizeof(publish_namespace)), false);
parser.ReadAndDispatchMessages();
EXPECT_EQ(visitor_.messages_received_, 0);
- EXPECT_EQ(visitor_.parsing_error_, "ANNOUNCE contains invalid parameters");
+ EXPECT_EQ(visitor_.parsing_error_,
+ "PUBLISH_NAMESPACE contains invalid parameters");
EXPECT_EQ(visitor_.parsing_error_code_, MoqtError::kProtocolViolation);
}
@@ -1477,22 +1480,25 @@
}
// All messages with TrackNamespace use ReadTrackNamespace too check this. Use
-// ANNOUNCE.
+// PUBLISH_NAMESPACE.
TEST_F(MoqtMessageSpecificTest, NamespaceTooSmall) {
webtransport::test::InMemoryStream stream(/*stream_id=*/0);
MoqtControlParser parser(kRawQuic, &stream, visitor_);
- char announce[7] = {
+ char publish_namespace[7] = {
0x06, 0x00, 0x04, 0x02, // request_id = 2
0x01, 0x00, // one empty namespace element
0x00, // no parameters
};
- stream.Receive(absl::string_view(announce, sizeof(announce)), false);
+ stream.Receive(
+ absl::string_view(publish_namespace, sizeof(publish_namespace)), false);
parser.ReadAndDispatchMessages();
EXPECT_EQ(visitor_.messages_received_, 1);
EXPECT_EQ(visitor_.parsing_error_, std::nullopt);
- --announce[2]; // Remove one element.
- --announce[4];
- stream.Receive(absl::string_view(announce, sizeof(announce) - 1), false);
+ --publish_namespace[2]; // Remove one element.
+ --publish_namespace[4];
+ stream.Receive(
+ absl::string_view(publish_namespace, sizeof(publish_namespace) - 1),
+ false);
parser.ReadAndDispatchMessages();
EXPECT_EQ(visitor_.messages_received_, 1);
EXPECT_EQ(visitor_.parsing_error_, "Invalid number of namespace elements");
@@ -1501,18 +1507,21 @@
TEST_F(MoqtMessageSpecificTest, NamespaceTooLarge) {
webtransport::test::InMemoryStream stream(/*stream_id=*/0);
MoqtControlParser parser(kRawQuic, &stream, visitor_);
- char announce[39] = {
+ char publish_namespace[39] = {
0x06, 0x00, 0x23, 0x02, // type, length = 35, request_id = 2
0x20, // 32 namespace elements. This is the maximum.
};
// 32 empty namespace elements + no parameters.
- stream.Receive(absl::string_view(announce, sizeof(announce) - 1), false);
+ stream.Receive(
+ absl::string_view(publish_namespace, sizeof(publish_namespace) - 1),
+ false);
parser.ReadAndDispatchMessages();
EXPECT_EQ(visitor_.messages_received_, 1);
EXPECT_EQ(visitor_.parsing_error_, std::nullopt);
- ++announce[2]; // Add one element.
- ++announce[4];
- stream.Receive(absl::string_view(announce, sizeof(announce)), false);
+ ++publish_namespace[2]; // Add one element.
+ ++publish_namespace[4];
+ stream.Receive(
+ absl::string_view(publish_namespace, sizeof(publish_namespace)), false);
parser.ReadAndDispatchMessages();
EXPECT_EQ(visitor_.messages_received_, 1);
EXPECT_EQ(visitor_.parsing_error_, "Invalid number of namespace elements");
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc
index 783a0cf..e0dbc62 100644
--- a/quiche/quic/moqt/moqt_session.cc
+++ b/quiche/quic/moqt/moqt_session.cc
@@ -277,7 +277,7 @@
<< peer_max_request_id_;
return false;
}
- if (outgoing_subscribe_announces_.contains(track_namespace)) {
+ if (outgoing_subscribe_namespaces_.contains(track_namespace)) {
std::move(callback)(
track_namespace, RequestErrorCode::kInternalError,
"SUBSCRIBE_NAMESPACE already outstanding for namespace");
@@ -291,15 +291,15 @@
SendControlMessage(framer_.SerializeSubscribeNamespace(message));
QUIC_DLOG(INFO) << ENDPOINT << "Sent SUBSCRIBE_NAMESPACE message for "
<< message.track_namespace;
- pending_outgoing_subscribe_announces_[message.request_id] =
+ pending_outgoing_subscribe_namespaces_[message.request_id] =
PendingSubscribeNamespaceData{track_namespace, std::move(callback)};
- outgoing_subscribe_announces_.emplace(track_namespace);
+ outgoing_subscribe_namespaces_.emplace(track_namespace);
return true;
}
bool MoqtSession::UnsubscribeNamespace(TrackNamespace track_namespace) {
QUICHE_DCHECK(track_namespace.IsValid());
- if (!outgoing_subscribe_announces_.contains(track_namespace)) {
+ if (!outgoing_subscribe_namespaces_.contains(track_namespace)) {
return false;
}
MoqtUnsubscribeNamespace message;
@@ -307,19 +307,21 @@
SendControlMessage(framer_.SerializeUnsubscribeNamespace(message));
QUIC_DLOG(INFO) << ENDPOINT << "Sent UNSUBSCRIBE_NAMESPACE message for "
<< message.track_namespace;
- outgoing_subscribe_announces_.erase(track_namespace);
+ outgoing_subscribe_namespaces_.erase(track_namespace);
return true;
}
-void MoqtSession::Announce(TrackNamespace track_namespace,
- MoqtOutgoingAnnounceCallback announce_callback,
- VersionSpecificParameters parameters) {
+void MoqtSession::PublishNamespace(
+ TrackNamespace track_namespace,
+ MoqtOutgoingPublishNamespaceCallback publish_namespace_callback,
+ VersionSpecificParameters parameters) {
QUICHE_DCHECK(track_namespace.IsValid());
- if (outgoing_announces_.contains(track_namespace)) {
- std::move(announce_callback)(
+ if (outgoing_publish_namespaces_.contains(track_namespace)) {
+ std::move(publish_namespace_callback)(
track_namespace,
- MoqtAnnounceErrorReason{RequestErrorCode::kInternalError,
- "ANNOUNCE already outstanding for namespace"});
+ MoqtPublishNamespaceErrorReason{
+ RequestErrorCode::kInternalError,
+ "PUBLISH_NAMESPACE already outstanding for namespace"});
return;
}
if (next_request_id_ >= peer_max_request_id_) {
@@ -330,51 +332,54 @@
SendControlMessage(framer_.SerializeRequestsBlocked(requests_blocked));
last_requests_blocked_sent_ = peer_max_request_id_;
}
- QUIC_DLOG(INFO) << ENDPOINT << "Tried to send ANNOUNCE with ID "
+ QUIC_DLOG(INFO) << ENDPOINT << "Tried to send PUBLISH_NAMESPACE with ID "
<< next_request_id_
<< " which is greater than the maximum ID "
<< peer_max_request_id_;
return;
}
if (received_goaway_ || sent_goaway_) {
- QUIC_DLOG(INFO) << ENDPOINT << "Tried to send ANNOUNCE after GOAWAY";
+ QUIC_DLOG(INFO) << ENDPOINT
+ << "Tried to send PUBLISH_NAMESPACE after GOAWAY";
return;
}
- MoqtAnnounce message;
+ MoqtPublishNamespace message;
message.request_id = next_request_id_;
next_request_id_ += 2;
message.track_namespace = track_namespace;
message.parameters = parameters;
- SendControlMessage(framer_.SerializeAnnounce(message));
- QUIC_DLOG(INFO) << ENDPOINT << "Sent ANNOUNCE message for "
+ SendControlMessage(framer_.SerializePublishNamespace(message));
+ QUIC_DLOG(INFO) << ENDPOINT << "Sent PUBLISH_NAMESPACE message for "
<< message.track_namespace;
- pending_outgoing_announces_[message.request_id] = track_namespace;
- outgoing_announces_[track_namespace] = std::move(announce_callback);
+ pending_outgoing_publish_namespaces_[message.request_id] = track_namespace;
+ outgoing_publish_namespaces_[track_namespace] =
+ std::move(publish_namespace_callback);
}
-bool MoqtSession::Unannounce(TrackNamespace track_namespace) {
+bool MoqtSession::PublishNamespaceDone(TrackNamespace track_namespace) {
QUICHE_DCHECK(track_namespace.IsValid());
- auto it = outgoing_announces_.find(track_namespace);
- if (it == outgoing_announces_.end()) {
- return false; // Could have been destroyed by ANNOUNCE_CANCEL.
+ auto it = outgoing_publish_namespaces_.find(track_namespace);
+ if (it == outgoing_publish_namespaces_.end()) {
+ return false; // Could have been destroyed by PUBLISH_NAMESPACE_CANCEL.
}
- MoqtUnannounce message;
+ MoqtPublishNamespaceDone message;
message.track_namespace = track_namespace;
- SendControlMessage(framer_.SerializeUnannounce(message));
- QUIC_DLOG(INFO) << ENDPOINT << "Sent UNANNOUNCE message for "
+ SendControlMessage(framer_.SerializePublishNamespaceDone(message));
+ QUIC_DLOG(INFO) << ENDPOINT << "Sent PUBLISH_NAMESPACE_DONE message for "
<< message.track_namespace;
- outgoing_announces_.erase(it);
+ outgoing_publish_namespaces_.erase(it);
return true;
}
-void MoqtSession::CancelAnnounce(TrackNamespace track_namespace,
- RequestErrorCode code,
- absl::string_view reason) {
+void MoqtSession::CancelPublishNamespace(TrackNamespace track_namespace,
+ RequestErrorCode code,
+ absl::string_view reason) {
QUICHE_DCHECK(track_namespace.IsValid());
- MoqtAnnounceCancel message{track_namespace, code, std::string(reason)};
+ MoqtPublishNamespaceCancel message{track_namespace, code,
+ std::string(reason)};
- SendControlMessage(framer_.SerializeAnnounceCancel(message));
- QUIC_DLOG(INFO) << ENDPOINT << "Sent ANNOUNCE_CANCEL message for "
+ SendControlMessage(framer_.SerializePublishNamespaceCancel(message));
+ QUIC_DLOG(INFO) << ENDPOINT << "Sent PUBLISH_NAMESPACE_CANCEL message for "
<< message.track_namespace << " with reason " << reason;
}
@@ -1193,98 +1198,104 @@
it->second->set_delivery_timeout(message.parameters.delivery_timeout);
}
-void MoqtSession::ControlStream::OnAnnounceMessage(
- const MoqtAnnounce& message) {
+void MoqtSession::ControlStream::OnPublishNamespaceMessage(
+ const MoqtPublishNamespace& message) {
if (!session_->ValidateRequestId(message.request_id)) {
return;
}
if (session_->sent_goaway_) {
- QUIC_DLOG(INFO) << ENDPOINT << "Received an ANNOUNCE after GOAWAY";
- MoqtAnnounceError error;
+ QUIC_DLOG(INFO) << ENDPOINT << "Received a PUBLISH_NAMESPACE after GOAWAY";
+ MoqtPublishNamespaceError error;
error.request_id = message.request_id;
error.error_code = RequestErrorCode::kUnauthorized;
- error.error_reason = "ANNOUNCE after GOAWAY";
- SendOrBufferMessage(session_->framer_.SerializeAnnounceError(error));
+ error.error_reason = "PUBLISH_NAMESPACE after GOAWAY";
+ SendOrBufferMessage(
+ session_->framer_.SerializePublishNamespaceError(error));
return;
}
- std::optional<MoqtAnnounceErrorReason> error =
- session_->callbacks_.incoming_announce_callback(message.track_namespace,
- message.parameters);
+ std::optional<MoqtPublishNamespaceErrorReason> error =
+ session_->callbacks_.incoming_publish_namespace_callback(
+ message.track_namespace, message.parameters);
if (error.has_value()) {
- MoqtAnnounceError reply;
+ MoqtPublishNamespaceError reply;
reply.request_id = message.request_id;
reply.error_code = error->error_code;
reply.error_reason = error->reason_phrase;
- SendOrBufferMessage(session_->framer_.SerializeAnnounceError(reply));
+ SendOrBufferMessage(
+ session_->framer_.SerializePublishNamespaceError(reply));
return;
}
- MoqtAnnounceOk ok;
+ MoqtPublishNamespaceOk ok;
ok.request_id = message.request_id;
- SendOrBufferMessage(session_->framer_.SerializeAnnounceOk(ok));
+ SendOrBufferMessage(session_->framer_.SerializePublishNamespaceOk(ok));
}
-// Do not enforce that there is only one of OK or ERROR per ANNOUNCE. Upon
-// ERROR, we immediately destroy the state.
-void MoqtSession::ControlStream::OnAnnounceOkMessage(
- const MoqtAnnounceOk& message) {
- auto it = session_->pending_outgoing_announces_.find(message.request_id);
- if (it == session_->pending_outgoing_announces_.end()) {
+// Do not enforce that there is only one of OK or ERROR per PUBLISH_NAMESPACE.
+// Upon ERROR, we immediately destroy the state.
+void MoqtSession::ControlStream::OnPublishNamespaceOkMessage(
+ const MoqtPublishNamespaceOk& message) {
+ auto it =
+ session_->pending_outgoing_publish_namespaces_.find(message.request_id);
+ if (it == session_->pending_outgoing_publish_namespaces_.end()) {
session_->Error(MoqtError::kProtocolViolation,
- "Received ANNOUNCE_OK for unknown request_id");
+ "Received PUBLISH_NAMESPACE_OK for unknown request_id");
return;
}
TrackNamespace track_namespace = it->second;
- session_->pending_outgoing_announces_.erase(it);
- auto callback_it = session_->outgoing_announces_.find(track_namespace);
- if (callback_it == session_->outgoing_announces_.end()) {
- // It might have already been destroyed due to UNANNOUNCE.
+ session_->pending_outgoing_publish_namespaces_.erase(it);
+ auto callback_it =
+ session_->outgoing_publish_namespaces_.find(track_namespace);
+ if (callback_it == session_->outgoing_publish_namespaces_.end()) {
+ // It might have already been destroyed due to PUBLISH_NAMESPACE_DONE.
return;
}
std::move(callback_it->second)(track_namespace, std::nullopt);
}
-void MoqtSession::ControlStream::OnAnnounceErrorMessage(
- const MoqtAnnounceError& message) {
- auto it = session_->pending_outgoing_announces_.find(message.request_id);
- if (it == session_->pending_outgoing_announces_.end()) {
+void MoqtSession::ControlStream::OnPublishNamespaceErrorMessage(
+ const MoqtPublishNamespaceError& message) {
+ auto it =
+ session_->pending_outgoing_publish_namespaces_.find(message.request_id);
+ if (it == session_->pending_outgoing_publish_namespaces_.end()) {
session_->Error(MoqtError::kProtocolViolation,
- "Received ANNOUNCE_ERROR for unknown request_id");
+ "Received PUBLISH_NAMESPACE_ERROR for unknown request_id");
return;
}
TrackNamespace track_namespace = it->second;
- session_->pending_outgoing_announces_.erase(it);
- auto it2 = session_->outgoing_announces_.find(track_namespace);
- if (it2 == session_->outgoing_announces_.end()) {
- return; // State might have been destroyed due to UNANNOUNCE.
+ session_->pending_outgoing_publish_namespaces_.erase(it);
+ auto it2 = session_->outgoing_publish_namespaces_.find(track_namespace);
+ if (it2 == session_->outgoing_publish_namespaces_.end()) {
+ return; // State might have been destroyed due to PUBLISH_NAMESPACE_DONE.
}
std::move(it2->second)(
track_namespace,
- MoqtAnnounceErrorReason{message.error_code,
- std::string(message.error_reason)});
- session_->outgoing_announces_.erase(it2);
+ MoqtPublishNamespaceErrorReason{message.error_code,
+ std::string(message.error_reason)});
+ session_->outgoing_publish_namespaces_.erase(it2);
}
-void MoqtSession::ControlStream::OnUnannounceMessage(
- const MoqtUnannounce& message) {
- session_->callbacks_.incoming_announce_callback(message.track_namespace,
- std::nullopt);
+void MoqtSession::ControlStream::OnPublishNamespaceDoneMessage(
+ const MoqtPublishNamespaceDone& message) {
+ session_->callbacks_.incoming_publish_namespace_callback(
+ message.track_namespace, std::nullopt);
}
-void MoqtSession::ControlStream::OnAnnounceCancelMessage(
- const MoqtAnnounceCancel& message) {
+void MoqtSession::ControlStream::OnPublishNamespaceCancelMessage(
+ const MoqtPublishNamespaceCancel& message) {
// The spec currently says that if a later SUBSCRIBE arrives for this
// namespace, that SHOULD be a session error. I'm hoping that via Issue #557,
// this will go away. Regardless, a SHOULD will not compel the session to keep
// state forever, so there is no support for this requirement.
- auto it = session_->outgoing_announces_.find(message.track_namespace);
- if (it == session_->outgoing_announces_.end()) {
- return; // State might have been destroyed due to UNANNOUNCE.
+ auto it =
+ session_->outgoing_publish_namespaces_.find(message.track_namespace);
+ if (it == session_->outgoing_publish_namespaces_.end()) {
+ return; // State might have been destroyed due to PUBLISH_NAMESPACE_DONE.
}
std::move(it->second)(
message.track_namespace,
- MoqtAnnounceErrorReason{message.error_code,
- std::string(message.error_reason)});
- session_->outgoing_announces_.erase(it);
+ MoqtPublishNamespaceErrorReason{message.error_code,
+ std::string(message.error_reason)});
+ session_->outgoing_publish_namespaces_.erase(it);
}
void MoqtSession::ControlStream::OnTrackStatusMessage(
@@ -1355,7 +1366,7 @@
session_->framer_.SerializeSubscribeNamespaceError(error));
return;
}
- if (!session_->incoming_subscribe_announces_.AddNamespace(
+ if (!session_->incoming_subscribe_namespace_.AddNamespace(
message.track_namespace)) {
QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE_NAMESPACE for "
<< message.track_namespace
@@ -1369,7 +1380,7 @@
return;
}
std::optional<MoqtSubscribeErrorReason> result =
- session_->callbacks_.incoming_subscribe_announces_callback(
+ session_->callbacks_.incoming_subscribe_namespace_callback(
message.track_namespace, message.parameters);
if (result.has_value()) {
MoqtSubscribeNamespaceError error;
@@ -1378,7 +1389,7 @@
error.error_reason = result->reason_phrase;
SendOrBufferMessage(
session_->framer_.SerializeSubscribeNamespaceError(error));
- session_->incoming_subscribe_announces_.RemoveNamespace(
+ session_->incoming_subscribe_namespace_.RemoveNamespace(
message.track_namespace);
return;
}
@@ -1390,21 +1401,21 @@
void MoqtSession::ControlStream::OnSubscribeNamespaceOkMessage(
const MoqtSubscribeNamespaceOk& message) {
auto it =
- session_->pending_outgoing_subscribe_announces_.find(message.request_id);
- if (it == session_->pending_outgoing_subscribe_announces_.end()) {
+ session_->pending_outgoing_subscribe_namespaces_.find(message.request_id);
+ if (it == session_->pending_outgoing_subscribe_namespaces_.end()) {
session_->Error(MoqtError::kProtocolViolation,
"Received SUBSCRIBE_NAMESPACE_OK for unknown request_id");
return; // UNSUBSCRIBE_NAMESPACE may already have deleted the entry.
}
std::move(it->second.callback)(it->second.track_namespace, std::nullopt, "");
- session_->pending_outgoing_subscribe_announces_.erase(it);
+ session_->pending_outgoing_subscribe_namespaces_.erase(it);
}
void MoqtSession::ControlStream::OnSubscribeNamespaceErrorMessage(
const MoqtSubscribeNamespaceError& message) {
auto it =
- session_->pending_outgoing_subscribe_announces_.find(message.request_id);
- if (it == session_->pending_outgoing_subscribe_announces_.end()) {
+ session_->pending_outgoing_subscribe_namespaces_.find(message.request_id);
+ if (it == session_->pending_outgoing_subscribe_namespaces_.end()) {
session_->Error(
MoqtError::kProtocolViolation,
"Received SUBSCRIBE_NAMESPACE_ERROR for unknown request_id");
@@ -1412,17 +1423,17 @@
}
std::move(it->second.callback)(it->second.track_namespace, message.error_code,
absl::string_view(message.error_reason));
- session_->outgoing_subscribe_announces_.erase(it->second.track_namespace);
- session_->pending_outgoing_subscribe_announces_.erase(it);
+ session_->outgoing_subscribe_namespaces_.erase(it->second.track_namespace);
+ session_->pending_outgoing_subscribe_namespaces_.erase(it);
}
void MoqtSession::ControlStream::OnUnsubscribeNamespaceMessage(
const MoqtUnsubscribeNamespace& message) {
// MoqtSession keeps no state here, so just tell the application.
std::optional<MoqtSubscribeErrorReason> result =
- session_->callbacks_.incoming_subscribe_announces_callback(
+ session_->callbacks_.incoming_subscribe_namespace_callback(
message.track_namespace, std::nullopt);
- session_->incoming_subscribe_announces_.RemoveNamespace(
+ session_->incoming_subscribe_namespace_.RemoveNamespace(
message.track_namespace);
}
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index 407a5c7..55a67cf 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -101,18 +101,22 @@
VersionSpecificParameters parameters);
bool UnsubscribeNamespace(TrackNamespace track_namespace);
- // Send an ANNOUNCE message for |track_namespace|, and call
- // |announce_callback| when the response arrives. Will fail immediately if
- // there is already an unresolved ANNOUNCE for that namespace.
- void Announce(TrackNamespace track_namespace,
- MoqtOutgoingAnnounceCallback announce_callback,
- VersionSpecificParameters parameters);
- // Returns true if message was sent, false if there is no ANNOUNCE to cancel.
- bool Unannounce(TrackNamespace track_namespace);
+ // Send a PUBLISH_NAMESPACE message for |track_namespace|, and call
+ // |publish_namespace_callback| when the response arrives. Will fail
+ // immediately if there is already an unresolved PUBLISH_NAMESPACE for that
+ // namespace.
+ void PublishNamespace(
+ TrackNamespace track_namespace,
+ MoqtOutgoingPublishNamespaceCallback publish_namespace_callback,
+ VersionSpecificParameters parameters);
+ // Returns true if message was sent, false if there is no PUBLISH_NAMESPACE to
+ // cancel.
+ bool PublishNamespaceDone(TrackNamespace track_namespace);
// Allows the subscriber to declare it will not subscribe to |track_namespace|
// anymore.
- void CancelAnnounce(TrackNamespace track_namespace, RequestErrorCode code,
- absl::string_view reason_phrase);
+ void CancelPublishNamespace(TrackNamespace track_namespace,
+ RequestErrorCode code,
+ absl::string_view reason_phrase);
// MoqtSessionInterface implementation.
MoqtSessionCallbacks& callbacks() override { return callbacks_; }
@@ -232,11 +236,16 @@
// There is no state to update for SUBSCRIBE_DONE.
void OnPublishDoneMessage(const MoqtPublishDone& /*message*/) override;
void OnSubscribeUpdateMessage(const MoqtSubscribeUpdate& message) override;
- void OnAnnounceMessage(const MoqtAnnounce& message) override;
- void OnAnnounceOkMessage(const MoqtAnnounceOk& message) override;
- void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override;
- void OnUnannounceMessage(const MoqtUnannounce& message) override;
- void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override;
+ void OnPublishNamespaceMessage(
+ const MoqtPublishNamespace& message) override;
+ void OnPublishNamespaceOkMessage(
+ const MoqtPublishNamespaceOk& message) override;
+ void OnPublishNamespaceErrorMessage(
+ const MoqtPublishNamespaceError& message) override;
+ void OnPublishNamespaceDoneMessage(
+ const MoqtPublishNamespaceDone& /*message*/) override;
+ void OnPublishNamespaceCancelMessage(
+ const MoqtPublishNamespaceCancel& message) override;
void OnTrackStatusMessage(const MoqtTrackStatus& message) override;
void OnTrackStatusOkMessage(const MoqtTrackStatusOk& /*message*/) override {
}
@@ -830,25 +839,26 @@
absl::flat_hash_map<FullTrackName, MoqtPublishingMonitorInterface*>
monitoring_interfaces_for_published_tracks_;
- // Outgoing ANNOUNCE for which no OK or ERROR has been received.
- absl::flat_hash_map<uint64_t, TrackNamespace> pending_outgoing_announces_;
- // All outgoing ANNOUNCE.
- absl::flat_hash_map<TrackNamespace, MoqtOutgoingAnnounceCallback>
- outgoing_announces_;
+ // Outgoing PUBLISH_NAMESPACE for which no OK or ERROR has been received.
+ absl::flat_hash_map<uint64_t, TrackNamespace>
+ pending_outgoing_publish_namespaces_;
+ // All outgoing PUBLISH_NAMESPACE.
+ absl::flat_hash_map<TrackNamespace, MoqtOutgoingPublishNamespaceCallback>
+ outgoing_publish_namespaces_;
// The value is nullptr after OK or ERROR is received. The entry is deleted
// when sending UNSUBSCRIBE_NAMESPACE, to make sure the application doesn't
- // unsubscribe from something that it isn't subscribed to. ANNOUNCEs that
- // result from this subscription use incoming_announce_callback.
+ // unsubscribe from something that it isn't subscribed to. PUBLISH_NAMESPACEs
+ // that result from this subscription use incoming_publish_namespace_callback.
struct PendingSubscribeNamespaceData {
TrackNamespace track_namespace;
MoqtOutgoingSubscribeNamespaceCallback callback;
};
absl::flat_hash_map<uint64_t, PendingSubscribeNamespaceData>
- pending_outgoing_subscribe_announces_;
- absl::flat_hash_set<TrackNamespace> outgoing_subscribe_announces_;
+ pending_outgoing_subscribe_namespaces_;
+ absl::flat_hash_set<TrackNamespace> outgoing_subscribe_namespaces_;
// It's an error if the namespaces overlap, so keep track of them.
- NamespaceTree incoming_subscribe_announces_;
+ NamespaceTree incoming_subscribe_namespace_;
// The minimum request ID the peer can use that is monotonically increasing.
uint64_t next_incoming_request_id_ = 0;
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h
index cc0a35c..f104de0 100644
--- a/quiche/quic/moqt/moqt_session_callbacks.h
+++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -29,10 +29,11 @@
// Called from the session destructor.
using MoqtSessionDeletedCallback = quiche::SingleUseCallback<void()>;
-// Called whenever an ANNOUNCE or UNANNOUNCE message is received from the peer.
-// ANNOUNCE sets a value for |parameters|, UNANNOUNCE does not.
-using MoqtIncomingAnnounceCallback =
- quiche::MultiUseCallback<std::optional<MoqtAnnounceErrorReason>(
+// Called whenever a PUBLISH_NAMESPACE or PUBLISH_NAMESPACE_DONE message is
+// received from the peer. PUBLISH_NAMESPACE sets a value for |parameters|,
+// PUBLISH_NAMESPACE_DONE does not.
+using MoqtIncomingPublishNamespaceCallback =
+ quiche::MultiUseCallback<std::optional<MoqtPublishNamespaceErrorReason>(
const TrackNamespace& track_namespace,
const std::optional<VersionSpecificParameters>& parameters)>;
@@ -46,12 +47,13 @@
const TrackNamespace& track_namespace,
std::optional<VersionSpecificParameters> parameters)>;
-inline std::optional<MoqtAnnounceErrorReason> DefaultIncomingAnnounceCallback(
+inline std::optional<MoqtPublishNamespaceErrorReason>
+DefaultIncomingPublishNamespaceCallback(
const TrackNamespace& /*track_namespace*/,
std::optional<VersionSpecificParameters> /*parameters*/) {
- return std::optional(MoqtAnnounceErrorReason{
+ return std::optional(MoqtPublishNamespaceErrorReason{
RequestErrorCode::kNotSupported,
- "This endpoint does not accept incoming ANNOUNCE messages"});
+ "This endpoint does not accept incoming PUBLISH_NAMESPACE messages"});
};
inline std::optional<MoqtSubscribeErrorReason>
@@ -72,9 +74,9 @@
+[](absl::string_view) {};
MoqtSessionDeletedCallback session_deleted_callback = +[] {};
- MoqtIncomingAnnounceCallback incoming_announce_callback =
- DefaultIncomingAnnounceCallback;
- MoqtIncomingSubscribeNamespaceCallback incoming_subscribe_announces_callback =
+ MoqtIncomingPublishNamespaceCallback incoming_publish_namespace_callback =
+ DefaultIncomingPublishNamespaceCallback;
+ MoqtIncomingSubscribeNamespaceCallback incoming_subscribe_namespace_callback =
DefaultIncomingSubscribeNamespaceCallback;
const quic::QuicClock* clock = quic::QuicDefaultClock::Get();
};
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h
index b60439d..cc2b51c 100644
--- a/quiche/quic/moqt/moqt_session_interface.h
+++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -63,17 +63,18 @@
using FetchResponseCallback =
quiche::SingleUseCallback<void(std::unique_ptr<MoqtFetchTask> fetch_task)>;
-// TODO(martinduke): MoqtOutgoingAnnounceCallback and
+// TODO(martinduke): MoqtOutgoingPublishNamespaceCallback and
// MoqtOutgoingSubscribeNamespaceCallback are deprecated. Remove.
-// If |error_message| is nullopt, this is triggered by an ANNOUNCE_OK.
-// Otherwise, it is triggered by ANNOUNCE_ERROR or ANNOUNCE_CANCEL. For
-// ERROR or CANCEL, MoqtSession is deleting all ANNOUNCE state immediately
-// after calling this callback. Alternatively, the application can call
-// Unannounce() to delete the state.
-using MoqtOutgoingAnnounceCallback = quiche::MultiUseCallback<void(
+// If |error_message| is nullopt, this is triggered by a PUBLISH_NAMESPACE_OK.
+// Otherwise, it is triggered by PUBLISH_NAMESPACE_ERROR or
+// PUBLISH_NAMESPACE_CANCEL. For ERROR or CANCEL, MoqtSession is deleting all
+// PUBLISH_NAMESPACE state immediately after calling this callback.
+// Alternatively, the application can call PublishNamespaceDone() to delete the
+// state.
+using MoqtOutgoingPublishNamespaceCallback = quiche::MultiUseCallback<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error)>;
+ std::optional<MoqtPublishNamespaceErrorReason> error)>;
using MoqtOutgoingSubscribeNamespaceCallback = quiche::SingleUseCallback<void(
TrackNamespace track_namespace, std::optional<RequestErrorCode> error,
@@ -83,7 +84,7 @@
public:
virtual ~MoqtSessionInterface() = default;
- // TODO: move ANNOUNCE logic here.
+ // TODO: move PUBLISH_NAMESPACE logic here.
// Callbacks for session-level events.
virtual MoqtSessionCallbacks& callbacks() = 0;
@@ -159,8 +160,8 @@
// TODO(martinduke): Add an API for absolute joining fetch.
// TODO: Add SubscribeNamespace, UnsubscribeNamespace method.
- // TODO: Add Announce, Unannounce method.
- // TODO: Add AnnounceCancel method.
+ // TODO: Add PublishNamespace, PublishNamespaceDone method.
+ // TODO: Add PublishNamespaceCancel method.
// TODO: Add TrackStatusRequest method.
// TODO: Add SubscribeUpdate, PublishDone method.
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc
index 5a62fb0..348e2c7 100644
--- a/quiche/quic/moqt/moqt_session_test.cc
+++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -154,8 +154,8 @@
.WillByDefault(Return(MoqtForwardingPreference::kSubgroup));
}
- // The publisher receives SUBSCRIBE and synchronously announces it will
- // publish objects.
+ // The publisher receives SUBSCRIBE and synchronously publishes namespaces it
+ // supports.
MoqtObjectListener* ReceiveSubscribeSynchronousOk(
MockTrackPublisher* publisher, MoqtSubscribe& subscribe,
MoqtControlParserVisitor* control_parser, uint64_t track_alias = 0) {
@@ -384,112 +384,116 @@
stream_input->OnPublishMessage(publish);
}
-TEST_F(MoqtSessionTest, AnnounceWithOkAndCancel) {
+TEST_F(MoqtSessionTest, PublishNamespaceWithOkAndCancel) {
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_resolved_callback;
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_resolved_callback;
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
- EXPECT_CALL(mock_stream_,
- Writev(ControlMessageOfType(MoqtMessageType::kAnnounce), _));
- session_.Announce(TrackNamespace("foo"),
- announce_resolved_callback.AsStdFunction(),
- VersionSpecificParameters());
+ EXPECT_CALL(
+ mock_stream_,
+ Writev(ControlMessageOfType(MoqtMessageType::kPublishNamespace), _));
+ session_.PublishNamespace(TrackNamespace("foo"),
+ publish_namespace_resolved_callback.AsStdFunction(),
+ VersionSpecificParameters());
- MoqtAnnounceOk ok = {
+ MoqtPublishNamespaceOk ok = {
/*request_id=*/0,
};
- EXPECT_CALL(announce_resolved_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
EXPECT_EQ(track_namespace, TrackNamespace("foo"));
EXPECT_FALSE(error.has_value());
});
- stream_input->OnAnnounceOkMessage(ok);
+ stream_input->OnPublishNamespaceOkMessage(ok);
- MoqtAnnounceCancel cancel = {
+ MoqtPublishNamespaceCancel cancel = {
TrackNamespace("foo"),
RequestErrorCode::kInternalError,
/*error_reason=*/"Test error",
};
- EXPECT_CALL(announce_resolved_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
EXPECT_EQ(track_namespace, TrackNamespace("foo"));
ASSERT_TRUE(error.has_value());
EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
EXPECT_EQ(error->reason_phrase, "Test error");
});
- stream_input->OnAnnounceCancelMessage(cancel);
+ stream_input->OnPublishNamespaceCancelMessage(cancel);
// State is gone.
- EXPECT_FALSE(session_.Unannounce(TrackNamespace("foo")));
+ EXPECT_FALSE(session_.PublishNamespaceDone(TrackNamespace("foo")));
}
-TEST_F(MoqtSessionTest, AnnounceWithOkAndUnannounce) {
+TEST_F(MoqtSessionTest, PublishNamespaceWithOkAndPublishNamespaceDone) {
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_resolved_callback;
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_resolved_callback;
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
- EXPECT_CALL(mock_stream_,
- Writev(ControlMessageOfType(MoqtMessageType::kAnnounce), _));
- session_.Announce(TrackNamespace{"foo"},
- announce_resolved_callback.AsStdFunction(),
- VersionSpecificParameters());
+ EXPECT_CALL(
+ mock_stream_,
+ Writev(ControlMessageOfType(MoqtMessageType::kPublishNamespace), _));
+ session_.PublishNamespace(TrackNamespace{"foo"},
+ publish_namespace_resolved_callback.AsStdFunction(),
+ VersionSpecificParameters());
- MoqtAnnounceOk ok = {
+ MoqtPublishNamespaceOk ok = {
/*request_id=*/0,
};
- EXPECT_CALL(announce_resolved_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
EXPECT_FALSE(error.has_value());
});
- stream_input->OnAnnounceOkMessage(ok);
+ stream_input->OnPublishNamespaceOkMessage(ok);
EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
- EXPECT_CALL(mock_stream_,
- Writev(ControlMessageOfType(MoqtMessageType::kUnannounce), _));
- session_.Unannounce(TrackNamespace{"foo"});
+ EXPECT_CALL(
+ mock_stream_,
+ Writev(ControlMessageOfType(MoqtMessageType::kPublishNamespaceDone), _));
+ session_.PublishNamespaceDone(TrackNamespace{"foo"});
// State is gone.
- EXPECT_FALSE(session_.Unannounce(TrackNamespace{"foo"}));
+ EXPECT_FALSE(session_.PublishNamespaceDone(TrackNamespace{"foo"}));
}
-TEST_F(MoqtSessionTest, AnnounceWithError) {
+TEST_F(MoqtSessionTest, PublishNamespaceWithError) {
testing::MockFunction<void(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message)>
- announce_resolved_callback;
+ std::optional<MoqtPublishNamespaceErrorReason> error_message)>
+ publish_namespace_resolved_callback;
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
EXPECT_CALL(mock_session_, GetStreamById(_)).WillOnce(Return(&mock_stream_));
- EXPECT_CALL(mock_stream_,
- Writev(ControlMessageOfType(MoqtMessageType::kAnnounce), _));
- session_.Announce(TrackNamespace{"foo"},
- announce_resolved_callback.AsStdFunction(),
- VersionSpecificParameters());
+ EXPECT_CALL(
+ mock_stream_,
+ Writev(ControlMessageOfType(MoqtMessageType::kPublishNamespace), _));
+ session_.PublishNamespace(TrackNamespace{"foo"},
+ publish_namespace_resolved_callback.AsStdFunction(),
+ VersionSpecificParameters());
- MoqtAnnounceError error = {
+ MoqtPublishNamespaceError error = {
/*request_id=*/0,
/*error_code=*/RequestErrorCode::kInternalError,
/*reason_phrase=*/"Test error",
};
- EXPECT_CALL(announce_resolved_callback, Call(_, _))
+ EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _))
.WillOnce([&](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error) {
+ std::optional<MoqtPublishNamespaceErrorReason> error) {
EXPECT_EQ(track_namespace, TrackNamespace{"foo"});
ASSERT_TRUE(error.has_value());
EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError);
EXPECT_EQ(error->reason_phrase, "Test error");
});
- stream_input->OnAnnounceErrorMessage(error);
+ stream_input->OnPublishNamespaceErrorMessage(error);
// State is gone.
- EXPECT_FALSE(session_.Unannounce(TrackNamespace{"foo"}));
+ EXPECT_FALSE(session_.PublishNamespaceDone(TrackNamespace{"foo"}));
}
TEST_F(MoqtSessionTest, AsynchronousSubscribeReturnsOk) {
@@ -940,88 +944,89 @@
EXPECT_EQ(MoqtSessionPeer::remote_track(&session_, 2), nullptr);
}
-TEST_F(MoqtSessionTest, ReplyToAnnounceWithOkThenUnannounce) {
+TEST_F(MoqtSessionTest, ReplyToPublishNamespaceWithOkThenPublishNamespaceDone) {
TrackNamespace track_namespace{"foo"};
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- MoqtAnnounce announce = {
+ MoqtPublishNamespace publish_namespace = {
kDefaultPeerRequestId,
track_namespace,
*parameters,
};
- EXPECT_CALL(session_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(session_callbacks_.incoming_publish_namespace_callback,
Call(track_namespace, parameters))
.WillOnce(Return(std::nullopt));
- EXPECT_CALL(
- mock_stream_,
- Writev(SerializedControlMessage(MoqtAnnounceOk{kDefaultPeerRequestId}),
- _));
- stream_input->OnAnnounceMessage(announce);
- MoqtUnannounce unannounce = {
+ EXPECT_CALL(mock_stream_,
+ Writev(SerializedControlMessage(
+ MoqtPublishNamespaceOk{kDefaultPeerRequestId}),
+ _));
+ stream_input->OnPublishNamespaceMessage(publish_namespace);
+ MoqtPublishNamespaceDone unpublish_namespace = {
track_namespace,
};
- EXPECT_CALL(session_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(session_callbacks_.incoming_publish_namespace_callback,
Call(track_namespace, std::optional<VersionSpecificParameters>()))
.WillOnce(Return(std::nullopt));
- stream_input->OnUnannounceMessage(unannounce);
+ stream_input->OnPublishNamespaceDoneMessage(unpublish_namespace);
}
-TEST_F(MoqtSessionTest, ReplyToAnnounceWithOkThenAnnounceCancel) {
+TEST_F(MoqtSessionTest,
+ ReplyToPublishNamespaceWithOkThenPublishNamespaceCancel) {
TrackNamespace track_namespace{"foo"};
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- MoqtAnnounce announce = {
+ MoqtPublishNamespace publish_namespace = {
kDefaultPeerRequestId,
track_namespace,
*parameters,
};
- EXPECT_CALL(session_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(session_callbacks_.incoming_publish_namespace_callback,
Call(track_namespace, parameters))
.WillOnce(Return(std::nullopt));
- EXPECT_CALL(
- mock_stream_,
- Writev(SerializedControlMessage(MoqtAnnounceOk{kDefaultPeerRequestId}),
- _));
- stream_input->OnAnnounceMessage(announce);
EXPECT_CALL(mock_stream_,
- Writev(SerializedControlMessage(MoqtAnnounceCancel{
+ Writev(SerializedControlMessage(
+ MoqtPublishNamespaceOk{kDefaultPeerRequestId}),
+ _));
+ stream_input->OnPublishNamespaceMessage(publish_namespace);
+ EXPECT_CALL(mock_stream_,
+ Writev(SerializedControlMessage(MoqtPublishNamespaceCancel{
track_namespace, RequestErrorCode::kInternalError,
"deadbeef"}),
_));
- session_.CancelAnnounce(track_namespace, RequestErrorCode::kInternalError,
- "deadbeef");
+ session_.CancelPublishNamespace(track_namespace,
+ RequestErrorCode::kInternalError, "deadbeef");
}
-TEST_F(MoqtSessionTest, ReplyToAnnounceWithError) {
+TEST_F(MoqtSessionTest, ReplyToPublishNamespaceWithError) {
TrackNamespace track_namespace{"foo"};
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_);
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- MoqtAnnounce announce = {
+ MoqtPublishNamespace publish_namespace = {
kDefaultPeerRequestId,
track_namespace,
*parameters,
};
- MoqtAnnounceErrorReason error = {
+ MoqtPublishNamespaceErrorReason error = {
RequestErrorCode::kNotSupported,
"deadbeef",
};
- EXPECT_CALL(session_callbacks_.incoming_announce_callback,
+ EXPECT_CALL(session_callbacks_.incoming_publish_namespace_callback,
Call(track_namespace, parameters))
.WillOnce(Return(error));
EXPECT_CALL(
mock_stream_,
- Writev(SerializedControlMessage(MoqtAnnounceError{
+ Writev(SerializedControlMessage(MoqtPublishNamespaceError{
kDefaultPeerRequestId, error.error_code, error.reason_phrase}),
_));
- stream_input->OnAnnounceMessage(announce);
+ stream_input->OnPublishNamespaceMessage(publish_namespace);
}
TEST_F(MoqtSessionTest, SubscribeNamespaceLifeCycle) {
@@ -2741,7 +2746,7 @@
TrackNamespace track_namespace = TrackNamespace{"foo"};
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- MoqtSubscribeNamespace announces = {
+ MoqtSubscribeNamespace publish_namespaces = {
/*request_id=*/1,
track_namespace,
*parameters,
@@ -2749,27 +2754,27 @@
webtransport::test::MockStream control_stream;
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(_, parameters))
.WillOnce(Return(std::nullopt));
EXPECT_CALL(
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
- stream_input->OnSubscribeNamespaceMessage(announces);
- MoqtUnsubscribeNamespace unsubscribe_announces = {
+ stream_input->OnSubscribeNamespaceMessage(publish_namespaces);
+ MoqtUnsubscribeNamespace ununsubscribe_namespaces = {
TrackNamespace{"foo"},
};
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(track_namespace, std::optional<VersionSpecificParameters>()))
.WillOnce(Return(std::nullopt));
- stream_input->OnUnsubscribeNamespaceMessage(unsubscribe_announces);
+ stream_input->OnUnsubscribeNamespaceMessage(ununsubscribe_namespaces);
}
TEST_F(MoqtSessionTest, IncomingSubscribeNamespaceWithError) {
TrackNamespace track_namespace{"foo"};
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- MoqtSubscribeNamespace announces = {
+ MoqtSubscribeNamespace publish_namespaces = {
/*request_id=*/1,
track_namespace,
*parameters,
@@ -2777,7 +2782,7 @@
webtransport::test::MockStream control_stream;
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(_, parameters))
.WillOnce(Return(
MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"}));
@@ -2785,24 +2790,24 @@
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError),
_));
- stream_input->OnSubscribeNamespaceMessage(announces);
+ stream_input->OnSubscribeNamespaceMessage(publish_namespaces);
// Try again, to verify that it was purged from the tree.
- announces.request_id += 2;
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ publish_namespaces.request_id += 2;
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(_, parameters))
.WillOnce(Return(std::nullopt));
EXPECT_CALL(
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
- stream_input->OnSubscribeNamespaceMessage(announces);
+ stream_input->OnSubscribeNamespaceMessage(publish_namespaces);
}
TEST_F(MoqtSessionTest, IncomingSubscribeNamespaceWithPrefixOverlap) {
TrackNamespace track_namespace{"foo"};
auto parameters = std::make_optional<VersionSpecificParameters>(
AuthTokenType::kOutOfBand, "foo");
- MoqtSubscribeNamespace announces = {
+ MoqtSubscribeNamespace publish_namespaces = {
/*request_id=*/1,
track_namespace,
*parameters,
@@ -2810,41 +2815,41 @@
webtransport::test::MockStream control_stream;
std::unique_ptr<MoqtControlParserVisitor> stream_input =
MoqtSessionPeer::CreateControlStream(&session_, &control_stream);
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(_, parameters))
.WillOnce(Return(std::nullopt));
EXPECT_CALL(
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
- stream_input->OnSubscribeNamespaceMessage(announces);
+ stream_input->OnSubscribeNamespaceMessage(publish_namespaces);
// Overlapping request is rejected.
- announces.request_id += 2;
- announces.track_namespace = TrackNamespace{"foo", "bar"};
+ publish_namespaces.request_id += 2;
+ publish_namespaces.track_namespace = TrackNamespace{"foo", "bar"};
EXPECT_CALL(
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError),
_));
- stream_input->OnSubscribeNamespaceMessage(announces);
+ stream_input->OnSubscribeNamespaceMessage(publish_namespaces);
// Remove the subscription. Now a later one will work.
- MoqtUnsubscribeNamespace unsubscribe_announces = {
+ MoqtUnsubscribeNamespace ununsubscribe_namespaces = {
TrackNamespace{"foo"},
};
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(track_namespace, std::optional<VersionSpecificParameters>()))
.WillOnce(Return(std::nullopt));
- stream_input->OnUnsubscribeNamespaceMessage(unsubscribe_announces);
+ stream_input->OnUnsubscribeNamespaceMessage(ununsubscribe_namespaces);
// Try again, it will work.
- announces.request_id += 2;
- EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback,
+ publish_namespaces.request_id += 2;
+ EXPECT_CALL(session_callbacks_.incoming_subscribe_namespace_callback,
Call(_, parameters))
.WillOnce(Return(std::nullopt));
EXPECT_CALL(
control_stream,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _));
- stream_input->OnSubscribeNamespaceMessage(announces);
+ stream_input->OnSubscribeNamespaceMessage(publish_namespaces);
}
TEST_F(MoqtSessionTest, FetchThenOkThenCancel) {
@@ -3411,10 +3416,10 @@
std::optional<RequestErrorCode> /*error*/,
absl::string_view /*reason*/) {},
VersionSpecificParameters()));
- session_.Announce(
+ session_.PublishNamespace(
TrackNamespace{"foo"},
+[](TrackNamespace /*track_namespace*/,
- std::optional<MoqtAnnounceErrorReason> /*error*/) {},
+ std::optional<MoqtPublishNamespaceErrorReason> /*error*/) {},
VersionSpecificParameters());
EXPECT_FALSE(session_.Fetch(
FullTrackName{TrackNamespace("foo"), "bar"},
@@ -3445,10 +3450,11 @@
mock_stream_,
Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _));
stream_input->OnSubscribeMessage(DefaultSubscribe());
- EXPECT_CALL(mock_stream_,
- Writev(ControlMessageOfType(MoqtMessageType::kAnnounceError), _));
- stream_input->OnAnnounceMessage(
- MoqtAnnounce(3, TrackNamespace("foo"), VersionSpecificParameters()));
+ EXPECT_CALL(
+ mock_stream_,
+ Writev(ControlMessageOfType(MoqtMessageType::kPublishNamespaceError), _));
+ stream_input->OnPublishNamespaceMessage(MoqtPublishNamespace(
+ 3, TrackNamespace("foo"), VersionSpecificParameters()));
EXPECT_CALL(mock_stream_,
Writev(ControlMessageOfType(MoqtMessageType::kFetchError), _));
MoqtFetch fetch = DefaultFetch();
@@ -3465,7 +3471,7 @@
mock_stream_,
Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _));
stream_input->OnTrackStatusMessage(track_status);
- // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc.
+ // Block all outgoing SUBSCRIBE, PUBLISH_NAMESPACE, GOAWAY,etc.
EXPECT_CALL(mock_stream_, Writev).Times(0);
MockSubscribeRemoteTrackVisitor remote_track_visitor;
EXPECT_FALSE(session_.SubscribeCurrentObject(
@@ -3477,10 +3483,10 @@
std::optional<RequestErrorCode> /*error*/,
absl::string_view /*reason*/) {},
VersionSpecificParameters()));
- session_.Announce(
+ session_.PublishNamespace(
TrackNamespace{"foo"},
+[](TrackNamespace /*track_namespace*/,
- std::optional<MoqtAnnounceErrorReason> /*error*/) {},
+ std::optional<MoqtPublishNamespaceErrorReason> /*error*/) {},
VersionSpecificParameters());
EXPECT_FALSE(session_.Fetch(
FullTrackName(TrackNamespace("foo"), "bar"),
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
index 8643c12..6073b87 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -50,20 +50,20 @@
quiche::QuicheBuffer operator()(const MoqtSubscribeUpdate& message) {
return framer.SerializeSubscribeUpdate(message);
}
- quiche::QuicheBuffer operator()(const MoqtAnnounce& message) {
- return framer.SerializeAnnounce(message);
+ quiche::QuicheBuffer operator()(const MoqtPublishNamespace& message) {
+ return framer.SerializePublishNamespace(message);
}
- quiche::QuicheBuffer operator()(const MoqtAnnounceOk& message) {
- return framer.SerializeAnnounceOk(message);
+ quiche::QuicheBuffer operator()(const MoqtPublishNamespaceOk& message) {
+ return framer.SerializePublishNamespaceOk(message);
}
- quiche::QuicheBuffer operator()(const MoqtAnnounceError& message) {
- return framer.SerializeAnnounceError(message);
+ quiche::QuicheBuffer operator()(const MoqtPublishNamespaceError& message) {
+ return framer.SerializePublishNamespaceError(message);
}
- quiche::QuicheBuffer operator()(const MoqtUnannounce& message) {
- return framer.SerializeUnannounce(message);
+ quiche::QuicheBuffer operator()(const MoqtPublishNamespaceDone& message) {
+ return framer.SerializePublishNamespaceDone(message);
}
- quiche::QuicheBuffer operator()(const MoqtAnnounceCancel& message) {
- return framer.SerializeAnnounceCancel(message);
+ quiche::QuicheBuffer operator()(const MoqtPublishNamespaceCancel& message) {
+ return framer.SerializePublishNamespaceCancel(message);
}
quiche::QuicheBuffer operator()(const MoqtTrackStatus& message) {
return framer.SerializeTrackStatus(message);
@@ -153,19 +153,21 @@
void OnSubscribeUpdateMessage(const MoqtSubscribeUpdate& message) {
frames_.push_back(message);
}
- void OnAnnounceMessage(const MoqtAnnounce& message) {
+ void OnPublishNamespaceMessage(const MoqtPublishNamespace& message) {
frames_.push_back(message);
}
- void OnAnnounceOkMessage(const MoqtAnnounceOk& message) {
+ void OnPublishNamespaceOkMessage(const MoqtPublishNamespaceOk& message) {
frames_.push_back(message);
}
- void OnAnnounceErrorMessage(const MoqtAnnounceError& message) {
+ void OnPublishNamespaceErrorMessage(
+ const MoqtPublishNamespaceError& message) {
frames_.push_back(message);
}
- void OnUnannounceMessage(const MoqtUnannounce& message) {
+ void OnPublishNamespaceDoneMessage(const MoqtPublishNamespaceDone& message) {
frames_.push_back(message);
}
- void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) {
+ void OnPublishNamespaceCancelMessage(
+ const MoqtPublishNamespaceCancel& message) {
frames_.push_back(message);
}
void OnTrackStatusMessage(const MoqtTrackStatus& message) {
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
index b0e05d7..57e0d5b 100644
--- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h
+++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -28,9 +28,9 @@
using MoqtGenericFrame = std::variant<
MoqtClientSetup, MoqtServerSetup, MoqtSubscribe, MoqtSubscribeOk,
MoqtSubscribeError, MoqtUnsubscribe, MoqtPublishDone, MoqtSubscribeUpdate,
- MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError, MoqtUnannounce,
- MoqtAnnounceCancel, MoqtTrackStatus, MoqtTrackStatusOk,
- MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace,
+ MoqtPublishNamespace, MoqtPublishNamespaceOk, MoqtPublishNamespaceError,
+ MoqtPublishNamespaceDone, MoqtPublishNamespaceCancel, MoqtTrackStatus,
+ MoqtTrackStatusOk, MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace,
MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError,
MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel,
MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
diff --git a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
index be6f3b2..6998d98 100644
--- a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
+++ b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
@@ -66,19 +66,23 @@
void OnPublishDoneMessage(const MoqtPublishDone& message) override {
OnControlMessage(message);
}
- void OnAnnounceMessage(const MoqtAnnounce& message) override {
+ void OnPublishNamespaceMessage(const MoqtPublishNamespace& message) override {
OnControlMessage(message);
}
- void OnAnnounceOkMessage(const MoqtAnnounceOk& message) override {
+ void OnPublishNamespaceOkMessage(
+ const MoqtPublishNamespaceOk& message) override {
OnControlMessage(message);
}
- void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override {
+ void OnPublishNamespaceErrorMessage(
+ const MoqtPublishNamespaceError& message) override {
OnControlMessage(message);
}
- void OnUnannounceMessage(const MoqtUnannounce& message) override {
+ void OnPublishNamespaceDoneMessage(
+ const MoqtPublishNamespaceDone& message) override {
OnControlMessage(message);
}
- void OnAnnounceCancelMessage(const MoqtAnnounceCancel& message) override {
+ void OnPublishNamespaceCancelMessage(
+ const MoqtPublishNamespaceCancel& message) override {
OnControlMessage(message);
}
void OnTrackStatusMessage(const MoqtTrackStatus& message) override {
diff --git a/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc b/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
index 9c743eb..b124720 100644
--- a/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
+++ b/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
@@ -39,7 +39,7 @@
MoqtSessionCallbacks CreateCallbacks(quic::simulator::Simulator* simulator) {
return MoqtSessionCallbacks(
+[] {}, +[](absl::string_view) {}, +[](absl::string_view) {}, +[] {},
- DefaultIncomingAnnounceCallback,
+ DefaultIncomingPublishNamespaceCallback,
DefaultIncomingSubscribeNamespaceCallback, simulator->GetClock());
}
} // namespace
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index 13126e4..2af6e2b 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -69,16 +69,18 @@
public:
virtual ~TestMessageBase() = default;
- using MessageStructuredData = std::variant<
- MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
- MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, MoqtPublishDone,
- MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError,
- MoqtUnannounce, MoqtAnnounceCancel, MoqtTrackStatus, MoqtTrackStatusOk,
- MoqtTrackStatusError, MoqtGoAway, MoqtSubscribeNamespace,
- MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError,
- MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel,
- MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
- MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
+ using MessageStructuredData =
+ std::variant<MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
+ MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
+ MoqtPublishDone, MoqtSubscribeUpdate, MoqtPublishNamespace,
+ MoqtPublishNamespaceOk, MoqtPublishNamespaceError,
+ MoqtPublishNamespaceDone, MoqtPublishNamespaceCancel,
+ MoqtTrackStatus, MoqtTrackStatusOk, MoqtTrackStatusError,
+ MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk,
+ MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace,
+ MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk,
+ MoqtFetchError, MoqtRequestsBlocked, MoqtPublish,
+ MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
// The total actual size of the message.
size_t total_message_size() const { return wire_image_size_; }
@@ -969,24 +971,24 @@
};
};
-class QUICHE_NO_EXPORT AnnounceMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT PublishNamespaceMessage : public TestMessageBase {
public:
- AnnounceMessage() : TestMessageBase() {
+ PublishNamespaceMessage() : TestMessageBase() {
SetWireImage(raw_packet_, sizeof(raw_packet_));
}
bool EqualFieldValues(MessageStructuredData& values) const override {
- auto cast = std::get<MoqtAnnounce>(values);
- if (cast.request_id != announce_.request_id) {
- QUIC_LOG(INFO) << "ANNOUNCE request ID mismatch";
+ auto cast = std::get<MoqtPublishNamespace>(values);
+ if (cast.request_id != publish_namespace_.request_id) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE request ID mismatch";
return false;
}
- if (cast.track_namespace != announce_.track_namespace) {
- QUIC_LOG(INFO) << "ANNOUNCE track namespace mismatch";
+ if (cast.track_namespace != publish_namespace_.track_namespace) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE track namespace mismatch";
return false;
}
- if (cast.parameters != announce_.parameters) {
- QUIC_LOG(INFO) << "ANNOUNCE parameter mismatch";
+ if (cast.parameters != publish_namespace_.parameters) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE parameter mismatch";
return false;
}
return true;
@@ -995,7 +997,7 @@
void ExpandVarints() override { ExpandVarintsImpl("vvv---vvv-----"); }
MessageStructuredData structured_data() const override {
- return TestMessageBase::MessageStructuredData(announce_);
+ return TestMessageBase::MessageStructuredData(publish_namespace_);
}
private:
@@ -1006,23 +1008,23 @@
0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72, // authorization_tag = "bar"
};
- MoqtAnnounce announce_ = {
+ MoqtPublishNamespace publish_namespace_ = {
/*request_id=*/2,
TrackNamespace{"foo"},
VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"),
};
};
-class QUICHE_NO_EXPORT AnnounceOkMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT PublishNamespaceOkMessage : public TestMessageBase {
public:
- AnnounceOkMessage() : TestMessageBase() {
+ PublishNamespaceOkMessage() : TestMessageBase() {
SetWireImage(raw_packet_, sizeof(raw_packet_));
}
bool EqualFieldValues(MessageStructuredData& values) const override {
- auto cast = std::get<MoqtAnnounceOk>(values);
- if (cast.request_id != announce_ok_.request_id) {
- QUIC_LOG(INFO) << "ANNOUNCE OK MESSAGE request ID mismatch";
+ auto cast = std::get<MoqtPublishNamespaceOk>(values);
+ if (cast.request_id != publish_namespace_ok_.request_id) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE OK MESSAGE request ID mismatch";
return false;
}
return true;
@@ -1031,7 +1033,7 @@
void ExpandVarints() override { ExpandVarintsImpl("v"); }
MessageStructuredData structured_data() const override {
- return TestMessageBase::MessageStructuredData(announce_ok_);
+ return TestMessageBase::MessageStructuredData(publish_namespace_ok_);
}
private:
@@ -1039,29 +1041,29 @@
0x07, 0x00, 0x01, 0x01, // request_id = 1
};
- MoqtAnnounceOk announce_ok_ = {
+ MoqtPublishNamespaceOk publish_namespace_ok_ = {
/*request_id=*/1,
};
};
-class QUICHE_NO_EXPORT AnnounceErrorMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT PublishNamespaceErrorMessage : public TestMessageBase {
public:
- AnnounceErrorMessage() : TestMessageBase() {
+ PublishNamespaceErrorMessage() : TestMessageBase() {
SetWireImage(raw_packet_, sizeof(raw_packet_));
}
bool EqualFieldValues(MessageStructuredData& values) const override {
- auto cast = std::get<MoqtAnnounceError>(values);
- if (cast.request_id != announce_error_.request_id) {
- QUIC_LOG(INFO) << "ANNOUNCE_ERROR request ID mismatch";
+ auto cast = std::get<MoqtPublishNamespaceError>(values);
+ if (cast.request_id != publish_namespace_error_.request_id) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE_ERROR request ID mismatch";
return false;
}
- if (cast.error_code != announce_error_.error_code) {
- QUIC_LOG(INFO) << "ANNOUNCE_ERROR error code mismatch";
+ if (cast.error_code != publish_namespace_error_.error_code) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE_ERROR error code mismatch";
return false;
}
- if (cast.error_reason != announce_error_.error_reason) {
- QUIC_LOG(INFO) << "ANNOUNCE_ERROR error reason mismatch";
+ if (cast.error_reason != publish_namespace_error_.error_reason) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE_ERROR error reason mismatch";
return false;
}
return true;
@@ -1070,7 +1072,7 @@
void ExpandVarints() override { ExpandVarintsImpl("vvv---"); }
MessageStructuredData structured_data() const override {
- return TestMessageBase::MessageStructuredData(announce_error_);
+ return TestMessageBase::MessageStructuredData(publish_namespace_error_);
}
private:
@@ -1080,23 +1082,23 @@
0x03, 0x62, 0x61, 0x72, // reason_phrase = "bar"
};
- MoqtAnnounceError announce_error_ = {
+ MoqtPublishNamespaceError publish_namespace_error_ = {
/*request_id=*/1,
RequestErrorCode::kNotSupported,
/*reason_phrase=*/"bar",
};
};
-class QUICHE_NO_EXPORT UnannounceMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT PublishNamespaceDoneMessage : public TestMessageBase {
public:
- UnannounceMessage() : TestMessageBase() {
+ PublishNamespaceDoneMessage() : TestMessageBase() {
SetWireImage(raw_packet_, sizeof(raw_packet_));
}
bool EqualFieldValues(MessageStructuredData& values) const override {
- auto cast = std::get<MoqtUnannounce>(values);
- if (cast.track_namespace != unannounce_.track_namespace) {
- QUIC_LOG(INFO) << "UNANNOUNCE track namespace mismatch";
+ auto cast = std::get<MoqtPublishNamespaceDone>(values);
+ if (cast.track_namespace != publish_namespace_done_.track_namespace) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE_DONE track namespace mismatch";
return false;
}
return true;
@@ -1105,7 +1107,7 @@
void ExpandVarints() override { ExpandVarintsImpl("vv---"); }
MessageStructuredData structured_data() const override {
- return TestMessageBase::MessageStructuredData(unannounce_);
+ return TestMessageBase::MessageStructuredData(publish_namespace_done_);
}
private:
@@ -1113,29 +1115,29 @@
0x09, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f, // track_namespace
};
- MoqtUnannounce unannounce_ = {
+ MoqtPublishNamespaceDone publish_namespace_done_ = {
TrackNamespace("foo"),
};
};
-class QUICHE_NO_EXPORT AnnounceCancelMessage : public TestMessageBase {
+class QUICHE_NO_EXPORT PublishNamespaceCancelMessage : public TestMessageBase {
public:
- AnnounceCancelMessage() : TestMessageBase() {
+ PublishNamespaceCancelMessage() : TestMessageBase() {
SetWireImage(raw_packet_, sizeof(raw_packet_));
}
bool EqualFieldValues(MessageStructuredData& values) const override {
- auto cast = std::get<MoqtAnnounceCancel>(values);
- if (cast.track_namespace != announce_cancel_.track_namespace) {
- QUIC_LOG(INFO) << "ANNOUNCE CANCEL track namespace mismatch";
+ auto cast = std::get<MoqtPublishNamespaceCancel>(values);
+ if (cast.track_namespace != publish_namespace_cancel_.track_namespace) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE CANCEL track namespace mismatch";
return false;
}
- if (cast.error_code != announce_cancel_.error_code) {
- QUIC_LOG(INFO) << "ANNOUNCE CANCEL error code mismatch";
+ if (cast.error_code != publish_namespace_cancel_.error_code) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE CANCEL error code mismatch";
return false;
}
- if (cast.error_reason != announce_cancel_.error_reason) {
- QUIC_LOG(INFO) << "ANNOUNCE CANCEL reason phrase mismatch";
+ if (cast.error_reason != publish_namespace_cancel_.error_reason) {
+ QUIC_LOG(INFO) << "PUBLISH_NAMESPACE CANCEL reason phrase mismatch";
return false;
}
return true;
@@ -1144,7 +1146,7 @@
void ExpandVarints() override { ExpandVarintsImpl("vv---vv---"); }
MessageStructuredData structured_data() const override {
- return TestMessageBase::MessageStructuredData(announce_cancel_);
+ return TestMessageBase::MessageStructuredData(publish_namespace_cancel_);
}
private:
@@ -1155,7 +1157,7 @@
0x03, 0x62, 0x61, 0x72, // error_reason = "bar"
};
- MoqtAnnounceCancel announce_cancel_ = {
+ MoqtPublishNamespaceCancel publish_namespace_cancel_ = {
TrackNamespace("foo"),
RequestErrorCode::kNotSupported,
/*error_reason=*/"bar",
@@ -2061,16 +2063,16 @@
return std::make_unique<PublishDoneMessage>();
case MoqtMessageType::kSubscribeUpdate:
return std::make_unique<SubscribeUpdateMessage>();
- case MoqtMessageType::kAnnounce:
- return std::make_unique<AnnounceMessage>();
- case MoqtMessageType::kAnnounceOk:
- return std::make_unique<AnnounceOkMessage>();
- case MoqtMessageType::kAnnounceError:
- return std::make_unique<AnnounceErrorMessage>();
- case MoqtMessageType::kUnannounce:
- return std::make_unique<UnannounceMessage>();
- case MoqtMessageType::kAnnounceCancel:
- return std::make_unique<AnnounceCancelMessage>();
+ case MoqtMessageType::kPublishNamespace:
+ return std::make_unique<PublishNamespaceMessage>();
+ case MoqtMessageType::kPublishNamespaceOk:
+ return std::make_unique<PublishNamespaceOkMessage>();
+ case MoqtMessageType::kPublishNamespaceError:
+ return std::make_unique<PublishNamespaceErrorMessage>();
+ case MoqtMessageType::kPublishNamespaceDone:
+ return std::make_unique<PublishNamespaceDoneMessage>();
+ case MoqtMessageType::kPublishNamespaceCancel:
+ return std::make_unique<PublishNamespaceCancelMessage>();
case MoqtMessageType::kTrackStatus:
return std::make_unique<TrackStatusMessage>();
case MoqtMessageType::kTrackStatusOk:
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc
index 1bfb70e..ab6f73c 100644
--- a/quiche/quic/moqt/tools/chat_client.cc
+++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -27,6 +27,7 @@
#include "quiche/quic/moqt/moqt_priority.h"
#include "quiche/quic/moqt/moqt_publisher.h"
#include "quiche/quic/moqt/moqt_session.h"
+#include "quiche/quic/moqt/moqt_session_interface.h"
#include "quiche/quic/moqt/tools/moq_chat.h"
#include "quiche/quic/moqt/tools/moqt_client.h"
#include "quiche/quic/platform/api/quic_default_proof_providers.h"
@@ -39,35 +40,37 @@
namespace moqt::moq_chat {
-std::optional<MoqtAnnounceErrorReason> ChatClient::OnIncomingAnnounce(
+std::optional<MoqtPublishNamespaceErrorReason>
+ChatClient::OnIncomingPublishNamespace(
const moqt::TrackNamespace& track_namespace,
std::optional<VersionSpecificParameters> parameters) {
if (track_namespace == GetUserNamespace(my_track_name_)) {
- // Ignore ANNOUNCE for my own track.
- return std::optional<MoqtAnnounceErrorReason>();
+ // Ignore PUBLISH_NAMESPACE for my own track.
+ return std::optional<MoqtPublishNamespaceErrorReason>();
}
std::optional<FullTrackName> track_name = ConstructTrackNameFromNamespace(
track_namespace, GetChatId(my_track_name_));
if (!parameters.has_value()) {
- std::cout << "UNANNOUNCE for " << track_namespace.ToString() << "\n";
+ std::cout << "PUBLISH_NAMESPACE_DONE for " << track_namespace.ToString()
+ << "\n";
if (track_name.has_value() && other_users_.contains(*track_name)) {
session_->Unsubscribe(*track_name);
other_users_.erase(*track_name);
}
return std::nullopt;
}
- std::cout << "ANNOUNCE for " << track_namespace.ToString() << "\n";
+ std::cout << "PUBLISH_NAMESPACE for " << track_namespace.ToString() << "\n";
if (!track_name.has_value()) {
- std::cout << "ANNOUNCE rejected, invalid namespace\n";
- return std::make_optional<MoqtAnnounceErrorReason>(
+ std::cout << "PUBLISH_NAMESPACE rejected, invalid namespace\n";
+ return std::make_optional<MoqtPublishNamespaceErrorReason>(
RequestErrorCode::kTrackDoesNotExist, "Not a subscribed namespace");
}
if (other_users_.contains(*track_name)) {
- std::cout << "Duplicate ANNOUNCE, send OK and ignore\n";
+ std::cout << "Duplicate PUBLISH_NAMESPACE, send OK and ignore\n";
return std::nullopt;
}
if (GetUsername(my_track_name_) == GetUsername(*track_name)) {
- std::cout << "ANNOUNCE for a previous instance of my track, "
+ std::cout << "PUBLISH_NAMESPACE for a previous instance of my track, "
"do not subscribe\n";
return std::nullopt;
}
@@ -78,7 +81,7 @@
++subscribes_to_make_;
other_users_.emplace(*track_name);
}
- return std::nullopt; // Send ANNOUNCE_OK.
+ return std::nullopt; // Send PUBLISH_NAMESPACE_OK.
}
ChatClient::ChatClient(const quic::QuicServerId& server_id,
@@ -128,8 +131,8 @@
session_callbacks_.session_deleted_callback = [this]() {
session_ = nullptr;
};
- session_callbacks_.incoming_announce_callback =
- absl::bind_front(&ChatClient::OnIncomingAnnounce, this);
+ session_callbacks_.incoming_publish_namespace_callback =
+ absl::bind_front(&ChatClient::OnIncomingPublishNamespace, this);
interface_->Initialize(
[this](absl::string_view input_message) {
OnTerminalLineInput(input_message);
@@ -150,9 +153,9 @@
return;
}
if (input_message == "/exit") {
- // Clean teardown of SUBSCRIBE_NAMESPACE, ANNOUNCE, SUBSCRIBE.
+ // Clean teardown of SUBSCRIBE_NAMESPACE, PUBLISH_NAMESPACE, SUBSCRIBE.
session_->UnsubscribeNamespace(GetChatNamespace(my_track_name_));
- session_->Unannounce(GetUserNamespace(my_track_name_));
+ session_->PublishNamespaceDone(GetUserNamespace(my_track_name_));
for (const auto& track_name : other_users_) {
session_->Unsubscribe(track_name);
}
@@ -205,7 +208,7 @@
client_->WriteToOutput(GetUsername(*it), object);
}
-bool ChatClient::AnnounceAndSubscribeNamespace() {
+bool ChatClient::PublishNamespaceAndSubscribeNamespace() {
session_ = client_->session();
if (session_ == nullptr) {
std::cout << "Failed to connect.\n";
@@ -217,26 +220,29 @@
my_track_name_, MoqtForwardingPreference::kSubgroup);
publisher_.Add(queue_);
session_->set_publisher(&publisher_);
- MoqtOutgoingAnnounceCallback announce_callback =
+ MoqtOutgoingPublishNamespaceCallback publish_namespace_callback =
[this](TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> reason) {
+ std::optional<MoqtPublishNamespaceErrorReason> reason) {
if (reason.has_value()) {
- std::cout << "ANNOUNCE rejected, " << reason->reason_phrase << "\n";
- session_->Error(MoqtError::kInternalError, "Local ANNOUNCE rejected");
+ std::cout << "PUBLISH_NAMESPACE rejected, " << reason->reason_phrase
+ << "\n";
+ session_->Error(MoqtError::kInternalError,
+ "Local PUBLISH_NAMESPACE rejected");
return;
}
- std::cout << "ANNOUNCE for " << track_namespace.ToString()
+ std::cout << "PUBLISH_NAMESPACE for " << track_namespace.ToString()
<< " accepted\n";
return;
};
std::cout << "Announcing " << GetUserNamespace(my_track_name_).ToString()
<< "\n";
- session_->Announce(GetUserNamespace(my_track_name_),
- std::move(announce_callback), VersionSpecificParameters());
+ session_->PublishNamespace(GetUserNamespace(my_track_name_),
+ std::move(publish_namespace_callback),
+ VersionSpecificParameters());
- // Send SUBSCRIBE_ANNOUNCE. Pop 3 levels of namespace to get to {moq-chat,
- // chat-id}
- MoqtOutgoingSubscribeNamespaceCallback subscribe_announces_callback =
+ // Send SUBSCRIBE_NAMESPACE. Pop 3 levels of namespace to get to
+ // {moq-chat, chat-id}
+ MoqtOutgoingSubscribeNamespaceCallback subscribe_namespace_callback =
[this](TrackNamespace track_namespace,
std::optional<RequestErrorCode> error, absl::string_view reason) {
if (error.has_value()) {
@@ -252,7 +258,7 @@
VersionSpecificParameters parameters(
AuthTokenType::kOutOfBand, std::string(GetUsername(my_track_name_)));
session_->SubscribeNamespace(GetChatNamespace(my_track_name_),
- std::move(subscribe_announces_callback),
+ std::move(subscribe_namespace_callback),
parameters);
while (session_is_open_ && is_syncing()) {
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h
index fcb9981..85becbf 100644
--- a/quiche/quic/moqt/tools/chat_client.h
+++ b/quiche/quic/moqt/tools/chat_client.h
@@ -112,7 +112,7 @@
};
// Returns false on error.
- bool AnnounceAndSubscribeNamespace();
+ bool PublishNamespaceAndSubscribeNamespace();
bool session_is_open() const { return session_is_open_; }
@@ -126,8 +126,8 @@
private:
void RunEventLoop() { event_loop_->RunEventLoopOnce(kChatEventLoopDuration); }
- // Callback for incoming announces.
- std::optional<MoqtAnnounceErrorReason> OnIncomingAnnounce(
+ // Callback for incoming publish_namespaces.
+ std::optional<MoqtPublishNamespaceErrorReason> OnIncomingPublishNamespace(
const moqt::TrackNamespace& track_namespace,
std::optional<VersionSpecificParameters> parameters);
@@ -150,7 +150,7 @@
absl::flat_hash_set<FullTrackName> other_users_;
int subscribes_to_make_ = 0;
- // Related to subscriptions/announces
+ // Related to subscriptions/publish_namespaces
// TODO: One for each subscribe
RemoteTrackVisitor remote_track_visitor_;
diff --git a/quiche/quic/moqt/tools/chat_client_bin.cc b/quiche/quic/moqt/tools/chat_client_bin.cc
index e627ea4..c391c8c 100644
--- a/quiche/quic/moqt/tools/chat_client_bin.cc
+++ b/quiche/quic/moqt/tools/chat_client_bin.cc
@@ -152,7 +152,7 @@
if (!client.Connect(path)) {
return 1;
}
- if (!client.AnnounceAndSubscribeNamespace()) {
+ if (!client.PublishNamespaceAndSubscribeNamespace()) {
return 1;
}
client.IoLoop();
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc
index 4c64466..fa7d5d4 100644
--- a/quiche/quic/moqt/tools/chat_server.cc
+++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -26,32 +26,34 @@
namespace moqt::moq_chat {
-std::optional<MoqtAnnounceErrorReason>
-ChatServer::ChatServerSessionHandler::OnIncomingAnnounce(
+std::optional<MoqtPublishNamespaceErrorReason>
+ChatServer::ChatServerSessionHandler::OnIncomingPublishNamespace(
const moqt::TrackNamespace& track_namespace,
std::optional<VersionSpecificParameters> parameters) {
if (track_name_.has_value() &&
GetUserNamespace(*track_name_) != track_namespace) {
// ChatServer only supports one track per client session at a time. Return
- // ANNOUNCE_OK and exit.
+ // PUBLISH_NAMESPACE_OK and exit.
return std::nullopt;
}
- // Accept the ANNOUNCE regardless of the chat_id.
+ // Accept the PUBLISH_NAMESPACE regardless of the chat_id.
track_name_ = ConstructTrackNameFromNamespace(track_namespace,
GetChatId(track_namespace));
if (!track_name_.has_value()) {
- std::cout << "Malformed ANNOUNCE namespace\n";
- return MoqtAnnounceErrorReason(RequestErrorCode::kTrackDoesNotExist,
- "Not a valid namespace for this chat.");
+ std::cout << "Malformed PUBLISH_NAMESPACE namespace\n";
+ return MoqtPublishNamespaceErrorReason(
+ RequestErrorCode::kTrackDoesNotExist,
+ "Not a valid namespace for this chat.");
}
if (!parameters.has_value()) {
- std::cout << "Received UNANNOUNCE for " << track_namespace.ToString()
- << "\n";
+ std::cout << "Received PUBLISH_NAMESPACE_DONE for "
+ << track_namespace.ToString() << "\n";
server_->DeleteUser(*track_name_);
track_name_.reset();
return std::nullopt;
}
- std::cout << "Received ANNOUNCE for " << track_namespace.ToString() << "\n";
+ std::cout << "Received PUBLISH_NAMESPACE for " << track_namespace.ToString()
+ << "\n";
session_->SubscribeCurrentObject(*track_name_,
server_->remote_track_visitor(),
moqt::VersionSpecificParameters());
@@ -59,11 +61,11 @@
return std::nullopt;
}
-void ChatServer::ChatServerSessionHandler::OnOutgoingAnnounceReply(
+void ChatServer::ChatServerSessionHandler::OnOutgoingPublishNamespaceReply(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message) {
+ std::optional<MoqtPublishNamespaceErrorReason> error_message) {
// Log the result; the server doesn't really care.
- std::cout << "ANNOUNCE for " << track_namespace.ToString();
+ std::cout << "PUBLISH_NAMESPACE for " << track_namespace.ToString();
if (error_message.has_value()) {
std::cout << " failed with error: " << error_message->reason_phrase << "\n";
} else {
@@ -74,8 +76,8 @@
ChatServer::ChatServerSessionHandler::ChatServerSessionHandler(
MoqtSession* session, ChatServer* server)
: session_(session), server_(server) {
- session_->callbacks().incoming_announce_callback = absl::bind_front(
- &ChatServer::ChatServerSessionHandler::OnIncomingAnnounce, this);
+ session_->callbacks().incoming_publish_namespace_callback = absl::bind_front(
+ &ChatServer::ChatServerSessionHandler::OnIncomingPublishNamespace, this);
session_->callbacks().session_terminated_callback =
[this](absl::string_view error_message) {
std::cout << "Session terminated, reason = " << error_message << "\n";
@@ -84,7 +86,7 @@
server_->DeleteUser(*track_name_);
}
};
- session_->callbacks().incoming_subscribe_announces_callback =
+ session_->callbacks().incoming_subscribe_namespace_callback =
[this](const moqt::TrackNamespace& chat_namespace,
std::optional<VersionSpecificParameters> parameters) {
if (parameters.has_value()) {
@@ -104,19 +106,19 @@
if (!parameters.has_value()) {
return std::optional<MoqtSubscribeErrorReason>();
}
- // Send all ANNOUNCE.
+ // Send all PUBLISH_NAMESPACE.
for (auto& [track_name, queue] : server_->user_queues_) {
- std::cout << "Sending ANNOUNCE for "
+ std::cout << "Sending PUBLISH_NAMESPACE for "
<< GetUserNamespace(track_name).ToString() << "\n";
if (track_name_.has_value() &&
GetUsername(*track_name_) == GetUsername(track_name)) {
- // Don't ANNOUNCE a client to itself.
+ // Don't PUBLISH_NAMESPACE a client to itself.
continue;
}
- session_->Announce(
+ session_->PublishNamespace(
GetUserNamespace(track_name),
absl::bind_front(&ChatServer::ChatServerSessionHandler::
- OnOutgoingAnnounceReply,
+ OnOutgoingPublishNamespaceReply,
this),
moqt::VersionSpecificParameters());
}
@@ -202,7 +204,7 @@
MoqtDeliveryOrder::kAscending, quic::QuicTime::Infinite());
publisher_.Add(user_queues_[track_name]);
for (auto& session : sessions_) {
- session.AnnounceIfSubscribed(track_name.track_namespace());
+ session.PublishNamespaceIfSubscribed(track_name.track_namespace());
}
}
@@ -216,7 +218,7 @@
publisher_.Delete(track_name);
TrackNamespace track_namespace = GetUserNamespace(track_name);
for (auto& session : sessions_) {
- session.UnannounceIfSubscribed(track_namespace);
+ session.PublishNamespaceDoneIfSubscribed(track_namespace);
}
if (user_queues_.empty()) {
std::cout << "No more users!\n";
diff --git a/quiche/quic/moqt/tools/chat_server.h b/quiche/quic/moqt/tools/chat_server.h
index 468845f..971e49e 100644
--- a/quiche/quic/moqt/tools/chat_server.h
+++ b/quiche/quic/moqt/tools/chat_server.h
@@ -64,14 +64,14 @@
it_ = it;
}
- void AnnounceIfSubscribed(TrackNamespace track_namespace) {
+ void PublishNamespaceIfSubscribed(TrackNamespace track_namespace) {
for (const TrackNamespace& subscribed_namespace :
subscribed_namespaces_) {
if (track_namespace.InNamespace(subscribed_namespace)) {
- session_->Announce(
+ session_->PublishNamespace(
track_namespace,
absl::bind_front(&ChatServer::ChatServerSessionHandler::
- OnOutgoingAnnounceReply,
+ OnOutgoingPublishNamespaceReply,
this),
VersionSpecificParameters());
return;
@@ -79,24 +79,24 @@
}
}
- void UnannounceIfSubscribed(TrackNamespace track_namespace) {
+ void PublishNamespaceDoneIfSubscribed(TrackNamespace track_namespace) {
for (const TrackNamespace& subscribed_namespace :
subscribed_namespaces_) {
if (track_namespace.InNamespace(subscribed_namespace)) {
- session_->Unannounce(track_namespace);
+ session_->PublishNamespaceDone(track_namespace);
return;
}
}
}
private:
- // Callback for incoming announces.
- std::optional<MoqtAnnounceErrorReason> OnIncomingAnnounce(
+ // Callback for incoming publish_namespaces.
+ std::optional<MoqtPublishNamespaceErrorReason> OnIncomingPublishNamespace(
const moqt::TrackNamespace& track_namespace,
std::optional<VersionSpecificParameters> parameters);
- void OnOutgoingAnnounceReply(
+ void OnOutgoingPublishNamespaceReply(
TrackNamespace track_namespace,
- std::optional<MoqtAnnounceErrorReason> error_message);
+ std::optional<MoqtPublishNamespaceErrorReason> error_message);
MoqtSession* session_; // Not owned.
// This design assumes that each server has exactly one username, although
diff --git a/quiche/quic/moqt/tools/moq_chat.h b/quiche/quic/moqt/tools/moq_chat.h
index 9d43814..ea40a84 100644
--- a/quiche/quic/moqt/tools/moq_chat.h
+++ b/quiche/quic/moqt/tools/moq_chat.h
@@ -44,7 +44,7 @@
std::optional<FullTrackName> ConstructTrackNameFromNamespace(
const TrackNamespace& track_namespace, absl::string_view chat_id);
-// Strips "chat" from the end of |track_name| to use in ANNOUNCE.
+// Strips "chat" from the end of |track_name| to use in PUBLISH_NAMESPACE.
const TrackNamespace& GetUserNamespace(const FullTrackName& track_name);
// Returns {"moq-chat", chat-id}, useful for SUBSCRIBE_NAMESPACE.
diff --git a/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc b/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc
index f808d47..0527dfe 100644
--- a/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc
+++ b/quiche/quic/moqt/tools/moq_chat_end_to_end_test.cc
@@ -96,8 +96,8 @@
TEST_F(MoqChatEndToEndTest, EndToEndTest) {
EXPECT_TRUE(client1_->Connect(moqt::moq_chat::kWebtransPath));
EXPECT_TRUE(client2_->Connect(moqt::moq_chat::kWebtransPath));
- EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace());
- EXPECT_TRUE(client2_->AnnounceAndSubscribeNamespace());
+ EXPECT_TRUE(client1_->PublishNamespaceAndSubscribeNamespace());
+ EXPECT_TRUE(client2_->PublishNamespaceAndSubscribeNamespace());
SendAndWaitForOutput(interface1_, interface2_, "client1", "Hello");
SendAndWaitForOutput(interface2_, interface1_, "client2", "Hi");
SendAndWaitForOutput(interface1_, interface2_, "client1", "How are you?");
@@ -113,8 +113,8 @@
TEST_F(MoqChatEndToEndTest, LeaveAndRejoin) {
EXPECT_TRUE(client1_->Connect(moqt::moq_chat::kWebtransPath));
EXPECT_TRUE(client2_->Connect(moqt::moq_chat::kWebtransPath));
- EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace());
- EXPECT_TRUE(client2_->AnnounceAndSubscribeNamespace());
+ EXPECT_TRUE(client1_->PublishNamespaceAndSubscribeNamespace());
+ EXPECT_TRUE(client2_->PublishNamespaceAndSubscribeNamespace());
SendAndWaitForOutput(interface1_, interface2_, "client1", "Hello");
SendAndWaitForOutput(interface2_, interface1_, "client2", "Hi");
@@ -136,7 +136,7 @@
std::move(if1bptr), "test_chat", "client1", "device1",
server_.moqt_server().quic_server().event_loop());
EXPECT_TRUE(client1_->Connect(moqt::moq_chat::kWebtransPath));
- EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace());
+ EXPECT_TRUE(client1_->PublishNamespaceAndSubscribeNamespace());
SendAndWaitForOutput(interface1b_, interface2_, "client1", "Hello again");
SendAndWaitForOutput(interface2_, interface1b_, "client2", "Hi again");
}
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
index 8fd51fe..c59955f 100644
--- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
+++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -3,7 +3,7 @@
// found in the LICENSE file.
// moqt_ingestion_server is a simple command-line utility that accepts incoming
-// ANNOUNCE messages and records them into a file.
+// PUBLISH_NAMESPACE messages and records them into a file.
#include <sys/stat.h>
@@ -112,21 +112,24 @@
explicit MoqtIngestionHandler(MoqtSession* session,
absl::string_view output_root)
: session_(session), output_root_(output_root) {
- session_->callbacks().incoming_announce_callback =
- absl::bind_front(&MoqtIngestionHandler::OnAnnounceReceived, this);
+ session_->callbacks().incoming_publish_namespace_callback =
+ absl::bind_front(&MoqtIngestionHandler::OnPublishNamespaceReceived,
+ this);
}
- // TODO(martinduke): Handle when |announce| is false (UNANNOUNCE).
- std::optional<MoqtAnnounceErrorReason> OnAnnounceReceived(
+ // TODO(martinduke): Handle when |publish_namespace| is false
+ // (PUBLISH_NAMESPACE_DONE).
+ std::optional<MoqtPublishNamespaceErrorReason> OnPublishNamespaceReceived(
TrackNamespace track_namespace,
std::optional<VersionSpecificParameters> /*parameters*/) {
if (!IsValidTrackNamespace(track_namespace) &&
!quiche::GetQuicheCommandLineFlag(
FLAGS_allow_invalid_track_namespaces)) {
- QUICHE_DLOG(WARNING) << "Rejected remote announce as it contained "
- "disallowed characters; namespace: "
- << track_namespace;
- return MoqtAnnounceErrorReason{
+ QUICHE_DLOG(WARNING)
+ << "Rejected remote publish_namespace as it contained "
+ "disallowed characters; namespace: "
+ << track_namespace;
+ return MoqtPublishNamespaceErrorReason{
RequestErrorCode::kInternalError,
"Track namespace contains disallowed characters"};
}
@@ -146,8 +149,9 @@
subscribed_namespaces_.erase(it);
QUICHE_LOG(ERROR) << "Failed to create directory " << directory_path
<< "; " << status;
- return MoqtAnnounceErrorReason{RequestErrorCode::kInternalError,
- "Failed to create output directory"};
+ return MoqtPublishNamespaceErrorReason{
+ RequestErrorCode::kInternalError,
+ "Failed to create output directory"};
}
std::string track_list = quiche::GetQuicheCommandLineFlag(FLAGS_tracks);
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h
index 1dbc446..ac1571d 100644
--- a/quiche/quic/moqt/tools/moqt_mock_visitor.h
+++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -12,13 +12,14 @@
#include <variant>
#include "absl/status/status.h"
-#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/quic_time.h"
#include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/quic/moqt/moqt_object.h"
#include "quiche/quic/moqt/moqt_priority.h"
#include "quiche/quic/moqt/moqt_publisher.h"
#include "quiche/quic/moqt/moqt_session.h"
+#include "quiche/quic/moqt/moqt_session_callbacks.h"
#include "quiche/quic/moqt/moqt_track.h"
#include "quiche/common/platform/api/quiche_test.h"
@@ -29,17 +30,17 @@
testing::MockFunction<void(absl::string_view)> goaway_received_callback;
testing::MockFunction<void(absl::string_view)> session_terminated_callback;
testing::MockFunction<void()> session_deleted_callback;
- testing::MockFunction<std::optional<MoqtAnnounceErrorReason>(
+ testing::MockFunction<std::optional<MoqtPublishNamespaceErrorReason>(
const TrackNamespace&, std::optional<VersionSpecificParameters>)>
- incoming_announce_callback;
+ incoming_publish_namespace_callback;
testing::MockFunction<std::optional<MoqtSubscribeErrorReason>(
TrackNamespace, std::optional<VersionSpecificParameters>)>
- incoming_subscribe_announces_callback;
+ incoming_subscribe_namespace_callback;
MockSessionCallbacks() {
- ON_CALL(incoming_announce_callback, Call(testing::_, testing::_))
- .WillByDefault(DefaultIncomingAnnounceCallback);
- ON_CALL(incoming_subscribe_announces_callback, Call(testing::_, testing::_))
+ ON_CALL(incoming_publish_namespace_callback, Call(testing::_, testing::_))
+ .WillByDefault(DefaultIncomingPublishNamespaceCallback);
+ ON_CALL(incoming_subscribe_namespace_callback, Call(testing::_, testing::_))
.WillByDefault(DefaultIncomingSubscribeNamespaceCallback);
}
@@ -49,8 +50,8 @@
goaway_received_callback.AsStdFunction(),
session_terminated_callback.AsStdFunction(),
session_deleted_callback.AsStdFunction(),
- incoming_announce_callback.AsStdFunction(),
- incoming_subscribe_announces_callback.AsStdFunction()};
+ incoming_publish_namespace_callback.AsStdFunction(),
+ incoming_subscribe_namespace_callback.AsStdFunction()};
}
};
