Rename MoQT SubscribeError fields and update request error codes. PiperOrigin-RevId: 757891370
diff --git a/quiche/quic/moqt/moqt_failed_fetch.h b/quiche/quic/moqt/moqt_failed_fetch.h index fd13a52..154c6fc 100644 --- a/quiche/quic/moqt/moqt_failed_fetch.h +++ b/quiche/quic/moqt/moqt_failed_fetch.h
@@ -27,7 +27,7 @@ void SetFetchResponseCallback(FetchResponseCallback callback) { MoqtFetchError error; error.subscribe_id = 0; - error.error_code = StatusToSubscribeErrorCode(status_); + error.error_code = StatusToRequestErrorCode(status_); error.reason_phrase = status_.message(); std::move(callback)(error); }
diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc index 7578166..43caa3a 100644 --- a/quiche/quic/moqt/moqt_framer.cc +++ b/quiche/quic/moqt/moqt_framer.cc
@@ -501,7 +501,7 @@ quiche::QuicheBuffer MoqtFramer::SerializeSubscribeError( const MoqtSubscribeError& message) { return SerializeControlMessage( - MoqtMessageType::kSubscribeError, WireVarInt62(message.subscribe_id), + MoqtMessageType::kSubscribeError, WireVarInt62(message.request_id), WireVarInt62(message.error_code), WireStringWithVarInt62Length(message.reason_phrase), WireVarInt62(message.track_alias));
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc index 8d97e6e..b6c95ad 100644 --- a/quiche/quic/moqt/moqt_integration_test.cc +++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -203,12 +203,11 @@ matches = true; EXPECT_EQ(track_namespace, FullTrackName{"foo"}); ASSERT_TRUE(error.has_value()); - EXPECT_EQ(error->error_code, SubscribeErrorCode::kInternalError); + EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError); EXPECT_EQ(error->reason_phrase, "internal error"); }); - server_->session()->CancelAnnounce(FullTrackName{"foo"}, - SubscribeErrorCode::kInternalError, - "internal error"); + server_->session()->CancelAnnounce( + FullTrackName{"foo"}, RequestErrorCode::kInternalError, "internal error"); success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; }); EXPECT_TRUE(success); } @@ -461,7 +460,7 @@ matches = true; EXPECT_EQ(track_namespace, FullTrackName{"foo"}); ASSERT_TRUE(error.has_value()); - EXPECT_EQ(error->error_code, SubscribeErrorCode::kNotSupported); + EXPECT_EQ(error->error_code, RequestErrorCode::kNotSupported); }); bool success = test_harness_.RunUntilWithDefaultTimeout([&]() { return matches; });
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc index 7e6f480..96e50cd 100644 --- a/quiche/quic/moqt/moqt_messages.cc +++ b/quiche/quic/moqt/moqt_messages.cc
@@ -92,25 +92,63 @@ return static_cast<MoqtObjectStatus>(integer); } -SubscribeErrorCode StatusToSubscribeErrorCode(absl::Status status) { +RequestErrorCode StatusToRequestErrorCode(absl::Status status) { QUICHE_DCHECK(!status.ok()); switch (status.code()) { case absl::StatusCode::kPermissionDenied: - case absl::StatusCode::kUnauthenticated: - return SubscribeErrorCode::kUnauthorized; + return RequestErrorCode::kUnauthorized; case absl::StatusCode::kDeadlineExceeded: - return SubscribeErrorCode::kTimeout; - case absl::StatusCode::kUnavailable: - return SubscribeErrorCode::kNotSupported; + return RequestErrorCode::kTimeout; + case absl::StatusCode::kUnimplemented: + return RequestErrorCode::kNotSupported; case absl::StatusCode::kNotFound: - return SubscribeErrorCode::kDoesNotExist; + return RequestErrorCode::kTrackDoesNotExist; case absl::StatusCode::kOutOfRange: - return SubscribeErrorCode::kInvalidRange; + return RequestErrorCode::kInvalidRange; + case absl::StatusCode::kInvalidArgument: + return RequestErrorCode::kInvalidJoiningSubscribeId; + case absl::StatusCode::kUnauthenticated: + return RequestErrorCode::kExpiredAuthToken; default: - return SubscribeErrorCode::kInternalError; + return RequestErrorCode::kInternalError; } } +absl::StatusCode RequestErrorCodeToStatusCode(RequestErrorCode error_code) { + switch (error_code) { + case RequestErrorCode::kInternalError: + return absl::StatusCode::kInternal; + case RequestErrorCode::kUnauthorized: + return absl::StatusCode::kPermissionDenied; + case RequestErrorCode::kTimeout: + return absl::StatusCode::kDeadlineExceeded; + case RequestErrorCode::kNotSupported: + return absl::StatusCode::kUnimplemented; + case RequestErrorCode::kTrackDoesNotExist: + // Equivalently, kUninterested and kNamespacePrefixUnknown. + return absl::StatusCode::kNotFound; + case RequestErrorCode::kInvalidRange: + // Equivalently, kNamespacePrefixOverlap. + return absl::StatusCode::kOutOfRange; + case RequestErrorCode::kNoObjects: + // Equivalently, kRetryTrackAlias. + return absl::StatusCode::kNotFound; + case RequestErrorCode::kInvalidJoiningSubscribeId: + case RequestErrorCode::kMalformedAuthToken: + case RequestErrorCode::kUnknownAuthTokenAlias: + return absl::StatusCode::kInvalidArgument; + case RequestErrorCode::kExpiredAuthToken: + return absl::StatusCode::kUnauthenticated; + default: + return absl::StatusCode::kUnknown; + } +} + +absl::Status RequestErrorCodeToStatus(RequestErrorCode error_code, + absl::string_view reason_phrase) { + return absl::Status(RequestErrorCodeToStatusCode(error_code), reason_phrase); +}; + MoqtError ValidateSetupParameters(const KeyValuePairList& parameters, bool webtrans, quic::Perspective perspective) {
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h index fc525c2..ef7d3b0 100644 --- a/quiche/quic/moqt/moqt_messages.h +++ b/quiche/quic/moqt/moqt_messages.h
@@ -241,29 +241,30 @@ // Used for SUBSCRIBE_ERROR, ANNOUNCE_ERROR, ANNOUNCE_CANCEL, // SUBSCRIBE_ANNOUNCES_ERROR, and FETCH_ERROR. -// TODO(martinduke): Create aliases like FetchErrorCode, etc. to hide the fact -// that these are all the same enum. -enum class QUICHE_EXPORT SubscribeErrorCode : uint64_t { +enum class QUICHE_EXPORT RequestErrorCode : uint64_t { kInternalError = 0x0, kUnauthorized = 0x1, kTimeout = 0x2, kNotSupported = 0x3, - kDoesNotExist = 0x4, // Can also mean "not interested" or "unknown". - kInvalidRange = 0x5, // SUBSCRIBE_ERROR and FETCH_ERROR only. - kRetryTrackAlias = 0x6, // SUBSCRIBE_ERROR only. + kTrackDoesNotExist = 0x4, // SUBSCRIBE_ERROR and FETCH_ERROR only. + kUninterested = 0x4, // ANNOUNCE_ERROR and ANNOUNCE_CANCEL only. + kNamespacePrefixUnknown = 0x4, // SUBSCRIBE_ANNOUNCES_ERROR only. + kInvalidRange = 0x5, // SUBSCRIBE_ERROR and FETCH_ERROR only. + kNamespacePrefixOverlap = 0x5, // SUBSCRIBE_ANNOUNCES_ERROR only. + kRetryTrackAlias = 0x6, // SUBSCRIBE_ERROR only. + kNoObjects = 0x6, // FETCH_ERROR only. + kInvalidJoiningSubscribeId = 0x7, // FETCH_ERROR only. kMalformedAuthToken = 0x10, kUnknownAuthTokenAlias = 0x11, kExpiredAuthToken = 0x12, }; struct MoqtSubscribeErrorReason { - SubscribeErrorCode error_code; + RequestErrorCode error_code; std::string reason_phrase; }; using MoqtAnnounceErrorReason = MoqtSubscribeErrorReason; -SubscribeErrorCode StatusToSubscribeErrorCode(absl::Status status); - // Full track name represents a tuple of name elements. All higher order // elements MUST be present, but lower-order ones (like the name) can be // omitted. @@ -548,8 +549,8 @@ }; struct QUICHE_EXPORT MoqtSubscribeError { - uint64_t subscribe_id; - SubscribeErrorCode error_code; + uint64_t request_id; + RequestErrorCode error_code; std::string reason_phrase; uint64_t track_alias; }; @@ -594,7 +595,7 @@ struct QUICHE_EXPORT MoqtAnnounceError { FullTrackName track_namespace; - SubscribeErrorCode error_code; + RequestErrorCode error_code; std::string reason_phrase; }; @@ -633,7 +634,7 @@ struct QUICHE_EXPORT MoqtAnnounceCancel { FullTrackName track_namespace; - SubscribeErrorCode error_code; + RequestErrorCode error_code; std::string reason_phrase; }; @@ -657,7 +658,7 @@ struct QUICHE_EXPORT MoqtSubscribeAnnouncesError { FullTrackName track_namespace; - SubscribeErrorCode error_code; + RequestErrorCode error_code; std::string reason_phrase; }; @@ -709,7 +710,7 @@ struct QUICHE_EXPORT MoqtFetchError { uint64_t subscribe_id; - SubscribeErrorCode error_code; + RequestErrorCode error_code; std::string reason_phrase; }; @@ -728,6 +729,11 @@ quic::QuicTimeDelta delta_from_deadline = quic::QuicTimeDelta::Zero(); }; +RequestErrorCode StatusToRequestErrorCode(absl::Status status); +absl::StatusCode RequestErrorCodeToStatusCode(RequestErrorCode error_code); +absl::Status RequestErrorCodeToStatus(RequestErrorCode error_code, + absl::string_view reason_phrase); + // Returns an error if the parameters are malformed or otherwise violate the // spec. |perspective| is the consumer of the message, not the sender. MoqtError ValidateSetupParameters(const KeyValuePairList& parameters,
diff --git a/quiche/quic/moqt/moqt_outgoing_queue.h b/quiche/quic/moqt/moqt_outgoing_queue.h index e8391be..d20f900 100644 --- a/quiche/quic/moqt/moqt_outgoing_queue.h +++ b/quiche/quic/moqt/moqt_outgoing_queue.h
@@ -119,15 +119,15 @@ } void SetFetchResponseCallback(FetchResponseCallback callback) override { if (!status_.ok()) { - MoqtFetchError error(0, StatusToSubscribeErrorCode(status_), + MoqtFetchError error(0, StatusToRequestErrorCode(status_), std::string(status_.message())); - error.error_code = StatusToSubscribeErrorCode(status_); + error.error_code = StatusToRequestErrorCode(status_); error.reason_phrase = status_.message(); std::move(callback)(error); return; } if (objects_.empty()) { - MoqtFetchError error(0, StatusToSubscribeErrorCode(status_), + MoqtFetchError error(0, StatusToRequestErrorCode(status_), "No objects in range"); std::move(callback)(error); return;
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc index c84fa9f..8761ffb 100644 --- a/quiche/quic/moqt/moqt_parser.cc +++ b/quiche/quic/moqt/moqt_parser.cc
@@ -514,13 +514,13 @@ size_t MoqtControlParser::ProcessSubscribeError(quic::QuicDataReader& reader) { MoqtSubscribeError subscribe_error; uint64_t error_code; - if (!reader.ReadVarInt62(&subscribe_error.subscribe_id) || + if (!reader.ReadVarInt62(&subscribe_error.request_id) || !reader.ReadVarInt62(&error_code) || !reader.ReadStringVarInt62(subscribe_error.reason_phrase) || !reader.ReadVarInt62(&subscribe_error.track_alias)) { return 0; } - subscribe_error.error_code = static_cast<SubscribeErrorCode>(error_code); + subscribe_error.error_code = static_cast<RequestErrorCode>(error_code); visitor_.OnSubscribeErrorMessage(subscribe_error); return reader.PreviouslyReadPayload().length(); } @@ -623,7 +623,7 @@ !reader.ReadStringVarInt62(announce_error.reason_phrase)) { return 0; } - announce_error.error_code = static_cast<SubscribeErrorCode>(error_code); + announce_error.error_code = static_cast<RequestErrorCode>(error_code); visitor_.OnAnnounceErrorMessage(announce_error); return reader.PreviouslyReadPayload().length(); } @@ -638,7 +638,7 @@ !reader.ReadStringVarInt62(announce_cancel.reason_phrase)) { return 0; } - announce_cancel.error_code = static_cast<SubscribeErrorCode>(error_code); + announce_cancel.error_code = static_cast<RequestErrorCode>(error_code); visitor_.OnAnnounceCancelMessage(announce_cancel); return reader.PreviouslyReadPayload().length(); } @@ -766,7 +766,7 @@ return 0; } subscribe_namespace_error.error_code = - static_cast<SubscribeErrorCode>(error_code); + static_cast<RequestErrorCode>(error_code); visitor_.OnSubscribeAnnouncesErrorMessage(subscribe_namespace_error); return reader.PreviouslyReadPayload().length(); } @@ -906,7 +906,7 @@ !reader.ReadStringVarInt62(fetch_error.reason_phrase)) { return 0; } - fetch_error.error_code = static_cast<SubscribeErrorCode>(error_code); + fetch_error.error_code = static_cast<RequestErrorCode>(error_code); visitor_.OnFetchErrorMessage(fetch_error); return reader.PreviouslyReadPayload().length(); }
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc index 9a0b499..0c8e75e 100644 --- a/quiche/quic/moqt/moqt_session.cc +++ b/quiche/quic/moqt/moqt_session.cc
@@ -287,7 +287,7 @@ std::move(announce_callback)( track_namespace, MoqtAnnounceErrorReason{ - SubscribeErrorCode::kInternalError, + RequestErrorCode::kInternalError, "ANNOUNCE message already outstanding for namespace"}); return; } @@ -319,7 +319,7 @@ } void MoqtSession::CancelAnnounce(FullTrackName track_namespace, - SubscribeErrorCode code, + RequestErrorCode code, absl::string_view reason) { MoqtAnnounceCancel message{track_namespace, code, std::string(reason)}; @@ -913,10 +913,10 @@ } void MoqtSession::ControlStream::SendSubscribeError( - uint64_t subscribe_id, SubscribeErrorCode error_code, + uint64_t request_id, RequestErrorCode error_code, absl::string_view reason_phrase, uint64_t track_alias) { MoqtSubscribeError subscribe_error; - subscribe_error.subscribe_id = subscribe_id; + subscribe_error.request_id = request_id; subscribe_error.error_code = error_code; subscribe_error.reason_phrase = reason_phrase; subscribe_error.track_alias = track_alias; @@ -925,7 +925,7 @@ } void MoqtSession::ControlStream::SendFetchError( - uint64_t subscribe_id, SubscribeErrorCode error_code, + uint64_t subscribe_id, RequestErrorCode error_code, absl::string_view reason_phrase) { MoqtFetchError fetch_error; fetch_error.subscribe_id = subscribe_id; @@ -943,7 +943,7 @@ << message.full_track_name; if (session_->sent_goaway_) { QUIC_DLOG(INFO) << ENDPOINT << "Received a SUBSCRIBE after GOAWAY"; - SendSubscribeError(message.request_id, SubscribeErrorCode::kUnauthorized, + SendSubscribeError(message.request_id, RequestErrorCode::kUnauthorized, "SUBSCRIBE after GOAWAY", message.track_alias); return; } @@ -959,7 +959,7 @@ QUIC_DLOG(INFO) << ENDPOINT << "SUBSCRIBE for " << track_name << " rejected by the application: " << track_publisher.status(); - SendSubscribeError(message.request_id, SubscribeErrorCode::kDoesNotExist, + SendSubscribeError(message.request_id, RequestErrorCode::kTrackDoesNotExist, track_publisher.status().message(), message.track_alias); return; } @@ -1025,10 +1025,10 @@ void MoqtSession::ControlStream::OnSubscribeErrorMessage( const MoqtSubscribeError& message) { - RemoteTrack* track = session_->RemoteTrackById(message.subscribe_id); + RemoteTrack* track = session_->RemoteTrackById(message.request_id); if (track == nullptr) { QUIC_DLOG(INFO) << ENDPOINT << "Received the SUBSCRIBE_ERROR for " - << "subscribe_id = " << message.subscribe_id + << "subscribe_id = " << message.request_id << " but no track exists"; // Subscription state might have been destroyed for internal reasons. return; @@ -1044,7 +1044,7 @@ return; } QUIC_DLOG(INFO) << ENDPOINT << "Received the SUBSCRIBE_ERROR for " - << "subscribe_id = " << message.subscribe_id << " (" + << "subscribe_id = " << message.request_id << " (" << track->full_track_name() << ")" << ", error = " << static_cast<int>(message.error_code) << " (" << message.reason_phrase << ")"; @@ -1053,7 +1053,7 @@ // an error due to a duplicate track name. The other entries for this // subscribe will be deleted after calling Subscribe(). session_->subscribe_by_name_.erase(subscribe->full_track_name()); - if (message.error_code == SubscribeErrorCode::kRetryTrackAlias) { + if (message.error_code == RequestErrorCode::kRetryTrackAlias) { // Automatically resubscribe with new alias. MoqtSubscribe& subscribe_message = subscribe->GetSubscribe(); session_->Subscribe(subscribe_message, subscribe->visitor(), @@ -1110,7 +1110,7 @@ QUIC_DLOG(INFO) << ENDPOINT << "Received an ANNOUNCE after GOAWAY"; MoqtAnnounceError error; error.track_namespace = message.track_namespace; - error.error_code = SubscribeErrorCode::kUnauthorized; + error.error_code = RequestErrorCode::kUnauthorized; error.reason_phrase = "ANNOUNCE after GOAWAY"; SendOrBufferMessage(session_->framer_.SerializeAnnounceError(error)); return; @@ -1205,7 +1205,7 @@ << "Received a SUBSCRIBE_ANNOUNCES after GOAWAY"; MoqtSubscribeAnnouncesError error; error.track_namespace = message.track_namespace; - error.error_code = SubscribeErrorCode::kUnauthorized; + error.error_code = RequestErrorCode::kUnauthorized; error.reason_phrase = "SUBSCRIBE_ANNOUNCES after GOAWAY"; SendOrBufferMessage( session_->framer_.SerializeSubscribeAnnouncesError(error)); @@ -1288,7 +1288,7 @@ } if (session_->sent_goaway_) { QUIC_DLOG(INFO) << ENDPOINT << "Received a FETCH after GOAWAY"; - SendFetchError(message.fetch_id, SubscribeErrorCode::kUnauthorized, + SendFetchError(message.fetch_id, RequestErrorCode::kUnauthorized, "FETCH after GOAWAY"); return; } @@ -1303,7 +1303,7 @@ QUIC_DLOG(INFO) << ENDPOINT << "Received a JOINING_FETCH for " << "subscribe_id " << joining_subscribe_id << " that does not exist"; - SendFetchError(message.fetch_id, SubscribeErrorCode::kDoesNotExist, + SendFetchError(message.fetch_id, RequestErrorCode::kTrackDoesNotExist, "Joining Fetch for non-existent subscribe"); return; } @@ -1342,7 +1342,7 @@ QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name << " rejected by the application: " << track_publisher.status(); - SendFetchError(message.fetch_id, SubscribeErrorCode::kDoesNotExist, + SendFetchError(message.fetch_id, RequestErrorCode::kTrackDoesNotExist, track_publisher.status().message()); return; } @@ -1354,7 +1354,7 @@ if (!fetch->GetStatus().ok()) { QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name << " could not initialize the task"; - SendFetchError(message.fetch_id, SubscribeErrorCode::kInvalidRange, + SendFetchError(message.fetch_id, RequestErrorCode::kInvalidRange, fetch->GetStatus().message()); return; } @@ -1365,7 +1365,7 @@ if (!result.second) { // Emplace failed. QUIC_DLOG(INFO) << ENDPOINT << "FETCH for " << track_name << " could not be added to the session"; - SendFetchError(message.fetch_id, SubscribeErrorCode::kInternalError, + SendFetchError(message.fetch_id, RequestErrorCode::kInternalError, "Could not initialize FETCH state"); } MoqtFetchTask* fetch_task = result.first->second->fetch_task(); @@ -1466,30 +1466,8 @@ << ", error = " << static_cast<int>(message.error_code) << " (" << message.reason_phrase << ")"; UpstreamFetch* fetch = static_cast<UpstreamFetch*>(track); - absl::Status status; - switch (message.error_code) { - case SubscribeErrorCode::kInternalError: - status = absl::InternalError(message.reason_phrase); - break; - case SubscribeErrorCode::kInvalidRange: - status = absl::OutOfRangeError(message.reason_phrase); - break; - case SubscribeErrorCode::kDoesNotExist: - status = absl::NotFoundError(message.reason_phrase); - break; - case SubscribeErrorCode::kUnauthorized: - status = absl::UnauthenticatedError(message.reason_phrase); - break; - case SubscribeErrorCode::kTimeout: - status = absl::DeadlineExceededError(message.reason_phrase); - break; - case SubscribeErrorCode::kNotSupported: - status = absl::UnavailableError(message.reason_phrase); - break; - default: - status = absl::UnknownError(message.reason_phrase); - break; - } + absl::Status status = + RequestErrorCodeToStatus(message.error_code, message.reason_phrase); fetch->OnFetchResult(Location(0, 0), status, nullptr); session_->upstream_by_id_.erase(message.subscribe_id); }
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h index 85e20ce..77bc1fb 100644 --- a/quiche/quic/moqt/moqt_session.h +++ b/quiche/quic/moqt/moqt_session.h
@@ -110,7 +110,7 @@ bool Unannounce(FullTrackName track_namespace); // Allows the subscriber to declare it will not subscribe to |track_namespace| // anymore. - void CancelAnnounce(FullTrackName track_namespace, SubscribeErrorCode code, + void CancelAnnounce(FullTrackName track_namespace, RequestErrorCode code, absl::string_view reason_phrase); // Returns true if SUBSCRIBE was sent. If there is already a subscription to @@ -275,14 +275,13 @@ // control credit. void SendOrBufferMessage(quiche::QuicheBuffer message, bool fin = false); - void SendSubscribeError(uint64_t subscribe_id, - SubscribeErrorCode error_code, + void SendSubscribeError(uint64_t request_id, RequestErrorCode error_code, absl::string_view reason_phrase, uint64_t track_alias); private: friend class test::MoqtSessionPeer; - void SendFetchError(uint64_t subscribe_id, SubscribeErrorCode error_code, + void SendFetchError(uint64_t subscribe_id, RequestErrorCode error_code, absl::string_view reason_phrase); MoqtSession* session_;
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h index 39b5bfd..3b0271a 100644 --- a/quiche/quic/moqt/moqt_session_callbacks.h +++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -50,7 +50,7 @@ const FullTrackName& /*track_namespace*/, std::optional<VersionSpecificParameters> /*parameters*/) { return std::optional(MoqtAnnounceErrorReason{ - SubscribeErrorCode::kNotSupported, + RequestErrorCode::kNotSupported, "This endpoint does not accept incoming ANNOUNCE messages"}); }; @@ -59,7 +59,7 @@ const FullTrackName& track_namespace, std::optional<VersionSpecificParameters> /*parameters*/) { return MoqtSubscribeErrorReason{ - SubscribeErrorCode::kUnauthorized, + RequestErrorCode::kNotSupported, "This endpoint does not support incoming SUBSCRIBE_ANNOUNCES messages"}; }
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h index 1bf2eb2..f26266d 100644 --- a/quiche/quic/moqt/moqt_session_interface.h +++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -27,7 +27,7 @@ std::optional<MoqtAnnounceErrorReason> error)>; using MoqtOutgoingSubscribeAnnouncesCallback = quiche::SingleUseCallback<void( - FullTrackName track_namespace, std::optional<SubscribeErrorCode> error, + FullTrackName track_namespace, std::optional<RequestErrorCode> error, absl::string_view reason)>; class MoqtSessionInterface {
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc index 70c6a24..bbc41ad 100644 --- a/quiche/quic/moqt/moqt_session_test.cc +++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -379,7 +379,7 @@ MoqtAnnounceCancel cancel = { /*track_namespace=*/FullTrackName{"foo"}, - /*error_code=*/SubscribeErrorCode::kInternalError, + /*error_code=*/RequestErrorCode::kInternalError, /*reason_phrase=*/"Test error", }; EXPECT_CALL(announce_resolved_callback, Call(_, _)) @@ -387,7 +387,7 @@ std::optional<MoqtAnnounceErrorReason> error) { EXPECT_EQ(track_namespace, FullTrackName{"foo"}); ASSERT_TRUE(error.has_value()); - EXPECT_EQ(error->error_code, SubscribeErrorCode::kInternalError); + EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError); EXPECT_EQ(error->reason_phrase, "Test error"); }); stream_input->OnAnnounceCancelMessage(cancel); @@ -444,7 +444,7 @@ MoqtAnnounceError error = { /*track_namespace=*/FullTrackName{"foo"}, - /*error_code=*/SubscribeErrorCode::kInternalError, + /*error_code=*/RequestErrorCode::kInternalError, /*reason_phrase=*/"Test error", }; EXPECT_CALL(announce_resolved_callback, Call(_, _)) @@ -452,7 +452,7 @@ std::optional<MoqtAnnounceErrorReason> error) { EXPECT_EQ(track_namespace, FullTrackName{"foo"}); ASSERT_TRUE(error.has_value()); - EXPECT_EQ(error->error_code, SubscribeErrorCode::kInternalError); + EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError); EXPECT_EQ(error->reason_phrase, "Test error"); }); stream_input->OnAnnounceErrorMessage(error); @@ -491,8 +491,7 @@ mock_stream_, Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _)); listener->OnSubscribeRejected( - MoqtSubscribeErrorReason(SubscribeErrorCode::kInternalError, - "Test error"), + MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error"), request.track_alias); EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, 1), nullptr); } @@ -800,7 +799,7 @@ MoqtSubscribeError error = { /*request_id=*/0, - /*error_code=*/SubscribeErrorCode::kInvalidRange, + /*error_code=*/RequestErrorCode::kInvalidRange, /*reason_phrase=*/"deadbeef", /*track_alias=*/2, }; @@ -874,10 +873,10 @@ stream_input->OnAnnounceMessage(announce); EXPECT_CALL(mock_stream_, Writev(SerializedControlMessage(MoqtAnnounceCancel{ - track_namespace, SubscribeErrorCode::kInternalError, + track_namespace, RequestErrorCode::kInternalError, "deadbeef"}), _)); - session_.CancelAnnounce(track_namespace, SubscribeErrorCode::kInternalError, + session_.CancelAnnounce(track_namespace, RequestErrorCode::kInternalError, "deadbeef"); } @@ -893,7 +892,7 @@ *parameters, }; MoqtAnnounceErrorReason error = { - SubscribeErrorCode::kNotSupported, + RequestErrorCode::kNotSupported, "deadbeef", }; EXPECT_CALL(session_callbacks_.incoming_announce_callback, @@ -918,7 +917,7 @@ Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _)); session_.SubscribeAnnounces( track_namespace, - [&](const FullTrackName& ftn, std::optional<SubscribeErrorCode> error, + [&](const FullTrackName& ftn, std::optional<RequestErrorCode> error, absl::string_view reason) { got_callback = true; EXPECT_EQ(track_namespace, ftn); @@ -949,18 +948,18 @@ Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnounces), _)); session_.SubscribeAnnounces( track_namespace, - [&](const FullTrackName& ftn, std::optional<SubscribeErrorCode> error, + [&](const FullTrackName& ftn, std::optional<RequestErrorCode> error, absl::string_view reason) { got_callback = true; EXPECT_EQ(track_namespace, ftn); ASSERT_TRUE(error.has_value()); - EXPECT_EQ(*error, SubscribeErrorCode::kInvalidRange); + EXPECT_EQ(*error, RequestErrorCode::kInvalidRange); EXPECT_EQ(reason, "deadbeef"); }, VersionSpecificParameters()); MoqtSubscribeAnnouncesError error = { /*track_namespace=*/track_namespace, - /*error_code=*/SubscribeErrorCode::kInvalidRange, + /*error_code=*/RequestErrorCode::kInvalidRange, /*reason_phrase=*/"deadbeef", }; stream_input->OnSubscribeAnnouncesErrorMessage(error); @@ -1130,7 +1129,7 @@ // SUBSCRIBE_ERROR arrives MoqtSubscribeError subscribe_error = { /*request_id=*/1, - /*error_code=*/SubscribeErrorCode::kRetryTrackAlias, + /*error_code=*/RequestErrorCode::kRetryTrackAlias, /*reason_phrase=*/"foo", /*track_alias =*/3, }; @@ -1152,7 +1151,7 @@ // SUBSCRIBE_ERROR arrives MoqtSubscribeError subscribe_error = { /*request_id=*/1, - /*error_code=*/SubscribeErrorCode::kRetryTrackAlias, + /*error_code=*/RequestErrorCode::kRetryTrackAlias, /*reason_phrase=*/"foo", /*track_alias =*/3, }; @@ -1172,7 +1171,7 @@ // SUBSCRIBE_ERROR arrives MoqtSubscribeError subscribe_error = { /*request_id=*/1, - /*error_code=*/SubscribeErrorCode::kRetryTrackAlias, + /*error_code=*/RequestErrorCode::kRetryTrackAlias, /*reason_phrase=*/"foo", /*track_alias =*/2, }; @@ -2289,7 +2288,7 @@ MoqtFetchError expected_error; expected_error.subscribe_id = fetch.fetch_id; - expected_error.error_code = SubscribeErrorCode::kDoesNotExist; + expected_error.error_code = RequestErrorCode::kTrackDoesNotExist; expected_error.reason_phrase = "foo"; EXPECT_CALL(mock_stream_, Writev(SerializedControlMessage(expected_error), _)); @@ -2392,7 +2391,7 @@ fetch.joining_fetch = {1, 2}; MoqtFetchError expected_error = { /*request_id=*/1, - /*error_code=*/SubscribeErrorCode::kDoesNotExist, + /*error_code=*/RequestErrorCode::kTrackDoesNotExist, /*reason_phrase=*/"Joining Fetch for non-existent subscribe", }; EXPECT_CALL(mock_stream_, @@ -2538,7 +2537,7 @@ EXPECT_CALL(session_callbacks_.incoming_subscribe_announces_callback, Call(_, parameters)) .WillOnce(Return( - MoqtSubscribeErrorReason{SubscribeErrorCode::kUnauthorized, "foo"})); + MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"})); EXPECT_CALL( control_stream, Writev(ControlMessageOfType(MoqtMessageType::kSubscribeAnnouncesError), @@ -2588,12 +2587,12 @@ VersionSpecificParameters()); MoqtFetchError error = { /*request_id=*/0, - /*error_code=*/SubscribeErrorCode::kUnauthorized, + /*error_code=*/RequestErrorCode::kUnauthorized, /*reason_phrase=*/"No username provided", }; stream_input->OnFetchErrorMessage(error); ASSERT_NE(fetch_task, nullptr); - EXPECT_TRUE(absl::IsUnauthenticated(fetch_task->GetStatus())); + EXPECT_TRUE(absl::IsPermissionDenied(fetch_task->GetStatus())); EXPECT_EQ(fetch_task->GetStatus().message(), "No username provided"); } @@ -3070,7 +3069,7 @@ EXPECT_FALSE(session_.SubscribeAnnounces( FullTrackName{"foo"}, +[](FullTrackName /*track_namespace*/, - std::optional<SubscribeErrorCode> /*error*/, + std::optional<RequestErrorCode> /*error*/, absl::string_view /*reason*/) {}, VersionSpecificParameters())); session_.Announce( @@ -3131,7 +3130,7 @@ EXPECT_FALSE(session_.SubscribeAnnounces( FullTrackName{"foo"}, +[](FullTrackName /*track_namespace*/, - std::optional<SubscribeErrorCode> /*error*/, + std::optional<RequestErrorCode> /*error*/, absl::string_view /*reason*/) {}, VersionSpecificParameters())); session_.Announce(
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h index b30d63c..2ef9c8b 100644 --- a/quiche/quic/moqt/test_tools/moqt_test_message.h +++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -623,8 +623,8 @@ bool EqualFieldValues(MessageStructuredData& values) const override { auto cast = std::get<MoqtSubscribeError>(values); - if (cast.subscribe_id != subscribe_error_.subscribe_id) { - QUIC_LOG(INFO) << "SUBSCRIBE ERROR subscribe_id mismatch"; + if (cast.request_id != subscribe_error_.request_id) { + QUIC_LOG(INFO) << "SUBSCRIBE ERROR request_id mismatch"; return false; } if (cast.error_code != subscribe_error_.error_code) { @@ -651,15 +651,15 @@ private: uint8_t raw_packet_[10] = { 0x05, 0x00, 0x07, - 0x02, // subscribe_id = 2 + 0x02, // request_id = 2 0x05, // error_code = 5 0x03, 0x62, 0x61, 0x72, // reason_phrase = "bar" 0x04, // track_alias = 4 }; MoqtSubscribeError subscribe_error_ = { - /*subscribe_id=*/2, - /*subscribe=*/SubscribeErrorCode::kInvalidRange, + /*request_id=*/2, + /*error_code=*/RequestErrorCode::kInvalidRange, /*reason_phrase=*/"bar", /*track_alias=*/4, }; @@ -910,7 +910,7 @@ MoqtAnnounceError announce_error_ = { /*track_namespace=*/FullTrackName{"foo"}, - /*error_code=*/SubscribeErrorCode::kNotSupported, + /*error_code=*/RequestErrorCode::kNotSupported, /*reason_phrase=*/"bar", }; }; @@ -954,7 +954,7 @@ MoqtAnnounceCancel announce_cancel_ = { /*track_namespace=*/FullTrackName{"foo"}, - /*error_code=*/SubscribeErrorCode::kNotSupported, + /*error_code=*/RequestErrorCode::kNotSupported, /*reason_phrase=*/"bar", }; }; @@ -1227,7 +1227,7 @@ MoqtSubscribeAnnouncesError subscribe_namespace_error_ = { /*track_namespace=*/FullTrackName{"foo"}, - /*error_code=*/SubscribeErrorCode::kUnauthorized, + /*error_code=*/RequestErrorCode::kUnauthorized, /*reason_phrase=*/"bar", }; }; @@ -1625,7 +1625,7 @@ MoqtFetchError fetch_error_ = { /*subscribe_id =*/1, - /*error_code=*/SubscribeErrorCode::kUnauthorized, + /*error_code=*/RequestErrorCode::kUnauthorized, /*reason_phrase=*/"bar", }; };
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc index ef42e85..72349a4 100644 --- a/quiche/quic/moqt/tools/chat_client.cc +++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -59,7 +59,7 @@ if (!track_name.has_value()) { std::cout << "ANNOUNCE rejected, invalid namespace\n"; return std::make_optional<MoqtAnnounceErrorReason>( - SubscribeErrorCode::kDoesNotExist, "Not a subscribed namespace"); + RequestErrorCode::kTrackDoesNotExist, "Not a subscribed namespace"); } if (other_users_.contains(*track_name)) { std::cout << "Duplicate ANNOUNCE, send OK and ignore\n"; @@ -237,8 +237,7 @@ // chat-id} MoqtOutgoingSubscribeAnnouncesCallback subscribe_announces_callback = [this](FullTrackName track_namespace, - std::optional<SubscribeErrorCode> error, - absl::string_view reason) { + std::optional<RequestErrorCode> error, absl::string_view reason) { if (error.has_value()) { std::cout << "SUBSCRIBE_ANNOUNCES rejected, " << reason << "\n"; session_->Error(MoqtError::kInternalError,
diff --git a/quiche/quic/moqt/tools/chat_server.cc b/quiche/quic/moqt/tools/chat_server.cc index f09395b..08bcd62 100644 --- a/quiche/quic/moqt/tools/chat_server.cc +++ b/quiche/quic/moqt/tools/chat_server.cc
@@ -39,7 +39,7 @@ GetChatId(track_namespace)); if (!track_name_.has_value()) { std::cout << "Malformed ANNOUNCE namespace\n"; - return MoqtAnnounceErrorReason(SubscribeErrorCode::kDoesNotExist, + return MoqtAnnounceErrorReason(RequestErrorCode::kTrackDoesNotExist, "Not a valid namespace for this chat."); } if (!parameters.has_value()) { @@ -96,7 +96,7 @@ if (!IsValidChatNamespace(chat_namespace)) { std::cout << "Not a valid moq-chat namespace.\n"; return std::make_optional( - MoqtSubscribeErrorReason{SubscribeErrorCode::kDoesNotExist, + MoqtSubscribeErrorReason{RequestErrorCode::kTrackDoesNotExist, "Not a valid namespace for this chat."}); } if (!parameters.has_value()) {
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc index 0fdf4ac..4b4aefc 100644 --- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc +++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -126,7 +126,7 @@ "disallowed characters; namespace: " << track_namespace; return MoqtAnnounceErrorReason{ - SubscribeErrorCode::kInternalError, + RequestErrorCode::kInternalError, "Track namespace contains disallowed characters"}; } @@ -145,7 +145,7 @@ subscribed_namespaces_.erase(it); QUICHE_LOG(ERROR) << "Failed to create directory " << directory_path << "; " << status; - return MoqtAnnounceErrorReason{SubscribeErrorCode::kInternalError, + return MoqtAnnounceErrorReason{RequestErrorCode::kInternalError, "Failed to create output directory"}; }