Rename MoQT SubscribeAnnounces to SubscribeNamespace. This completes the update to draft-13. PiperOrigin-RevId: 792716552
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc index fdaac7e..15a00d2 100644 --- a/quiche/quic/moqt/moqt_framer.cc +++ b/quiche/quic/moqt/moqt_framer.cc
@@ -598,39 +598,39 @@ WireStringWithVarInt62Length(message.new_session_uri)); } -quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnounces( - const MoqtSubscribeAnnounces& message) { +quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespace( + const MoqtSubscribeNamespace& message) { KeyValuePairList parameters; VersionSpecificParametersToKeyValuePairList(message.parameters, parameters); if (!ValidateVersionSpecificParameters( - parameters, MoqtMessageType::kSubscribeAnnounces)) { + parameters, MoqtMessageType::kSubscribeNamespace)) { QUICHE_BUG(QUICHE_BUG_invalid_parameters) << "Serializing invalid MoQT parameters"; return quiche::QuicheBuffer(); } - return SerializeControlMessage(MoqtMessageType::kSubscribeAnnounces, + return SerializeControlMessage(MoqtMessageType::kSubscribeNamespace, WireVarInt62(message.request_id), WireTrackNamespace(message.track_namespace), WireKeyValuePairList(parameters)); } -quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesOk( - const MoqtSubscribeAnnouncesOk& message) { - return SerializeControlMessage(MoqtMessageType::kSubscribeAnnouncesOk, +quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceOk( + const MoqtSubscribeNamespaceOk& message) { + return SerializeControlMessage(MoqtMessageType::kSubscribeNamespaceOk, WireVarInt62(message.request_id)); } -quiche::QuicheBuffer MoqtFramer::SerializeSubscribeAnnouncesError( - const MoqtSubscribeAnnouncesError& message) { +quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceError( + const MoqtSubscribeNamespaceError& message) { return SerializeControlMessage( - MoqtMessageType::kSubscribeAnnouncesError, + MoqtMessageType::kSubscribeNamespaceError, WireVarInt62(message.request_id), WireVarInt62(message.error_code), WireStringWithVarInt62Length(message.error_reason)); } -quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeAnnounces( - const MoqtUnsubscribeAnnounces& message) { - return SerializeControlMessage(MoqtMessageType::kUnsubscribeAnnounces, +quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeNamespace( + const MoqtUnsubscribeNamespace& message) { + return SerializeControlMessage(MoqtMessageType::kUnsubscribeNamespace, WireTrackNamespace(message.track_namespace)); }
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h index 8310736..b053255 100644 --- a/quiche/quic/moqt/moqt_framer.h +++ b/quiche/quic/moqt/moqt_framer.h
@@ -57,14 +57,14 @@ const MoqtTrackStatusRequest& message); quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message); quiche::QuicheBuffer SerializeGoAway(const MoqtGoAway& message); - quiche::QuicheBuffer SerializeSubscribeAnnounces( - const MoqtSubscribeAnnounces& message); - quiche::QuicheBuffer SerializeSubscribeAnnouncesOk( - const MoqtSubscribeAnnouncesOk& message); - quiche::QuicheBuffer SerializeSubscribeAnnouncesError( - const MoqtSubscribeAnnouncesError& message); - quiche::QuicheBuffer SerializeUnsubscribeAnnounces( - const MoqtUnsubscribeAnnounces& message); + quiche::QuicheBuffer SerializeSubscribeNamespace( + const MoqtSubscribeNamespace& message); + quiche::QuicheBuffer SerializeSubscribeNamespaceOk( + const MoqtSubscribeNamespaceOk& message); + quiche::QuicheBuffer SerializeSubscribeNamespaceError( + const MoqtSubscribeNamespaceError& message); + quiche::QuicheBuffer SerializeUnsubscribeNamespace( + const MoqtUnsubscribeNamespace& message); quiche::QuicheBuffer SerializeMaxRequestId(const MoqtMaxRequestId& message); quiche::QuicheBuffer SerializeFetch(const MoqtFetch& message); quiche::QuicheBuffer SerializeFetchCancel(const MoqtFetchCancel& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc index db3252b..1d9d547 100644 --- a/quiche/quic/moqt/moqt_framer_test.cc +++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -47,10 +47,10 @@ MoqtMessageType::kAnnounceError, MoqtMessageType::kUnannounce, MoqtMessageType::kGoAway, - MoqtMessageType::kSubscribeAnnounces, - MoqtMessageType::kSubscribeAnnouncesOk, - MoqtMessageType::kSubscribeAnnouncesError, - MoqtMessageType::kUnsubscribeAnnounces, + MoqtMessageType::kSubscribeNamespace, + MoqtMessageType::kSubscribeNamespaceOk, + MoqtMessageType::kSubscribeNamespaceError, + MoqtMessageType::kUnsubscribeNamespace, MoqtMessageType::kMaxRequestId, MoqtMessageType::kFetch, MoqtMessageType::kFetchCancel, @@ -170,21 +170,21 @@ auto data = std::get<MoqtGoAway>(structured_data); return framer_.SerializeGoAway(data); } - case moqt::MoqtMessageType::kSubscribeAnnounces: { - auto data = std::get<MoqtSubscribeAnnounces>(structured_data); - return framer_.SerializeSubscribeAnnounces(data); + case moqt::MoqtMessageType::kSubscribeNamespace: { + auto data = std::get<MoqtSubscribeNamespace>(structured_data); + return framer_.SerializeSubscribeNamespace(data); } - case moqt::MoqtMessageType::kSubscribeAnnouncesOk: { - auto data = std::get<MoqtSubscribeAnnouncesOk>(structured_data); - return framer_.SerializeSubscribeAnnouncesOk(data); + case moqt::MoqtMessageType::kSubscribeNamespaceOk: { + auto data = std::get<MoqtSubscribeNamespaceOk>(structured_data); + return framer_.SerializeSubscribeNamespaceOk(data); } - case moqt::MoqtMessageType::kSubscribeAnnouncesError: { - auto data = std::get<MoqtSubscribeAnnouncesError>(structured_data); - return framer_.SerializeSubscribeAnnouncesError(data); + case moqt::MoqtMessageType::kSubscribeNamespaceError: { + auto data = std::get<MoqtSubscribeNamespaceError>(structured_data); + return framer_.SerializeSubscribeNamespaceError(data); } - case moqt::MoqtMessageType::kUnsubscribeAnnounces: { - auto data = std::get<MoqtUnsubscribeAnnounces>(structured_data); - return framer_.SerializeUnsubscribeAnnounces(data); + case moqt::MoqtMessageType::kUnsubscribeNamespace: { + auto data = std::get<MoqtUnsubscribeNamespace>(structured_data); + return framer_.SerializeUnsubscribeNamespace(data); } case moqt::MoqtMessageType::kMaxRequestId: { auto data = std::get<MoqtMaxRequestId>(structured_data);
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc index 81f41a5..64e706e 100644 --- a/quiche/quic/moqt/moqt_messages.cc +++ b/quiche/quic/moqt/moqt_messages.cc
@@ -175,7 +175,7 @@ const std::array<MoqtMessageType, 8> kAllowsAuthorization = { MoqtMessageType::kClientSetup, MoqtMessageType::kServerSetup, - MoqtMessageType::kSubscribe, MoqtMessageType::kSubscribeAnnounces, + MoqtMessageType::kSubscribe, MoqtMessageType::kSubscribeNamespace, MoqtMessageType::kAnnounce, MoqtMessageType::kTrackStatusRequest, MoqtMessageType::kFetch, MoqtMessageType::kPublish}; const std::array<MoqtMessageType, 6> kAllowsDeliveryTimeout = { @@ -246,13 +246,13 @@ return "UNANNOUNCE"; case MoqtMessageType::kGoAway: return "GOAWAY"; - case MoqtMessageType::kSubscribeAnnounces: + case MoqtMessageType::kSubscribeNamespace: return "SUBSCRIBE_NAMESPACE"; - case MoqtMessageType::kSubscribeAnnouncesOk: + case MoqtMessageType::kSubscribeNamespaceOk: return "SUBSCRIBE_NAMESPACE_OK"; - case MoqtMessageType::kSubscribeAnnouncesError: + case MoqtMessageType::kSubscribeNamespaceError: return "SUBSCRIBE_NAMESPACE_ERROR"; - case MoqtMessageType::kUnsubscribeAnnounces: + case MoqtMessageType::kUnsubscribeNamespace: return "UNSUBSCRIBE_NAMESPACE"; case MoqtMessageType::kMaxRequestId: return "MAX_REQUEST_ID";
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h index 175508b..2838975 100644 --- a/quiche/quic/moqt/moqt_messages.h +++ b/quiche/quic/moqt/moqt_messages.h
@@ -243,10 +243,10 @@ kTrackStatusRequest = 0x0d, kTrackStatus = 0x0e, kGoAway = 0x10, - kSubscribeAnnounces = 0x11, - kSubscribeAnnouncesOk = 0x12, - kSubscribeAnnouncesError = 0x13, - kUnsubscribeAnnounces = 0x14, + kSubscribeNamespace = 0x11, + kSubscribeNamespaceOk = 0x12, + kSubscribeNamespaceError = 0x13, + kUnsubscribeNamespace = 0x14, kMaxRequestId = 0x15, kFetch = 0x16, kFetchCancel = 0x17, @@ -340,7 +340,7 @@ }; // Used for SUBSCRIBE_ERROR, ANNOUNCE_ERROR, ANNOUNCE_CANCEL, -// SUBSCRIBE_ANNOUNCES_ERROR, and FETCH_ERROR. +// SUBSCRIBE_NAMESPACE_ERROR, and FETCH_ERROR. enum class QUICHE_EXPORT RequestErrorCode : uint64_t { kInternalError = 0x0, kUnauthorized = 0x1, @@ -348,9 +348,9 @@ kNotSupported = 0x3, kTrackDoesNotExist = 0x4, // SUBSCRIBE_ERROR and FETCH_ERROR only. kUninterested = 0x4, // ANNOUNCE_ERROR and ANNOUNCE_CANCEL only. - kNamespacePrefixUnknown = 0x4, // SUBSCRIBE_ANNOUNCES_ERROR only. + kNamespacePrefixUnknown = 0x4, // SUBSCRIBE_NAMESPACE_ERROR only. kInvalidRange = 0x5, // SUBSCRIBE_ERROR and FETCH_ERROR only. - kNamespacePrefixOverlap = 0x5, // SUBSCRIBE_ANNOUNCES_ERROR only. + kNamespacePrefixOverlap = 0x5, // SUBSCRIBE_NAMESPACE_ERROR only. kNoObjects = 0x6, // FETCH_ERROR only. kInvalidJoiningRequestId = 0x7, // FETCH_ERROR only. kUnknownStatusInRange = 0x8, // FETCH_ERROR only. @@ -763,23 +763,23 @@ std::string new_session_uri; }; -struct QUICHE_EXPORT MoqtSubscribeAnnounces { +struct QUICHE_EXPORT MoqtSubscribeNamespace { uint64_t request_id; TrackNamespace track_namespace; VersionSpecificParameters parameters; }; -struct QUICHE_EXPORT MoqtSubscribeAnnouncesOk { +struct QUICHE_EXPORT MoqtSubscribeNamespaceOk { uint64_t request_id; }; -struct QUICHE_EXPORT MoqtSubscribeAnnouncesError { +struct QUICHE_EXPORT MoqtSubscribeNamespaceError { uint64_t request_id; RequestErrorCode error_code; std::string error_reason; }; -struct QUICHE_EXPORT MoqtUnsubscribeAnnounces { +struct QUICHE_EXPORT MoqtUnsubscribeNamespace { TrackNamespace track_namespace; };
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc index eacc152..e7f4a7d 100644 --- a/quiche/quic/moqt/moqt_parser.cc +++ b/quiche/quic/moqt/moqt_parser.cc
@@ -261,17 +261,17 @@ case MoqtMessageType::kGoAway: bytes_read = ProcessGoAway(reader); break; - case MoqtMessageType::kSubscribeAnnounces: - bytes_read = ProcessSubscribeAnnounces(reader); + case MoqtMessageType::kSubscribeNamespace: + bytes_read = ProcessSubscribeNamespace(reader); break; - case MoqtMessageType::kSubscribeAnnouncesOk: - bytes_read = ProcessSubscribeAnnouncesOk(reader); + case MoqtMessageType::kSubscribeNamespaceOk: + bytes_read = ProcessSubscribeNamespaceOk(reader); break; - case MoqtMessageType::kSubscribeAnnouncesError: - bytes_read = ProcessSubscribeAnnouncesError(reader); + case MoqtMessageType::kSubscribeNamespaceError: + bytes_read = ProcessSubscribeNamespaceError(reader); break; - case MoqtMessageType::kUnsubscribeAnnounces: - bytes_read = ProcessUnsubscribeAnnounces(reader); + case MoqtMessageType::kUnsubscribeNamespace: + bytes_read = ProcessUnsubscribeNamespace(reader); break; case MoqtMessageType::kMaxRequestId: bytes_read = ProcessMaxRequestId(reader); @@ -691,9 +691,9 @@ return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessSubscribeAnnounces( +size_t MoqtControlParser::ProcessSubscribeNamespace( quic::QuicDataReader& reader) { - MoqtSubscribeAnnounces subscribe_announces; + MoqtSubscribeNamespace subscribe_announces; if (!reader.ReadVarInt62(&subscribe_announces.request_id) || !ReadTrackNamespace(reader, subscribe_announces.track_namespace)) { return 0; @@ -703,31 +703,31 @@ return 0; } if (!ValidateVersionSpecificParameters( - parameters, MoqtMessageType::kSubscribeAnnounces)) { - ParseError("SUBSCRIBE_ANNOUNCES message contains invalid parameters"); + parameters, MoqtMessageType::kSubscribeNamespace)) { + ParseError("SUBSCRIBE_NAMESPACE message contains invalid parameters"); return 0; } if (!KeyValuePairListToVersionSpecificParameters( parameters, subscribe_announces.parameters)) { return 0; } - visitor_.OnSubscribeAnnouncesMessage(subscribe_announces); + visitor_.OnSubscribeNamespaceMessage(subscribe_announces); return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessSubscribeAnnouncesOk( +size_t MoqtControlParser::ProcessSubscribeNamespaceOk( quic::QuicDataReader& reader) { - MoqtSubscribeAnnouncesOk subscribe_namespace_ok; + MoqtSubscribeNamespaceOk subscribe_namespace_ok; if (!reader.ReadVarInt62(&subscribe_namespace_ok.request_id)) { return 0; } - visitor_.OnSubscribeAnnouncesOkMessage(subscribe_namespace_ok); + visitor_.OnSubscribeNamespaceOkMessage(subscribe_namespace_ok); return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessSubscribeAnnouncesError( +size_t MoqtControlParser::ProcessSubscribeNamespaceError( quic::QuicDataReader& reader) { - MoqtSubscribeAnnouncesError subscribe_namespace_error; + MoqtSubscribeNamespaceError subscribe_namespace_error; uint64_t error_code; if (!reader.ReadVarInt62(&subscribe_namespace_error.request_id) || !reader.ReadVarInt62(&error_code) || @@ -736,17 +736,17 @@ } subscribe_namespace_error.error_code = static_cast<RequestErrorCode>(error_code); - visitor_.OnSubscribeAnnouncesErrorMessage(subscribe_namespace_error); + visitor_.OnSubscribeNamespaceErrorMessage(subscribe_namespace_error); return reader.PreviouslyReadPayload().length(); } -size_t MoqtControlParser::ProcessUnsubscribeAnnounces( +size_t MoqtControlParser::ProcessUnsubscribeNamespace( quic::QuicDataReader& reader) { - MoqtUnsubscribeAnnounces unsubscribe_namespace; + MoqtUnsubscribeNamespace unsubscribe_namespace; if (!ReadTrackNamespace(reader, unsubscribe_namespace.track_namespace)) { return 0; } - visitor_.OnUnsubscribeAnnouncesMessage(unsubscribe_namespace); + visitor_.OnUnsubscribeNamespaceMessage(unsubscribe_namespace); return reader.PreviouslyReadPayload().length(); }
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h index d56c394..f331b9f 100644 --- a/quiche/quic/moqt/moqt_parser.h +++ b/quiche/quic/moqt/moqt_parser.h
@@ -49,14 +49,14 @@ virtual void OnUnannounceMessage(const MoqtUnannounce& message) = 0; virtual void OnTrackStatusMessage(const MoqtTrackStatus& message) = 0; virtual void OnGoAwayMessage(const MoqtGoAway& message) = 0; - virtual void OnSubscribeAnnouncesMessage( - const MoqtSubscribeAnnounces& message) = 0; - virtual void OnSubscribeAnnouncesOkMessage( - const MoqtSubscribeAnnouncesOk& message) = 0; - virtual void OnSubscribeAnnouncesErrorMessage( - const MoqtSubscribeAnnouncesError& message) = 0; - virtual void OnUnsubscribeAnnouncesMessage( - const MoqtUnsubscribeAnnounces& message) = 0; + virtual void OnSubscribeNamespaceMessage( + const MoqtSubscribeNamespace& message) = 0; + virtual void OnSubscribeNamespaceOkMessage( + const MoqtSubscribeNamespaceOk& message) = 0; + virtual void OnSubscribeNamespaceErrorMessage( + const MoqtSubscribeNamespaceError& message) = 0; + virtual void OnUnsubscribeNamespaceMessage( + const MoqtUnsubscribeNamespace& message) = 0; virtual void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) = 0; virtual void OnFetchMessage(const MoqtFetch& message) = 0; virtual void OnFetchCancelMessage(const MoqtFetchCancel& message) = 0; @@ -126,10 +126,10 @@ size_t ProcessUnannounce(quic::QuicDataReader& reader); size_t ProcessTrackStatus(quic::QuicDataReader& reader); size_t ProcessGoAway(quic::QuicDataReader& reader); - size_t ProcessSubscribeAnnounces(quic::QuicDataReader& reader); - size_t ProcessSubscribeAnnouncesOk(quic::QuicDataReader& reader); - size_t ProcessSubscribeAnnouncesError(quic::QuicDataReader& reader); - size_t ProcessUnsubscribeAnnounces(quic::QuicDataReader& reader); + size_t ProcessSubscribeNamespace(quic::QuicDataReader& reader); + size_t ProcessSubscribeNamespaceOk(quic::QuicDataReader& reader); + size_t ProcessSubscribeNamespaceError(quic::QuicDataReader& reader); + size_t ProcessUnsubscribeNamespace(quic::QuicDataReader& reader); size_t ProcessMaxRequestId(quic::QuicDataReader& reader); size_t ProcessFetch(quic::QuicDataReader& reader); size_t ProcessFetchCancel(quic::QuicDataReader& reader);
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc index dafe27c..1ef7ec5 100644 --- a/quiche/quic/moqt/moqt_parser_test.cc +++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -48,10 +48,10 @@ MoqtMessageType::kClientSetup, MoqtMessageType::kServerSetup, MoqtMessageType::kGoAway, - MoqtMessageType::kSubscribeAnnounces, - MoqtMessageType::kSubscribeAnnouncesOk, - MoqtMessageType::kSubscribeAnnouncesError, - MoqtMessageType::kUnsubscribeAnnounces, + MoqtMessageType::kSubscribeNamespace, + MoqtMessageType::kSubscribeNamespaceOk, + MoqtMessageType::kSubscribeNamespaceError, + MoqtMessageType::kUnsubscribeNamespace, MoqtMessageType::kMaxRequestId, MoqtMessageType::kFetch, MoqtMessageType::kFetchCancel,
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc index b41d74e..dcdee31 100644 --- a/quiche/quic/moqt/moqt_session.cc +++ b/quiche/quic/moqt/moqt_session.cc
@@ -253,14 +253,14 @@ std::move(callbacks_.session_terminated_callback)(error); } -bool MoqtSession::SubscribeAnnounces( +bool MoqtSession::SubscribeNamespace( TrackNamespace track_namespace, - MoqtOutgoingSubscribeAnnouncesCallback callback, + MoqtOutgoingSubscribeNamespaceCallback callback, VersionSpecificParameters parameters) { QUICHE_DCHECK(track_namespace.IsValid()); if (received_goaway_ || sent_goaway_) { QUIC_DLOG(INFO) << ENDPOINT - << "Tried to send SUBSCRIBE_ANNOUNCES after GOAWAY"; + << "Tried to send SUBSCRIBE_NAMESPACE after GOAWAY"; return false; } if (next_request_id_ >= peer_max_request_id_) { @@ -271,7 +271,7 @@ SendControlMessage(framer_.SerializeRequestsBlocked(requests_blocked)); last_requests_blocked_sent_ = peer_max_request_id_; } - QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE_ANNOUNCES with ID " + QUIC_DLOG(INFO) << ENDPOINT << "Tried to send SUBSCRIBE_NAMESPACE with ID " << next_request_id_ << " which is greater than the maximum ID " << peer_max_request_id_; @@ -280,32 +280,32 @@ if (outgoing_subscribe_announces_.contains(track_namespace)) { std::move(callback)( track_namespace, RequestErrorCode::kInternalError, - "SUBSCRIBE_ANNOUNCES already outstanding for namespace"); + "SUBSCRIBE_NAMESPACE already outstanding for namespace"); return false; } - MoqtSubscribeAnnounces message; + MoqtSubscribeNamespace message; message.request_id = next_request_id_; next_request_id_ += 2; message.track_namespace = track_namespace; message.parameters = parameters; - SendControlMessage(framer_.SerializeSubscribeAnnounces(message)); - QUIC_DLOG(INFO) << ENDPOINT << "Sent SUBSCRIBE_ANNOUNCES message for " + SendControlMessage(framer_.SerializeSubscribeNamespace(message)); + QUIC_DLOG(INFO) << ENDPOINT << "Sent SUBSCRIBE_NAMESPACE message for " << message.track_namespace; pending_outgoing_subscribe_announces_[message.request_id] = - PendingSubscribeAnnouncesData{track_namespace, std::move(callback)}; + PendingSubscribeNamespaceData{track_namespace, std::move(callback)}; outgoing_subscribe_announces_.emplace(track_namespace); return true; } -bool MoqtSession::UnsubscribeAnnounces(TrackNamespace track_namespace) { +bool MoqtSession::UnsubscribeNamespace(TrackNamespace track_namespace) { QUICHE_DCHECK(track_namespace.IsValid()); if (!outgoing_subscribe_announces_.contains(track_namespace)) { return false; } - MoqtUnsubscribeAnnounces message; + MoqtUnsubscribeNamespace message; message.track_namespace = track_namespace; - SendControlMessage(framer_.SerializeUnsubscribeAnnounces(message)); - QUIC_DLOG(INFO) << ENDPOINT << "Sent UNSUBSCRIBE_ANNOUNCES message for " + SendControlMessage(framer_.SerializeUnsubscribeNamespace(message)); + QUIC_DLOG(INFO) << ENDPOINT << "Sent UNSUBSCRIBE_NAMESPACE message for " << message.track_namespace; outgoing_subscribe_announces_.erase(track_namespace); return true; @@ -1334,77 +1334,77 @@ } } -void MoqtSession::ControlStream::OnSubscribeAnnouncesMessage( - const MoqtSubscribeAnnounces& message) { +void MoqtSession::ControlStream::OnSubscribeNamespaceMessage( + const MoqtSubscribeNamespace& message) { if (!session_->ValidateRequestId(message.request_id)) { return; } // TODO(martinduke): Handle authentication. if (session_->sent_goaway_) { QUIC_DLOG(INFO) << ENDPOINT - << "Received a SUBSCRIBE_ANNOUNCES after GOAWAY"; - MoqtSubscribeAnnouncesError error; + << "Received a SUBSCRIBE_NAMESPACE after GOAWAY"; + MoqtSubscribeNamespaceError error; error.request_id = message.request_id; error.error_code = RequestErrorCode::kUnauthorized; - error.error_reason = "SUBSCRIBE_ANNOUNCES after GOAWAY"; + error.error_reason = "SUBSCRIBE_NAMESPACE after GOAWAY"; SendOrBufferMessage( - session_->framer_.SerializeSubscribeAnnouncesError(error)); + session_->framer_.SerializeSubscribeNamespaceError(error)); return; } if (!session_->incoming_subscribe_announces_.AddNamespace( message.track_namespace)) { - QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE_ANNOUNCES for " + QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE_NAMESPACE for " << message.track_namespace << " that is already subscribed to"; - MoqtSubscribeAnnouncesError error; + MoqtSubscribeNamespaceError error; error.request_id = message.request_id; error.error_code = RequestErrorCode::kNamespacePrefixOverlap; - error.error_reason = "SUBSCRIBE_ANNOUNCES for similar subscribed namespace"; + error.error_reason = "SUBSCRIBE_NAMESPACE for similar subscribed namespace"; SendOrBufferMessage( - session_->framer_.SerializeSubscribeAnnouncesError(error)); + session_->framer_.SerializeSubscribeNamespaceError(error)); return; } std::optional<MoqtSubscribeErrorReason> result = session_->callbacks_.incoming_subscribe_announces_callback( message.track_namespace, message.parameters); if (result.has_value()) { - MoqtSubscribeAnnouncesError error; + MoqtSubscribeNamespaceError error; error.request_id = message.request_id; error.error_code = result->error_code; error.error_reason = result->reason_phrase; SendOrBufferMessage( - session_->framer_.SerializeSubscribeAnnouncesError(error)); + session_->framer_.SerializeSubscribeNamespaceError(error)); session_->incoming_subscribe_announces_.RemoveNamespace( message.track_namespace); return; } - MoqtSubscribeAnnouncesOk ok; + MoqtSubscribeNamespaceOk ok; ok.request_id = message.request_id; - SendOrBufferMessage(session_->framer_.SerializeSubscribeAnnouncesOk(ok)); + SendOrBufferMessage(session_->framer_.SerializeSubscribeNamespaceOk(ok)); } -void MoqtSession::ControlStream::OnSubscribeAnnouncesOkMessage( - const MoqtSubscribeAnnouncesOk& message) { +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_->Error(MoqtError::kProtocolViolation, - "Received SUBSCRIBE_ANNOUNCES_OK for unknown request_id"); - return; // UNSUBSCRIBE_ANNOUNCES may already have deleted the entry. + "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); } -void MoqtSession::ControlStream::OnSubscribeAnnouncesErrorMessage( - const MoqtSubscribeAnnouncesError& message) { +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_->Error( MoqtError::kProtocolViolation, - "Received SUBSCRIBE_ANNOUNCES_ERROR for unknown request_id"); - return; // UNSUBSCRIBE_ANNOUNCES may already have deleted the entry. + "Received SUBSCRIBE_NAMESPACE_ERROR for unknown request_id"); + return; // UNSUBSCRIBE_NAMESPACE may already have deleted the entry. } std::move(it->second.callback)(it->second.track_namespace, message.error_code, absl::string_view(message.error_reason)); @@ -1412,8 +1412,8 @@ session_->pending_outgoing_subscribe_announces_.erase(it); } -void MoqtSession::ControlStream::OnUnsubscribeAnnouncesMessage( - const MoqtUnsubscribeAnnounces& message) { +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(
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h index 2467d41..252267e 100644 --- a/quiche/quic/moqt/moqt_session.h +++ b/quiche/quic/moqt/moqt_session.h
@@ -98,10 +98,10 @@ quic::Perspective perspective() const { return parameters_.perspective; } // Returns true if message was sent. - bool SubscribeAnnounces(TrackNamespace track_namespace, - MoqtOutgoingSubscribeAnnouncesCallback callback, + bool SubscribeNamespace(TrackNamespace track_namespace, + MoqtOutgoingSubscribeNamespaceCallback callback, VersionSpecificParameters parameters); - bool UnsubscribeAnnounces(TrackNamespace track_namespace); + bool UnsubscribeNamespace(TrackNamespace track_namespace); // Send an ANNOUNCE message for |track_namespace|, and call // |announce_callback| when the response arrives. Will fail immediately if @@ -256,14 +256,14 @@ void OnUnannounceMessage(const MoqtUnannounce& /*message*/) override; void OnTrackStatusMessage(const MoqtTrackStatus& message) override {} void OnGoAwayMessage(const MoqtGoAway& /*message*/) override; - void OnSubscribeAnnouncesMessage( - const MoqtSubscribeAnnounces& message) override; - void OnSubscribeAnnouncesOkMessage( - const MoqtSubscribeAnnouncesOk& message) override; - void OnSubscribeAnnouncesErrorMessage( - const MoqtSubscribeAnnouncesError& message) override; - void OnUnsubscribeAnnouncesMessage( - const MoqtUnsubscribeAnnounces& message) override; + void OnSubscribeNamespaceMessage( + const MoqtSubscribeNamespace& message) override; + void OnSubscribeNamespaceOkMessage( + const MoqtSubscribeNamespaceOk& message) override; + void OnSubscribeNamespaceErrorMessage( + const MoqtSubscribeNamespaceError& message) override; + void OnUnsubscribeNamespaceMessage( + const MoqtUnsubscribeNamespace& message) override; void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) override; void OnFetchMessage(const MoqtFetch& message) override; void OnFetchCancelMessage(const MoqtFetchCancel& message) override {} @@ -838,14 +838,14 @@ outgoing_announces_; // The value is nullptr after OK or ERROR is received. The entry is deleted - // when sending UNSUBSCRIBE_ANNOUNCES, to make sure the application doesn't + // 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. - struct PendingSubscribeAnnouncesData { + struct PendingSubscribeNamespaceData { TrackNamespace track_namespace; - MoqtOutgoingSubscribeAnnouncesCallback callback; + MoqtOutgoingSubscribeNamespaceCallback callback; }; - absl::flat_hash_map<uint64_t, PendingSubscribeAnnouncesData> + absl::flat_hash_map<uint64_t, PendingSubscribeNamespaceData> pending_outgoing_subscribe_announces_; absl::flat_hash_set<TrackNamespace> outgoing_subscribe_announces_; // It's an error if the namespaces overlap, so keep track of them.
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h index 447bc00..cc0a35c 100644 --- a/quiche/quic/moqt/moqt_session_callbacks.h +++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -36,12 +36,12 @@ const TrackNamespace& track_namespace, const std::optional<VersionSpecificParameters>& parameters)>; -// Called whenever SUBSCRIBE_ANNOUNCES or UNSUBSCRIBE_ANNOUNCES is received from -// the peer. For SUBSCRIBE_ANNOUNCES, the return value indicates whether to -// return an OK or an ERROR; for UNSUBSCRIBE_ANNOUNCES, the return value is -// ignored. SUBSCRIBE_ANNOUNCES sets a value for |parameters|, -// UNSUBSCRIBE_ANNOUNCES does not. -using MoqtIncomingSubscribeAnnouncesCallback = +// Called whenever SUBSCRIBE_NAMESPACE or UNSUBSCRIBE_NAMESPACE is received from +// the peer. For SUBSCRIBE_NAMESPACE, the return value indicates whether to +// return an OK or an ERROR; for UNSUBSCRIBE_NAMESPACE, the return value is +// ignored. SUBSCRIBE_NAMESPACE sets a value for |parameters|, +// UNSUBSCRIBE_NAMESPACE does not. +using MoqtIncomingSubscribeNamespaceCallback = quiche::MultiUseCallback<std::optional<MoqtSubscribeErrorReason>( const TrackNamespace& track_namespace, std::optional<VersionSpecificParameters> parameters)>; @@ -55,12 +55,12 @@ }; inline std::optional<MoqtSubscribeErrorReason> -DefaultIncomingSubscribeAnnouncesCallback( +DefaultIncomingSubscribeNamespaceCallback( const TrackNamespace& track_namespace, std::optional<VersionSpecificParameters> /*parameters*/) { return MoqtSubscribeErrorReason{ RequestErrorCode::kNotSupported, - "This endpoint does not support incoming SUBSCRIBE_ANNOUNCES messages"}; + "This endpoint does not support incoming SUBSCRIBE_NAMESPACE messages"}; } // Callbacks for session-level events. @@ -74,8 +74,8 @@ MoqtIncomingAnnounceCallback incoming_announce_callback = DefaultIncomingAnnounceCallback; - MoqtIncomingSubscribeAnnouncesCallback incoming_subscribe_announces_callback = - DefaultIncomingSubscribeAnnouncesCallback; + MoqtIncomingSubscribeNamespaceCallback incoming_subscribe_announces_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 6846c96..a6c0c46 100644 --- a/quiche/quic/moqt/moqt_session_interface.h +++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -26,7 +26,7 @@ TrackNamespace track_namespace, std::optional<MoqtAnnounceErrorReason> error)>; -using MoqtOutgoingSubscribeAnnouncesCallback = quiche::SingleUseCallback<void( +using MoqtOutgoingSubscribeNamespaceCallback = quiche::SingleUseCallback<void( TrackNamespace track_namespace, std::optional<RequestErrorCode> error, absl::string_view reason)>; @@ -110,7 +110,7 @@ // TODO(martinduke): Add an API for absolute joining fetch. - // TODO: Add SubscribeAnnounces, UnsubscribeAnnounces method. + // TODO: Add SubscribeNamespace, UnsubscribeNamespace method. // TODO: Add Announce, Unannounce method. // TODO: Add AnnounceCancel method. // TODO: Add TrackStatusRequest method.
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc index c290db0..adfb917 100644 --- a/quiche/quic/moqt/moqt_session_test.cc +++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -1009,15 +1009,15 @@ stream_input->OnAnnounceMessage(announce); } -TEST_F(MoqtSessionTest, SubscribeAnnouncesLifeCycle) { +TEST_F(MoqtSessionTest, SubscribeNamespaceLifeCycle) { std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); TrackNamespace track_namespace("foo"); bool got_callback = false; EXPECT_CALL( mock_stream_, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _)); - session_.SubscribeAnnounces( + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespace), _)); + session_.SubscribeNamespace( track_namespace, [&](const TrackNamespace& ns, std::optional<RequestErrorCode> error, absl::string_view reason) { @@ -1027,27 +1027,27 @@ EXPECT_EQ(reason, ""); }, VersionSpecificParameters()); - MoqtSubscribeAnnouncesOk ok = { + MoqtSubscribeNamespaceOk ok = { kDefaultLocalRequestId, }; - stream_input->OnSubscribeAnnouncesOkMessage(ok); + stream_input->OnSubscribeNamespaceOkMessage(ok); EXPECT_TRUE(got_callback); EXPECT_CALL( mock_stream_, - Writev(ControlMessageOfType(MoqtMessageType::kUnsubscribeAnnounces), _)); - EXPECT_TRUE(session_.UnsubscribeAnnounces(track_namespace)); - EXPECT_FALSE(session_.UnsubscribeAnnounces(track_namespace)); + Writev(ControlMessageOfType(MoqtMessageType::kUnsubscribeNamespace), _)); + EXPECT_TRUE(session_.UnsubscribeNamespace(track_namespace)); + EXPECT_FALSE(session_.UnsubscribeNamespace(track_namespace)); } -TEST_F(MoqtSessionTest, SubscribeAnnouncesError) { +TEST_F(MoqtSessionTest, SubscribeNamespaceError) { std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); TrackNamespace track_namespace("foo"); bool got_callback = false; EXPECT_CALL( mock_stream_, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _)); - session_.SubscribeAnnounces( + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespace), _)); + session_.SubscribeNamespace( track_namespace, [&](const TrackNamespace& ns, std::optional<RequestErrorCode> error, absl::string_view reason) { @@ -1058,15 +1058,15 @@ EXPECT_EQ(reason, "deadbeef"); }, VersionSpecificParameters()); - MoqtSubscribeAnnouncesError error = { + MoqtSubscribeNamespaceError error = { kDefaultLocalRequestId, RequestErrorCode::kInvalidRange, /*reason_phrase=*/"deadbeef", }; - stream_input->OnSubscribeAnnouncesErrorMessage(error); + stream_input->OnSubscribeNamespaceErrorMessage(error); EXPECT_TRUE(got_callback); // Entry is immediately gone. - EXPECT_FALSE(session_.UnsubscribeAnnounces(track_namespace)); + EXPECT_FALSE(session_.UnsubscribeNamespace(track_namespace)); } TEST_F(MoqtSessionTest, IncomingObject) { @@ -2711,11 +2711,11 @@ data_stream.Receive("foo", false); } -TEST_F(MoqtSessionTest, IncomingSubscribeAnnounces) { +TEST_F(MoqtSessionTest, IncomingSubscribeNamespace) { TrackNamespace track_namespace = TrackNamespace{"foo"}; auto parameters = std::make_optional<VersionSpecificParameters>( AuthTokenType::kOutOfBand, "foo"); - MoqtSubscribeAnnounces announces = { + MoqtSubscribeNamespace announces = { /*request_id=*/1, track_namespace, *parameters, @@ -2728,22 +2728,22 @@ .WillOnce(Return(std::nullopt)); EXPECT_CALL( control_stream, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _)); - stream_input->OnSubscribeAnnouncesMessage(announces); - MoqtUnsubscribeAnnounces unsubscribe_announces = { + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _)); + stream_input->OnSubscribeNamespaceMessage(announces); + MoqtUnsubscribeNamespace unsubscribe_announces = { TrackNamespace{"foo"}, }; EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback, Call(track_namespace, std::optional<VersionSpecificParameters>())) .WillOnce(Return(std::nullopt)); - stream_input->OnUnsubscribeAnnouncesMessage(unsubscribe_announces); + stream_input->OnUnsubscribeNamespaceMessage(unsubscribe_announces); } -TEST_F(MoqtSessionTest, IncomingSubscribeAnnouncesWithError) { +TEST_F(MoqtSessionTest, IncomingSubscribeNamespaceWithError) { TrackNamespace track_namespace{"foo"}; auto parameters = std::make_optional<VersionSpecificParameters>( AuthTokenType::kOutOfBand, "foo"); - MoqtSubscribeAnnounces announces = { + MoqtSubscribeNamespace announces = { /*request_id=*/1, track_namespace, *parameters, @@ -2757,9 +2757,9 @@ MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"})); EXPECT_CALL( control_stream, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError), + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError), _)); - stream_input->OnSubscribeAnnouncesMessage(announces); + stream_input->OnSubscribeNamespaceMessage(announces); // Try again, to verify that it was purged from the tree. announces.request_id += 2; @@ -2768,15 +2768,15 @@ .WillOnce(Return(std::nullopt)); EXPECT_CALL( control_stream, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _)); - stream_input->OnSubscribeAnnouncesMessage(announces); + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _)); + stream_input->OnSubscribeNamespaceMessage(announces); } -TEST_F(MoqtSessionTest, IncomingSubscribeAnnouncesWithPrefixOverlap) { +TEST_F(MoqtSessionTest, IncomingSubscribeNamespaceWithPrefixOverlap) { TrackNamespace track_namespace{"foo"}; auto parameters = std::make_optional<VersionSpecificParameters>( AuthTokenType::kOutOfBand, "foo"); - MoqtSubscribeAnnounces announces = { + MoqtSubscribeNamespace announces = { /*request_id=*/1, track_namespace, *parameters, @@ -2789,26 +2789,26 @@ .WillOnce(Return(std::nullopt)); EXPECT_CALL( control_stream, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _)); - stream_input->OnSubscribeAnnouncesMessage(announces); + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _)); + stream_input->OnSubscribeNamespaceMessage(announces); // Overlapping request is rejected. announces.request_id += 2; announces.track_namespace = TrackNamespace{"foo", "bar"}; EXPECT_CALL( control_stream, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError), + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError), _)); - stream_input->OnSubscribeAnnouncesMessage(announces); + stream_input->OnSubscribeNamespaceMessage(announces); // Remove the subscription. Now a later one will work. - MoqtUnsubscribeAnnounces unsubscribe_announces = { + MoqtUnsubscribeNamespace unsubscribe_announces = { TrackNamespace{"foo"}, }; EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback, Call(track_namespace, std::optional<VersionSpecificParameters>())) .WillOnce(Return(std::nullopt)); - stream_input->OnUnsubscribeAnnouncesMessage(unsubscribe_announces); + stream_input->OnUnsubscribeNamespaceMessage(unsubscribe_announces); // Try again, it will work. announces.request_id += 2; @@ -2817,8 +2817,8 @@ .WillOnce(Return(std::nullopt)); EXPECT_CALL( control_stream, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesOk), _)); - stream_input->OnSubscribeAnnouncesMessage(announces); + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceOk), _)); + stream_input->OnSubscribeNamespaceMessage(announces); } TEST_F(MoqtSessionTest, FetchThenOkThenCancel) { @@ -3362,7 +3362,7 @@ EXPECT_FALSE(session_.SubscribeCurrentObject(FullTrackName("foo", "bar"), &remote_track_visitor, VersionSpecificParameters())); - EXPECT_FALSE(session_.SubscribeAnnounces( + EXPECT_FALSE(session_.SubscribeNamespace( TrackNamespace{"foo"}, +[](TrackNamespace /*track_namespace*/, std::optional<RequestErrorCode> /*error*/, @@ -3413,16 +3413,16 @@ stream_input->OnFetchMessage(fetch); EXPECT_CALL( mock_stream_, - Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError), + Writev(ControlMessageOfType(MoqtMessageType::kSubscribeNamespaceError), _)); - stream_input->OnSubscribeAnnouncesMessage(MoqtSubscribeAnnounces(7)); + stream_input->OnSubscribeNamespaceMessage(MoqtSubscribeNamespace(7)); // Block all outgoing SUBSCRIBE, ANNOUNCE, GOAWAY,etc. EXPECT_CALL(mock_stream_, Writev).Times(0); MockSubscribeRemoteTrackVisitor remote_track_visitor; EXPECT_FALSE(session_.SubscribeCurrentObject( FullTrackName(TrackNamespace("foo"), "bar"), &remote_track_visitor, VersionSpecificParameters())); - EXPECT_FALSE(session_.SubscribeAnnounces( + EXPECT_FALSE(session_.SubscribeNamespace( TrackNamespace{"foo"}, +[](TrackNamespace /*track_namespace*/, std::optional<RequestErrorCode> /*error*/,
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc index bc979d4..f6b14b4 100644 --- a/quiche/quic/moqt/test_tools/moqt_framer_utils.cc +++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.cc
@@ -74,17 +74,17 @@ MoqtMessageType operator()(const MoqtGoAway&) { return MoqtMessageType::kGoAway; } - MoqtMessageType operator()(const MoqtSubscribeAnnounces&) { - return MoqtMessageType::kSubscribeAnnounces; + MoqtMessageType operator()(const MoqtSubscribeNamespace&) { + return MoqtMessageType::kSubscribeNamespace; } - MoqtMessageType operator()(const MoqtSubscribeAnnouncesOk&) { - return MoqtMessageType::kSubscribeAnnouncesOk; + MoqtMessageType operator()(const MoqtSubscribeNamespaceOk&) { + return MoqtMessageType::kSubscribeNamespaceOk; } - MoqtMessageType operator()(const MoqtSubscribeAnnouncesError&) { - return MoqtMessageType::kSubscribeAnnouncesError; + MoqtMessageType operator()(const MoqtSubscribeNamespaceError&) { + return MoqtMessageType::kSubscribeNamespaceError; } - MoqtMessageType operator()(const MoqtUnsubscribeAnnounces&) { - return MoqtMessageType::kUnsubscribeAnnounces; + MoqtMessageType operator()(const MoqtUnsubscribeNamespace&) { + return MoqtMessageType::kUnsubscribeNamespace; } MoqtMessageType operator()(const MoqtMaxRequestId&) { return MoqtMessageType::kMaxRequestId; @@ -167,17 +167,17 @@ quiche::QuicheBuffer operator()(const MoqtGoAway& message) { return framer.SerializeGoAway(message); } - quiche::QuicheBuffer operator()(const MoqtSubscribeAnnounces& message) { - return framer.SerializeSubscribeAnnounces(message); + quiche::QuicheBuffer operator()(const MoqtSubscribeNamespace& message) { + return framer.SerializeSubscribeNamespace(message); } - quiche::QuicheBuffer operator()(const MoqtSubscribeAnnouncesOk& message) { - return framer.SerializeSubscribeAnnouncesOk(message); + quiche::QuicheBuffer operator()(const MoqtSubscribeNamespaceOk& message) { + return framer.SerializeSubscribeNamespaceOk(message); } - quiche::QuicheBuffer operator()(const MoqtSubscribeAnnouncesError& message) { - return framer.SerializeSubscribeAnnouncesError(message); + quiche::QuicheBuffer operator()(const MoqtSubscribeNamespaceError& message) { + return framer.SerializeSubscribeNamespaceError(message); } - quiche::QuicheBuffer operator()(const MoqtUnsubscribeAnnounces& message) { - return framer.SerializeUnsubscribeAnnounces(message); + quiche::QuicheBuffer operator()(const MoqtUnsubscribeNamespace& message) { + return framer.SerializeUnsubscribeNamespace(message); } quiche::QuicheBuffer operator()(const MoqtMaxRequestId& message) { return framer.SerializeMaxRequestId(message); @@ -266,17 +266,17 @@ void OnGoAwayMessage(const MoqtGoAway& message) { frames_.push_back(message); } - void OnSubscribeAnnouncesMessage(const MoqtSubscribeAnnounces& message) { + void OnSubscribeNamespaceMessage(const MoqtSubscribeNamespace& message) { frames_.push_back(message); } - void OnSubscribeAnnouncesOkMessage(const MoqtSubscribeAnnouncesOk& message) { + void OnSubscribeNamespaceOkMessage(const MoqtSubscribeNamespaceOk& message) { frames_.push_back(message); } - void OnSubscribeAnnouncesErrorMessage( - const MoqtSubscribeAnnouncesError& message) { + void OnSubscribeNamespaceErrorMessage( + const MoqtSubscribeNamespaceError& message) { frames_.push_back(message); } - void OnUnsubscribeAnnouncesMessage(const MoqtUnsubscribeAnnounces& message) { + void OnUnsubscribeNamespaceMessage(const MoqtUnsubscribeNamespace& message) { frames_.push_back(message); } void OnMaxRequestIdMessage(const MoqtMaxRequestId& message) {
diff --git a/quiche/quic/moqt/test_tools/moqt_framer_utils.h b/quiche/quic/moqt/test_tools/moqt_framer_utils.h index 1b6e996..54a704c 100644 --- a/quiche/quic/moqt/test_tools/moqt_framer_utils.h +++ b/quiche/quic/moqt/test_tools/moqt_framer_utils.h
@@ -31,8 +31,8 @@ MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel, MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus, - MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk, - MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces, + MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk, + MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish, MoqtPublishOk, MoqtPublishError, MoqtObjectAck>;
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 71ff1b3..c29edb6 100644 --- a/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h +++ b/quiche/quic/moqt/test_tools/moqt_parser_test_visitor.h
@@ -91,20 +91,20 @@ void OnGoAwayMessage(const MoqtGoAway& message) override { OnControlMessage(message); } - void OnSubscribeAnnouncesMessage( - const MoqtSubscribeAnnounces& message) override { + void OnSubscribeNamespaceMessage( + const MoqtSubscribeNamespace& message) override { OnControlMessage(message); } - void OnSubscribeAnnouncesOkMessage( - const MoqtSubscribeAnnouncesOk& message) override { + void OnSubscribeNamespaceOkMessage( + const MoqtSubscribeNamespaceOk& message) override { OnControlMessage(message); } - void OnSubscribeAnnouncesErrorMessage( - const MoqtSubscribeAnnouncesError& message) override { + void OnSubscribeNamespaceErrorMessage( + const MoqtSubscribeNamespaceError& message) override { OnControlMessage(message); } - void OnUnsubscribeAnnouncesMessage( - const MoqtUnsubscribeAnnounces& message) override { + void OnUnsubscribeNamespaceMessage( + const MoqtUnsubscribeNamespace& message) override { OnControlMessage(message); } void OnMaxRequestIdMessage(const MoqtMaxRequestId& 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 d954f18..5d17a47 100644 --- a/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc +++ b/quiche/quic/moqt/test_tools/moqt_simulator_harness.cc
@@ -40,7 +40,7 @@ return MoqtSessionCallbacks( +[] {}, +[](absl::string_view) {}, +[](absl::string_view) {}, +[] {}, DefaultIncomingAnnounceCallback, - DefaultIncomingSubscribeAnnouncesCallback, simulator->GetClock()); + 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 211b5e0..55edb39 100644 --- a/quiche/quic/moqt/test_tools/moqt_test_message.h +++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -67,8 +67,8 @@ MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel, MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus, - MoqtGoAway, MoqtSubscribeAnnounces, MoqtSubscribeAnnouncesOk, - MoqtSubscribeAnnouncesError, MoqtUnsubscribeAnnounces, + MoqtGoAway, MoqtSubscribeNamespace, MoqtSubscribeNamespaceOk, + MoqtSubscribeNamespaceError, MoqtUnsubscribeNamespace, MoqtMaxRequestId, MoqtFetch, MoqtFetchCancel, MoqtFetchOk, MoqtFetchError, MoqtRequestsBlocked, MoqtPublish, MoqtPublishOk, MoqtPublishError, MoqtObjectAck>; @@ -1255,14 +1255,14 @@ }; }; -class QUICHE_NO_EXPORT SubscribeAnnouncesMessage : public TestMessageBase { +class QUICHE_NO_EXPORT SubscribeNamespaceMessage : public TestMessageBase { public: - SubscribeAnnouncesMessage() : TestMessageBase() { + SubscribeNamespaceMessage() : TestMessageBase() { SetWireImage(raw_packet_, sizeof(raw_packet_)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtSubscribeAnnounces>(values); + auto cast = std::get<MoqtSubscribeNamespace>(values); if (cast.request_id != subscribe_namespace_.request_id) { QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE request_id mismatch"; return false; @@ -1292,21 +1292,21 @@ 0x03, 0x05, 0x03, 0x00, 0x62, 0x61, 0x72, // authorization_tag = "bar" }; - MoqtSubscribeAnnounces subscribe_namespace_ = { + MoqtSubscribeNamespace subscribe_namespace_ = { /*request_id=*/1, TrackNamespace("foo"), VersionSpecificParameters(AuthTokenType::kOutOfBand, "bar"), }; }; -class QUICHE_NO_EXPORT SubscribeAnnouncesOkMessage : public TestMessageBase { +class QUICHE_NO_EXPORT SubscribeNamespaceOkMessage : public TestMessageBase { public: - SubscribeAnnouncesOkMessage() : TestMessageBase() { + SubscribeNamespaceOkMessage() : TestMessageBase() { SetWireImage(raw_packet_, sizeof(raw_packet_)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtSubscribeAnnouncesOk>(values); + auto cast = std::get<MoqtSubscribeNamespaceOk>(values); if (cast.request_id != subscribe_namespace_ok_.request_id) { QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_OK request_id mismatch"; return false; @@ -1325,19 +1325,19 @@ 0x12, 0x00, 0x01, 0x01, // request_id = 1 }; - MoqtSubscribeAnnouncesOk subscribe_namespace_ok_ = { + MoqtSubscribeNamespaceOk subscribe_namespace_ok_ = { /*request_id=*/1, }; }; -class QUICHE_NO_EXPORT SubscribeAnnouncesErrorMessage : public TestMessageBase { +class QUICHE_NO_EXPORT SubscribeNamespaceErrorMessage : public TestMessageBase { public: - SubscribeAnnouncesErrorMessage() : TestMessageBase() { + SubscribeNamespaceErrorMessage() : TestMessageBase() { SetWireImage(raw_packet_, sizeof(raw_packet_)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtSubscribeAnnouncesError>(values); + auto cast = std::get<MoqtSubscribeNamespaceError>(values); if (cast.request_id != subscribe_namespace_error_.request_id) { QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR request_id mismatch"; return false; @@ -1366,21 +1366,21 @@ 0x03, 0x62, 0x61, 0x72, // error_reason = "bar" }; - MoqtSubscribeAnnouncesError subscribe_namespace_error_ = { + MoqtSubscribeNamespaceError subscribe_namespace_error_ = { /*request_id=*/1, /*error_code=*/RequestErrorCode::kUnauthorized, /*error_reason=*/"bar", }; }; -class QUICHE_NO_EXPORT UnsubscribeAnnouncesMessage : public TestMessageBase { +class QUICHE_NO_EXPORT UnsubscribeNamespaceMessage : public TestMessageBase { public: - UnsubscribeAnnouncesMessage() : TestMessageBase() { + UnsubscribeNamespaceMessage() : TestMessageBase() { SetWireImage(raw_packet_, sizeof(raw_packet_)); } bool EqualFieldValues(MessageStructuredData& values) const override { - auto cast = std::get<MoqtUnsubscribeAnnounces>(values); + auto cast = std::get<MoqtUnsubscribeNamespace>(values); if (cast.track_namespace != unsubscribe_namespace_.track_namespace) { QUIC_LOG(INFO) << "UNSUBSCRIBE_NAMESPACE track namespace mismatch"; return false; @@ -1399,7 +1399,7 @@ 0x14, 0x00, 0x05, 0x01, 0x03, 0x66, 0x6f, 0x6f, // track_namespace }; - MoqtUnsubscribeAnnounces unsubscribe_namespace_ = { + MoqtUnsubscribeNamespace unsubscribe_namespace_ = { TrackNamespace("foo"), }; }; @@ -2077,14 +2077,14 @@ return std::make_unique<TrackStatusMessage>(); case MoqtMessageType::kGoAway: return std::make_unique<GoAwayMessage>(); - case MoqtMessageType::kSubscribeAnnounces: - return std::make_unique<SubscribeAnnouncesMessage>(); - case MoqtMessageType::kSubscribeAnnouncesOk: - return std::make_unique<SubscribeAnnouncesOkMessage>(); - case MoqtMessageType::kSubscribeAnnouncesError: - return std::make_unique<SubscribeAnnouncesErrorMessage>(); - case MoqtMessageType::kUnsubscribeAnnounces: - return std::make_unique<UnsubscribeAnnouncesMessage>(); + case MoqtMessageType::kSubscribeNamespace: + return std::make_unique<SubscribeNamespaceMessage>(); + case MoqtMessageType::kSubscribeNamespaceOk: + return std::make_unique<SubscribeNamespaceOkMessage>(); + case MoqtMessageType::kSubscribeNamespaceError: + return std::make_unique<SubscribeNamespaceErrorMessage>(); + case MoqtMessageType::kUnsubscribeNamespace: + return std::make_unique<UnsubscribeNamespaceMessage>(); case MoqtMessageType::kMaxRequestId: return std::make_unique<MaxRequestIdMessage>(); case MoqtMessageType::kFetch:
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc index 26525da..1bfb70e 100644 --- a/quiche/quic/moqt/tools/chat_client.cc +++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -150,8 +150,8 @@ return; } if (input_message == "/exit") { - // Clean teardown of SUBSCRIBE_ANNOUNCES, ANNOUNCE, SUBSCRIBE. - session_->UnsubscribeAnnounces(GetChatNamespace(my_track_name_)); + // Clean teardown of SUBSCRIBE_NAMESPACE, ANNOUNCE, SUBSCRIBE. + session_->UnsubscribeNamespace(GetChatNamespace(my_track_name_)); session_->Unannounce(GetUserNamespace(my_track_name_)); for (const auto& track_name : other_users_) { session_->Unsubscribe(track_name); @@ -205,7 +205,7 @@ client_->WriteToOutput(GetUsername(*it), object); } -bool ChatClient::AnnounceAndSubscribeAnnounces() { +bool ChatClient::AnnounceAndSubscribeNamespace() { session_ = client_->session(); if (session_ == nullptr) { std::cout << "Failed to connect.\n"; @@ -236,22 +236,22 @@ // Send SUBSCRIBE_ANNOUNCE. Pop 3 levels of namespace to get to {moq-chat, // chat-id} - MoqtOutgoingSubscribeAnnouncesCallback subscribe_announces_callback = + MoqtOutgoingSubscribeNamespaceCallback subscribe_announces_callback = [this](TrackNamespace track_namespace, std::optional<RequestErrorCode> error, absl::string_view reason) { if (error.has_value()) { - std::cout << "SUBSCRIBE_ANNOUNCES rejected, " << reason << "\n"; + std::cout << "SUBSCRIBE_NAMESPACE rejected, " << reason << "\n"; session_->Error(MoqtError::kInternalError, - "Local SUBSCRIBE_ANNOUNCES rejected"); + "Local SUBSCRIBE_NAMESPACE rejected"); return; } - std::cout << "SUBSCRIBE_ANNOUNCES for " << track_namespace.ToString() + std::cout << "SUBSCRIBE_NAMESPACE for " << track_namespace.ToString() << " accepted\n"; return; }; VersionSpecificParameters parameters( AuthTokenType::kOutOfBand, std::string(GetUsername(my_track_name_))); - session_->SubscribeAnnounces(GetChatNamespace(my_track_name_), + session_->SubscribeNamespace(GetChatNamespace(my_track_name_), std::move(subscribe_announces_callback), parameters);
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h index bf15fa7..07a668c 100644 --- a/quiche/quic/moqt/tools/chat_client.h +++ b/quiche/quic/moqt/tools/chat_client.h
@@ -113,7 +113,7 @@ }; // Returns false on error. - bool AnnounceAndSubscribeAnnounces(); + bool AnnounceAndSubscribeNamespace(); bool session_is_open() const { return session_is_open_; }
diff --git a/quiche/quic/moqt/tools/chat_client_bin.cc b/quiche/quic/moqt/tools/chat_client_bin.cc index 5e9125c..e627ea4 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.AnnounceAndSubscribeAnnounces()) { + if (!client.AnnounceAndSubscribeNamespace()) { return 1; } client.IoLoop();
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc index 268c912..acc818c 100644 --- a/quiche/quic/moqt/tools/chat_server.cc +++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -88,10 +88,10 @@ std::optional<VersionSpecificParameters> parameters) { if (parameters.has_value()) { subscribed_namespaces_.insert(chat_namespace); - std::cout << "Received SUBSCRIBE_ANNOUNCES for "; + std::cout << "Received SUBSCRIBE_NAMESPACE for "; } else { subscribed_namespaces_.erase(chat_namespace); - std::cout << "Received UNSUBSCRIBE_ANNOUNCES for "; + std::cout << "Received UNSUBSCRIBE_NAMESPACE for "; } std::cout << chat_namespace.ToString() << "\n"; if (!IsValidChatNamespace(chat_namespace)) {
diff --git a/quiche/quic/moqt/tools/moq_chat.h b/quiche/quic/moqt/tools/moq_chat.h index 3478b8b..9d43814 100644 --- a/quiche/quic/moqt/tools/moq_chat.h +++ b/quiche/quic/moqt/tools/moq_chat.h
@@ -47,7 +47,7 @@ // Strips "chat" from the end of |track_name| to use in ANNOUNCE. const TrackNamespace& GetUserNamespace(const FullTrackName& track_name); -// Returns {"moq-chat", chat-id}, useful for SUBSCRIBE_ANNOUNCES. +// Returns {"moq-chat", chat-id}, useful for SUBSCRIBE_NAMESPACE. TrackNamespace GetChatNamespace(const TrackNamespace& track_name); TrackNamespace GetChatNamespace(const FullTrackName& track_name);
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 8807363..f808d47 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_->AnnounceAndSubscribeAnnounces()); - EXPECT_TRUE(client2_->AnnounceAndSubscribeAnnounces()); + EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace()); + EXPECT_TRUE(client2_->AnnounceAndSubscribeNamespace()); 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_->AnnounceAndSubscribeAnnounces()); - EXPECT_TRUE(client2_->AnnounceAndSubscribeAnnounces()); + EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace()); + EXPECT_TRUE(client2_->AnnounceAndSubscribeNamespace()); 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_->AnnounceAndSubscribeAnnounces()); + EXPECT_TRUE(client1_->AnnounceAndSubscribeNamespace()); SendAndWaitForOutput(interface1b_, interface2_, "client1", "Hello again"); SendAndWaitForOutput(interface2_, interface1b_, "client2", "Hi again"); }
diff --git a/quiche/quic/moqt/tools/moqt_mock_visitor.h b/quiche/quic/moqt/tools/moqt_mock_visitor.h index cc46881..f786918 100644 --- a/quiche/quic/moqt/tools/moqt_mock_visitor.h +++ b/quiche/quic/moqt/tools/moqt_mock_visitor.h
@@ -40,7 +40,7 @@ ON_CALL(incoming_announce_callback, Call(testing::_, testing::_)) .WillByDefault(DefaultIncomingAnnounceCallback); ON_CALL(incoming_subscribe_announces_callback, Call(testing::_, testing::_)) - .WillByDefault(DefaultIncomingSubscribeAnnouncesCallback); + .WillByDefault(DefaultIncomingSubscribeNamespaceCallback); } MoqtSessionCallbacks AsSessionCallbacks() {