Rename MoqtRequestError to MoqtErrorPair. REQUEST_ERROR is now a message type, so this change avoids a name collision. PiperOrigin-RevId: 855343344
diff --git a/quiche/quic/moqt/moqt_integration_test.cc b/quiche/quic/moqt/moqt_integration_test.cc index e3c05f4..0b2f572 100644 --- a/quiche/quic/moqt/moqt_integration_test.cc +++ b/quiche/quic/moqt/moqt_integration_test.cc
@@ -94,11 +94,10 @@ MockSubscribeRemoteTrackVisitor* visitor) { bool received_ok = false; EXPECT_CALL(*visitor, OnReply) - .WillOnce( - [&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { - received_ok = std::holds_alternative<SubscribeOkData>(response); - }); + .WillOnce([&](const FullTrackName&, + std::variant<SubscribeOkData, MoqtErrorPair> response) { + received_ok = std::holds_alternative<SubscribeOkData>(response); + }); client_->session()->SubscribeCurrentObject(track_name, visitor, VersionSpecificParameters()); bool success = @@ -113,7 +112,7 @@ MockSessionCallbacks server_callbacks_; MockSubscribeRemoteTrackVisitor subscribe_visitor_; testing::MockFunction<void(TrackNamespace track_namespace, - std::optional<MoqtRequestError> error_message)> + std::optional<MoqtErrorPair> error_message)> outgoing_publish_namespace_callback_; std::unique_ptr<MoqtClientEndpoint> client_; std::unique_ptr<MoqtServerEndpoint> server_; @@ -177,9 +176,8 @@ MoqtResponseCallback callback) { std::move(callback)(std::nullopt); }); - testing::MockFunction<void( - TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error_message)> + testing::MockFunction<void(TrackNamespace track_namespace, + std::optional<MoqtErrorPair> error_message)> publish_namespace_callback; client_->session()->PublishNamespace( TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(), @@ -187,7 +185,7 @@ bool matches = false; EXPECT_CALL(publish_namespace_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error) { + std::optional<MoqtErrorPair> error) { matches = true; EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); EXPECT_FALSE(error.has_value()); @@ -221,9 +219,8 @@ MoqtResponseCallback callback) { std::move(callback)(std::nullopt); }); - testing::MockFunction<void( - TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error_message)> + testing::MockFunction<void(TrackNamespace track_namespace, + std::optional<MoqtErrorPair> error_message)> publish_namespace_callback; client_->session()->PublishNamespace( TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(), @@ -231,7 +228,7 @@ bool matches = false; EXPECT_CALL(publish_namespace_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error) { + std::optional<MoqtErrorPair> error) { matches = true; EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); EXPECT_FALSE(error.has_value()); @@ -242,7 +239,7 @@ matches = false; EXPECT_CALL(publish_namespace_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error) { + std::optional<MoqtErrorPair> error) { matches = true; EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); ASSERT_TRUE(error.has_value()); @@ -273,7 +270,7 @@ bool matches = false; EXPECT_CALL(outgoing_publish_namespace_callback_, Call) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtRequestError> error) { + std::optional<MoqtErrorPair> error) { EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); FullTrackName track_name(track_namespace, "/catalog"); EXPECT_FALSE(error.has_value()); @@ -281,7 +278,7 @@ track_name, &subscribe_visitor_, VersionSpecificParameters()); }) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtRequestError> error) { + std::optional<MoqtErrorPair> error) { EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); EXPECT_TRUE(error.has_value()); }); @@ -329,7 +326,7 @@ }); client_->session()->PublishNamespace( TrackNamespace{"test"}, - [](TrackNamespace, std::optional<MoqtRequestError>) {}, *parameters); + [](TrackNamespace, std::optional<MoqtErrorPair>) {}, *parameters); bool success = test_harness_.RunUntilWithDefaultTimeout( [&]() { return received_subscribe_ok; }); EXPECT_TRUE(success); @@ -386,12 +383,11 @@ VersionSpecificParameters()); std::optional<Location> largest_id; EXPECT_CALL(subscribe_visitor_, OnReply) - .WillOnce( - [&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { - EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response)); - largest_id = std::get<SubscribeOkData>(response).largest_location; - }); + .WillOnce([&](const FullTrackName&, + std::variant<SubscribeOkData, MoqtErrorPair> response) { + EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response)); + largest_id = std::get<SubscribeOkData>(response).largest_location; + }); bool success = test_harness_.RunUntilWithDefaultTimeout([&]() { return largest_id.has_value() && *largest_id == Location(0, 2); }); @@ -528,9 +524,8 @@ TEST_F(MoqtIntegrationTest, PublishNamespaceFailure) { EstablishSession(); - testing::MockFunction<void( - TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error_message)> + testing::MockFunction<void(TrackNamespace track_namespace, + std::optional<MoqtErrorPair> error_message)> publish_namespace_callback; client_->session()->PublishNamespace( TrackNamespace{"foo"}, publish_namespace_callback.AsStdFunction(), @@ -538,7 +533,7 @@ bool matches = false; EXPECT_CALL(publish_namespace_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> error) { + std::optional<MoqtErrorPair> error) { matches = true; EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); ASSERT_TRUE(error.has_value()); @@ -570,7 +565,7 @@ }); EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { received_ok = std::holds_alternative<SubscribeOkData>(response); }); client_->session()->SubscribeAbsolute( @@ -601,7 +596,7 @@ }); EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { received_ok = std::holds_alternative<SubscribeOkData>(response); }); client_->session()->SubscribeCurrentObject( @@ -632,7 +627,7 @@ }); EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { received_ok = std::holds_alternative<SubscribeOkData>(response); }); client_->session()->SubscribeNextGroup(full_track_name, &subscribe_visitor_, @@ -648,8 +643,8 @@ bool received_ok = false; EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { - received_ok = std::holds_alternative<MoqtRequestError>(response); + std::variant<SubscribeOkData, MoqtErrorPair> response) { + received_ok = std::holds_alternative<MoqtErrorPair>(response); }); client_->session()->SubscribeCurrentObject( full_track_name, &subscribe_visitor_, VersionSpecificParameters()); @@ -698,8 +693,8 @@ full_track_name, &subscribe_visitor_, VersionSpecificParameters())); EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { - EXPECT_TRUE(std::holds_alternative<MoqtRequestError>(response)); + std::variant<SubscribeOkData, MoqtErrorPair> response) { + EXPECT_TRUE(std::holds_alternative<MoqtErrorPair>(response)); }); // Teardown } @@ -730,7 +725,7 @@ }); EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError>) { + std::variant<SubscribeOkData, MoqtErrorPair>) { ack_function(10, 20, quic::QuicTimeDelta::FromMicroseconds(-123)); ack_function(100, 200, quic::QuicTimeDelta::FromMicroseconds(456)); }); @@ -779,7 +774,7 @@ bool received_ok = false; EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { received_ok = std::holds_alternative<SubscribeOkData>(response); }); VersionSpecificParameters parameters; @@ -827,7 +822,7 @@ bool received_ok = false; EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { received_ok = std::holds_alternative<SubscribeOkData>(response); }); VersionSpecificParameters parameters; @@ -911,7 +906,7 @@ bool subscribed = false; EXPECT_CALL(subscribe_visitor_, OnReply) .WillOnce([&](const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError>) { + std::variant<SubscribeOkData, MoqtErrorPair>) { subscribed = true; }); bool success =
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h index 1ed2b9b..c6816b3 100644 --- a/quiche/quic/moqt/moqt_messages.h +++ b/quiche/quic/moqt/moqt_messages.h
@@ -384,13 +384,10 @@ kExpiredAuthToken = 0x12, }; -struct MoqtRequestError { +struct MoqtErrorPair { RequestErrorCode error_code; std::string reason_phrase; }; -// TODO(martinduke): These are deprecated. Replace them in the code. -using MoqtSubscribeErrorReason = MoqtRequestError; -using MoqtPublishNamespaceErrorReason = MoqtSubscribeErrorReason; // Location as defined in // https://moq-wg.github.io/moq-transport/draft-ietf-moq-transport.html#location-structure
diff --git a/quiche/quic/moqt/moqt_outgoing_queue_test.cc b/quiche/quic/moqt/moqt_outgoing_queue_test.cc index 53b0833..014999e 100644 --- a/quiche/quic/moqt/moqt_outgoing_queue_test.cc +++ b/quiche/quic/moqt/moqt_outgoing_queue_test.cc
@@ -98,8 +98,7 @@ ()); MOCK_METHOD(void, OnTrackPublisherGone, (), (override)); MOCK_METHOD(void, OnSubscribeAccepted, (), (override)); - MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason), - (override)); + MOCK_METHOD(void, OnSubscribeRejected, (MoqtErrorPair reason), (override)); }; absl::StatusOr<std::vector<std::string>> FetchToVector(
diff --git a/quiche/quic/moqt/moqt_publisher.h b/quiche/quic/moqt/moqt_publisher.h index 3ed6a6f..6096799 100644 --- a/quiche/quic/moqt/moqt_publisher.h +++ b/quiche/quic/moqt/moqt_publisher.h
@@ -31,7 +31,7 @@ virtual void OnSubscribeAccepted() = 0; // Called when the publisher is sure that it cannot serve the subscription. // This could happen synchronously or asynchronously. - virtual void OnSubscribeRejected(MoqtSubscribeErrorReason reason) = 0; + virtual void OnSubscribeRejected(MoqtErrorPair reason) = 0; // Notifies that a new object is available on the track. The object payload // itself may be retrieved via GetCachedObject method of the associated track
diff --git a/quiche/quic/moqt/moqt_relay_publisher_test.cc b/quiche/quic/moqt/moqt_relay_publisher_test.cc index b844726..2ee9a8d 100644 --- a/quiche/quic/moqt/moqt_relay_publisher_test.cc +++ b/quiche/quic/moqt/moqt_relay_publisher_test.cc
@@ -75,10 +75,10 @@ TEST_F(MoqtRelayPublisherTest, PublishNamespaceLifecycle) { EXPECT_EQ(publisher_.GetTrack(FullTrackName("foo", "bar")), nullptr); - std::optional<MoqtRequestError> response; + std::optional<MoqtErrorPair> response; publisher_.OnPublishNamespace( TrackNamespace({"foo"}), VersionSpecificParameters(), &session_, - [&](std::optional<MoqtRequestError> error_response) { + [&](std::optional<MoqtErrorPair> error_response) { response = error_response; }); EXPECT_EQ(response, std::nullopt);
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.cc b/quiche/quic/moqt/moqt_relay_track_publisher.cc index 5ca8496..4b9e9e7 100644 --- a/quiche/quic/moqt/moqt_relay_track_publisher.cc +++ b/quiche/quic/moqt/moqt_relay_track_publisher.cc
@@ -27,12 +27,12 @@ void MoqtRelayTrackPublisher::OnReply( const FullTrackName&, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { if (is_closing_) { return; } - if (std::holds_alternative<MoqtRequestError>(response)) { - auto request_error = std::get<MoqtRequestError>(response); + if (std::holds_alternative<MoqtErrorPair>(response)) { + auto request_error = std::get<MoqtErrorPair>(response); // Delete upstream_ to avoid sending UNSUBSCRIBE. upstream_ = quiche::QuicheWeakPtr<MoqtSessionInterface>(); // Sessions will delete listeners, causing the track to delete itself. @@ -301,7 +301,7 @@ MoqtSessionInterface* session = upstream_.GetIfAvailable(); if (session == nullptr) { // upstream went away, reject the subscribe. - listener->OnSubscribeRejected(MoqtRequestError{ + listener->OnSubscribeRejected(MoqtErrorPair{ RequestErrorCode::kInternalError, "The upstream session was closed before a subscription could be " "established."});
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher.h b/quiche/quic/moqt/moqt_relay_track_publisher.h index 0aa2c0c..7b77829 100644 --- a/quiche/quic/moqt/moqt_relay_track_publisher.h +++ b/quiche/quic/moqt/moqt_relay_track_publisher.h
@@ -67,9 +67,8 @@ MoqtRelayTrackPublisher& operator=(MoqtRelayTrackPublisher&&) = default; // SubscribeVisitor implementation. - void OnReply( - const FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) override; + void OnReply(const FullTrackName& full_track_name, + std::variant<SubscribeOkData, MoqtErrorPair> response) override; // TODO(vasilvv): Implement this if we want to support Object Acks across // relays. void OnCanAckObjects(MoqtObjectAckFunction /*ack_function*/) override {}
diff --git a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc index c5add6d..c75c70c 100644 --- a/quiche/quic/moqt/moqt_relay_track_publisher_test.cc +++ b/quiche/quic/moqt/moqt_relay_track_publisher_test.cc
@@ -28,8 +28,7 @@ class MockMoqtObjectListener : public MoqtObjectListener { public: MOCK_METHOD(void, OnSubscribeAccepted, (), (override)); - MOCK_METHOD(void, OnSubscribeRejected, (MoqtSubscribeErrorReason reason), - (override)); + MOCK_METHOD(void, OnSubscribeRejected, (MoqtErrorPair reason), (override)); MOCK_METHOD(void, OnNewObjectAvailable, (Location sequence, uint64_t subgroup, MoqtPriority publisher_priority, @@ -310,9 +309,8 @@ EXPECT_CALL(listener_, OnSubscribeRejected).WillOnce([this] { publisher_.RemoveObjectListener(&listener_); }); - publisher_.OnReply( - kTrackName, - MoqtRequestError{RequestErrorCode::kUnauthorized, "Unauthorized"}); + publisher_.OnReply(kTrackName, MoqtErrorPair{RequestErrorCode::kUnauthorized, + "Unauthorized"}); EXPECT_TRUE(track_deleted_); }
diff --git a/quiche/quic/moqt/moqt_session.cc b/quiche/quic/moqt/moqt_session.cc index b1c1ef6..9017753 100644 --- a/quiche/quic/moqt/moqt_session.cc +++ b/quiche/quic/moqt/moqt_session.cc
@@ -325,9 +325,8 @@ if (outgoing_publish_namespaces_.contains(track_namespace)) { std::move(callback)( track_namespace, - MoqtRequestError{ - RequestErrorCode::kInternalError, - "PUBLISH_NAMESPACE already outstanding for namespace"}); + MoqtErrorPair{RequestErrorCode::kInternalError, + "PUBLISH_NAMESPACE already outstanding for namespace"}); return; } if (next_request_id_ >= peer_max_request_id_) { @@ -735,8 +734,7 @@ if (subscribe->ErrorIsAllowed()) { subscribe->visitor()->OnReply( subscribe->full_track_name(), - MoqtRequestError{RequestErrorCode::kNotSupported, - "Subscription closed"}); + MoqtErrorPair{RequestErrorCode::kNotSupported, "Subscription closed"}); } else { subscribe->visitor()->OnPublishDone(subscribe->full_track_name()); } @@ -1169,7 +1167,7 @@ if (subscribe->visitor() != nullptr) { subscribe->visitor()->OnReply( subscribe->full_track_name(), - MoqtRequestError{message.error_code, message.reason_phrase}); + MoqtErrorPair{message.error_code, message.reason_phrase}); } if (!session_->is_closing_) { // The visitor might have closed the session. @@ -1236,7 +1234,7 @@ session_->GetWeakPtr(); session_->callbacks_.incoming_publish_namespace_callback( message.track_namespace, message.parameters, - [&](std::optional<MoqtRequestError> error) { + [&](std::optional<MoqtErrorPair> error) { MoqtSession* session = static_cast<MoqtSession*>(session_weakptr.GetIfAvailable()); if (session == nullptr) { @@ -1297,7 +1295,7 @@ } std::move(it2->second)( track_namespace, - MoqtRequestError{message.error_code, std::string(message.error_reason)}); + MoqtErrorPair{message.error_code, std::string(message.error_reason)}); session_->outgoing_publish_namespaces_.erase(it2); } @@ -1321,7 +1319,7 @@ } std::move(it->second)( message.track_namespace, - MoqtRequestError{message.error_code, std::string(message.error_reason)}); + MoqtErrorPair{message.error_code, std::string(message.error_reason)}); session_->outgoing_publish_namespaces_.erase(it); } @@ -1408,7 +1406,7 @@ } (session_->callbacks_.incoming_subscribe_namespace_callback)( message.track_namespace, message.parameters, - [&](std::optional<MoqtRequestError> error) { + [&](std::optional<MoqtErrorPair> error) { if (error.has_value()) { MoqtSubscribeNamespaceError reply; reply.request_id = message.request_id; @@ -2073,7 +2071,7 @@ } void MoqtSession::PublishedSubscription::OnSubscribeRejected( - MoqtSubscribeErrorReason reason) { + MoqtErrorPair reason) { session_->GetControlStream()->SendSubscribeError( request_id_, reason.error_code, reason.reason_phrase); session_->published_subscriptions_.erase(request_id_); @@ -2573,8 +2571,8 @@ std::nullopt, nullptr); } for (auto& [track_namespace, callback] : outgoing_publish_namespaces_) { - callback(track_namespace, MoqtRequestError{RequestErrorCode::kUninterested, - "Session closed"}); + callback(track_namespace, + MoqtErrorPair{RequestErrorCode::kUninterested, "Session closed"}); } while (!upstream_by_id_.empty()) { auto upstream = upstream_by_id_.begin();
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h index 710e543..8c8f17f 100644 --- a/quiche/quic/moqt/moqt_session.h +++ b/quiche/quic/moqt/moqt_session.h
@@ -372,7 +372,7 @@ // MoqtObjectListener implementation. void OnSubscribeAccepted() override; - void OnSubscribeRejected(MoqtSubscribeErrorReason reason) override; + void OnSubscribeRejected(MoqtErrorPair reason) override; // This is only called for objects that have just arrived. void OnNewObjectAvailable( Location location, uint64_t subgroup, MoqtPriority publisher_priority, @@ -648,7 +648,7 @@ // No class access below this line! } - void OnSubscribeRejected(MoqtSubscribeErrorReason error_reason) override { + void OnSubscribeRejected(MoqtErrorPair error_reason) override { MoqtTrackStatusError track_status_error; track_status_error.request_id = request_id_; track_status_error.error_code = error_reason.error_code; @@ -669,8 +669,8 @@ void OnGroupAbandoned(uint64_t /*group_id*/) override {} void OnTrackPublisherGone() override { publisher_ = nullptr; - OnSubscribeRejected(MoqtSubscribeErrorReason( - RequestErrorCode::kTrackDoesNotExist, "Track publisher gone")); + OnSubscribeRejected(MoqtErrorPair(RequestErrorCode::kTrackDoesNotExist, + "Track publisher gone")); } private:
diff --git a/quiche/quic/moqt/moqt_session_callbacks.h b/quiche/quic/moqt/moqt_session_callbacks.h index e8a238d..541308a 100644 --- a/quiche/quic/moqt/moqt_session_callbacks.h +++ b/quiche/quic/moqt/moqt_session_callbacks.h
@@ -20,7 +20,7 @@ // once; if the argument is nullopt, an OK response was received. Otherwise, an // ERROR response was received. using MoqtResponseCallback = - quiche::SingleUseCallback<void(std::optional<MoqtRequestError>)>; + quiche::SingleUseCallback<void(std::optional<MoqtErrorPair>)>; // Called when the SETUP message from the peer is received. using MoqtSessionEstablishedCallback = quiche::SingleUseCallback<void()>; @@ -59,7 +59,7 @@ if (callback == nullptr) { return; } - return std::move(callback)(MoqtRequestError{ + return std::move(callback)(MoqtErrorPair{ RequestErrorCode::kNotSupported, "This endpoint does not support incoming SUBSCRIBE_NAMESPACE messages"}); };
diff --git a/quiche/quic/moqt/moqt_session_interface.h b/quiche/quic/moqt/moqt_session_interface.h index 677ba61..3e6736b 100644 --- a/quiche/quic/moqt/moqt_session_interface.h +++ b/quiche/quic/moqt/moqt_session_interface.h
@@ -41,7 +41,7 @@ // automatically retry. virtual void OnReply( const FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) = 0; + std::variant<SubscribeOkData, MoqtErrorPair> response) = 0; // Called when the subscription process is far enough that it is possible to // send OBJECT_ACK messages; provides a callback to do so. The callback is // valid for as long as the session is valid. @@ -79,9 +79,8 @@ // PUBLISH_NAMESPACE state immediately after calling this callback. // Alternatively, the application can call PublishNamespaceDone() to delete the // state. -using MoqtOutgoingPublishNamespaceCallback = - quiche::MultiUseCallback<void(const TrackNamespace& track_namespace, - std::optional<MoqtRequestError> error)>; +using MoqtOutgoingPublishNamespaceCallback = quiche::MultiUseCallback<void( + const TrackNamespace& track_namespace, std::optional<MoqtErrorPair> error)>; using MoqtOutgoingSubscribeNamespaceCallback = quiche::SingleUseCallback<void( TrackNamespace track_namespace, std::optional<RequestErrorCode> error,
diff --git a/quiche/quic/moqt/moqt_session_test.cc b/quiche/quic/moqt/moqt_session_test.cc index 6ec6709..887debc 100644 --- a/quiche/quic/moqt/moqt_session_test.cc +++ b/quiche/quic/moqt/moqt_session_test.cc
@@ -392,7 +392,7 @@ TEST_F(MoqtSessionTest, PublishNamespaceWithOkAndCancel) { testing::MockFunction<void(TrackNamespace track_namespace, - std::optional<MoqtRequestError> error_message)> + std::optional<MoqtErrorPair> error_message)> publish_namespace_resolved_callback; std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); @@ -409,7 +409,7 @@ }; EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtRequestError> error) { + std::optional<MoqtErrorPair> error) { EXPECT_EQ(track_namespace, TrackNamespace("foo")); EXPECT_FALSE(error.has_value()); }); @@ -422,7 +422,7 @@ }; EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtRequestError> error) { + std::optional<MoqtErrorPair> error) { EXPECT_EQ(track_namespace, TrackNamespace("foo")); ASSERT_TRUE(error.has_value()); EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError); @@ -435,7 +435,7 @@ TEST_F(MoqtSessionTest, PublishNamespaceWithOkAndPublishNamespaceDone) { testing::MockFunction<void(TrackNamespace track_namespace, - std::optional<MoqtRequestError> error_message)> + std::optional<MoqtErrorPair> error_message)> publish_namespace_resolved_callback; std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); @@ -452,7 +452,7 @@ }; EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtRequestError> error) { + std::optional<MoqtErrorPair> error) { EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); EXPECT_FALSE(error.has_value()); }); @@ -469,7 +469,7 @@ TEST_F(MoqtSessionTest, PublishNamespaceWithError) { testing::MockFunction<void(TrackNamespace track_namespace, - std::optional<MoqtRequestError> error_message)> + std::optional<MoqtErrorPair> error_message)> publish_namespace_resolved_callback; std::unique_ptr<MoqtControlParserVisitor> stream_input = MoqtSessionPeer::CreateControlStream(&session_, &mock_stream_); @@ -488,7 +488,7 @@ }; EXPECT_CALL(publish_namespace_resolved_callback, Call(_, _)) .WillOnce([&](TrackNamespace track_namespace, - std::optional<MoqtRequestError> error) { + std::optional<MoqtErrorPair> error) { EXPECT_EQ(track_namespace, TrackNamespace{"foo"}); ASSERT_TRUE(error.has_value()); EXPECT_EQ(error->error_code, RequestErrorCode::kInternalError); @@ -531,7 +531,7 @@ mock_stream_, Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _)); listener->OnSubscribeRejected( - MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error")); + MoqtErrorPair(RequestErrorCode::kInternalError, "Test error")); EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId), nullptr); } @@ -547,8 +547,8 @@ mock_stream_, Writev(ControlMessageOfType(MoqtMessageType::kSubscribeError), _)); EXPECT_CALL(*track, RemoveObjectListener); - listener->OnSubscribeRejected(MoqtSubscribeErrorReason( - RequestErrorCode::kInternalError, "Test error")); + listener->OnSubscribeRejected( + MoqtErrorPair(RequestErrorCode::kInternalError, "Test error")); }); stream_input->OnSubscribeMessage(request); EXPECT_EQ(MoqtSessionPeer::GetSubscription(&session_, kDefaultPeerRequestId), @@ -745,7 +745,7 @@ }; EXPECT_CALL(remote_track_visitor_, OnReply) .WillOnce([&](const FullTrackName& ftn, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { EXPECT_EQ(ftn, FullTrackName("foo", "bar")); EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response)); }); @@ -780,7 +780,7 @@ }; EXPECT_CALL(remote_track_visitor_, OnReply) .WillOnce([&](const FullTrackName& ftn, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { EXPECT_EQ(ftn, FullTrackName("foo", "bar")); EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response)); }); @@ -918,10 +918,10 @@ }; EXPECT_CALL(remote_track_visitor_, OnReply) .WillOnce([&](const FullTrackName& ftn, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { EXPECT_EQ(ftn, FullTrackName("foo", "bar")); - EXPECT_TRUE(std::holds_alternative<MoqtRequestError>(response) && - std::get<MoqtRequestError>(response).reason_phrase == + EXPECT_TRUE(std::holds_alternative<MoqtErrorPair>(response) && + std::get<MoqtErrorPair>(response).reason_phrase == "deadbeef"); }); stream_input->OnSubscribeErrorMessage(error); @@ -1022,7 +1022,7 @@ track_namespace, *parameters, }; - MoqtRequestError error = { + MoqtErrorPair error = { RequestErrorCode::kNotSupported, "deadbeef", }; @@ -2814,7 +2814,7 @@ std::optional<VersionSpecificParameters>, MoqtResponseCallback callback) { std::move(callback)( - MoqtSubscribeErrorReason{RequestErrorCode::kUnauthorized, "foo"}); + MoqtErrorPair{RequestErrorCode::kUnauthorized, "foo"}); }); EXPECT_CALL( control_stream, @@ -3492,7 +3492,7 @@ session_.PublishNamespace( TrackNamespace{"foo"}, +[](TrackNamespace /*track_namespace*/, - std::optional<MoqtRequestError> /*error*/) {}, + std::optional<MoqtErrorPair> /*error*/) {}, VersionSpecificParameters()); EXPECT_FALSE(session_.Fetch( FullTrackName{TrackNamespace("foo"), "bar"}, @@ -3558,7 +3558,7 @@ session_.PublishNamespace( TrackNamespace{"foo"}, +[](TrackNamespace /*track_namespace*/, - std::optional<MoqtRequestError> /*error*/) {}, + std::optional<MoqtErrorPair> /*error*/) {}, VersionSpecificParameters()); EXPECT_FALSE(session_.Fetch( FullTrackName(TrackNamespace("foo"), "bar"), @@ -3953,8 +3953,8 @@ Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _)); EXPECT_CALL(*track, RemoveObjectListener); - listener->OnSubscribeRejected(MoqtSubscribeErrorReason( - RequestErrorCode::kInternalError, "Test error")); + listener->OnSubscribeRejected( + MoqtErrorPair(RequestErrorCode::kInternalError, "Test error")); executed_AddObjectListener = true; }); stream_input->OnTrackStatusMessage(track_status); @@ -3978,7 +3978,7 @@ Writev(ControlMessageOfType(MoqtMessageType::kTrackStatusError), _)); EXPECT_CALL(*track, RemoveObjectListener(listener)); listener->OnSubscribeRejected( - MoqtSubscribeErrorReason(RequestErrorCode::kInternalError, "Test error")); + MoqtErrorPair(RequestErrorCode::kInternalError, "Test error")); } TEST_F(MoqtSessionTest, FinReportedToVisitor) { @@ -3998,7 +3998,7 @@ }; EXPECT_CALL(remote_track_visitor_, OnReply) .WillOnce([&](const FullTrackName& ftn, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { EXPECT_EQ(ftn, FullTrackName("foo", "bar")); EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response)); }); @@ -4043,7 +4043,7 @@ }; EXPECT_CALL(remote_track_visitor_, OnReply) .WillOnce([&](const FullTrackName& ftn, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { EXPECT_EQ(ftn, FullTrackName("foo", "bar")); EXPECT_TRUE(std::holds_alternative<SubscribeOkData>(response)); });
diff --git a/quiche/quic/moqt/relay_namespace_tree.h b/quiche/quic/moqt/relay_namespace_tree.h index bdee98e..e755bd0 100644 --- a/quiche/quic/moqt/relay_namespace_tree.h +++ b/quiche/quic/moqt/relay_namespace_tree.h
@@ -157,7 +157,7 @@ if (!node->publishers.empty()) { subscriber->PublishNamespace( track_namespace, - [](const TrackNamespace&, std::optional<MoqtRequestError>) {}, + [](const TrackNamespace&, std::optional<MoqtErrorPair>) {}, // TODO(martinduke): Add parameters. VersionSpecificParameters()); } @@ -189,7 +189,7 @@ if (adding) { subscriber->PublishNamespace( track_namespace, - [](const TrackNamespace&, std::optional<MoqtRequestError>) {}, + [](const TrackNamespace&, std::optional<MoqtErrorPair>) {}, // TODO(martinduke): Add parameters. VersionSpecificParameters()); } else {
diff --git a/quiche/quic/moqt/test_tools/moqt_mock_visitor.h b/quiche/quic/moqt/test_tools/moqt_mock_visitor.h index 7ac2412..164a69e 100644 --- a/quiche/quic/moqt/test_tools/moqt_mock_visitor.h +++ b/quiche/quic/moqt/test_tools/moqt_mock_visitor.h
@@ -188,7 +188,7 @@ public: MOCK_METHOD(void, OnReply, (const FullTrackName& full_track_name, - (std::variant<SubscribeOkData, MoqtRequestError> response)), + (std::variant<SubscribeOkData, MoqtErrorPair> response)), (override)); MOCK_METHOD(void, OnCanAckObjects, (MoqtObjectAckFunction ack_function), (override)); @@ -275,7 +275,7 @@ class MockMoqtObjectListener : public MoqtObjectListener { public: MOCK_METHOD(void, OnSubscribeAccepted, (), (override)); - MOCK_METHOD(void, OnSubscribeRejected, (MoqtRequestError), (override)); + MOCK_METHOD(void, OnSubscribeRejected, (MoqtErrorPair), (override)); MOCK_METHOD(void, OnNewObjectAvailable, (Location, uint64_t, MoqtPriority, MoqtForwardingPreference), (override));
diff --git a/quiche/quic/moqt/test_tools/moqt_simulator.cc b/quiche/quic/moqt/test_tools/moqt_simulator.cc index 80fac10..7853ca0 100644 --- a/quiche/quic/moqt/test_tools/moqt_simulator.cc +++ b/quiche/quic/moqt/test_tools/moqt_simulator.cc
@@ -196,10 +196,10 @@ void ObjectReceiver::OnReply( const FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { QUICHE_CHECK(full_track_name == TrackName()); - if (std::holds_alternative<MoqtRequestError>(response)) { - MoqtRequestError error = std::get<MoqtRequestError>(response); + if (std::holds_alternative<MoqtErrorPair>(response)) { + MoqtErrorPair error = std::get<MoqtErrorPair>(response); QUICHE_CHECK(!error.reason_phrase.empty()) << error.reason_phrase; } }
diff --git a/quiche/quic/moqt/test_tools/moqt_simulator.h b/quiche/quic/moqt/test_tools/moqt_simulator.h index af88bb7..d8e8b91 100644 --- a/quiche/quic/moqt/test_tools/moqt_simulator.h +++ b/quiche/quic/moqt/test_tools/moqt_simulator.h
@@ -155,9 +155,8 @@ quic::QuicTimeDelta deadline) : clock_(clock), deadline_(deadline) {} - void OnReply( - const FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) override; + void OnReply(const FullTrackName& full_track_name, + std::variant<SubscribeOkData, MoqtErrorPair> response) override; void OnCanAckObjects(MoqtObjectAckFunction ack_function) override { object_ack_function_ = std::move(ack_function);
diff --git a/quiche/quic/moqt/tools/chat_client.cc b/quiche/quic/moqt/tools/chat_client.cc index c355631..fee47e8 100644 --- a/quiche/quic/moqt/tools/chat_client.cc +++ b/quiche/quic/moqt/tools/chat_client.cc
@@ -68,7 +68,7 @@ std::cout << "PUBLISH_NAMESPACE for " << track_namespace.ToString() << "\n"; if (!track_name.has_value()) { std::cout << "PUBLISH_NAMESPACE rejected, invalid namespace\n"; - std::move(callback)(std::make_optional<MoqtPublishNamespaceErrorReason>( + std::move(callback)(std::make_optional<MoqtErrorPair>( RequestErrorCode::kTrackDoesNotExist, "Not a subscribed namespace")); return; } @@ -185,7 +185,7 @@ void ChatClient::RemoteTrackVisitor::OnReply( const FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) { + std::variant<SubscribeOkData, MoqtErrorPair> response) { auto it = client_->other_users_.find(full_track_name); if (it == client_->other_users_.end()) { std::cout << "Error: received reply for unknown user " @@ -197,9 +197,9 @@ if (std::holds_alternative<SubscribeOkData>(response)) { std::cout << "ACCEPTED\n"; } else { - auto request_error = std::get<MoqtRequestError>(response); + auto request_error = std::get<MoqtErrorPair>(response); std::cout << "REJECTED, reason = " - << std::get<MoqtRequestError>(response).reason_phrase << "\n"; + << std::get<MoqtErrorPair>(response).reason_phrase << "\n"; client_->other_users_.erase(it); } } @@ -247,7 +247,7 @@ session_->set_publisher(&publisher_); MoqtOutgoingPublishNamespaceCallback publish_namespace_callback = [this](TrackNamespace track_namespace, - std::optional<MoqtPublishNamespaceErrorReason> reason) { + std::optional<MoqtErrorPair> reason) { if (reason.has_value()) { std::cout << "PUBLISH_NAMESPACE rejected, " << reason->reason_phrase << "\n";
diff --git a/quiche/quic/moqt/tools/chat_client.h b/quiche/quic/moqt/tools/chat_client.h index e71baca..a26a7a6 100644 --- a/quiche/quic/moqt/tools/chat_client.h +++ b/quiche/quic/moqt/tools/chat_client.h
@@ -100,7 +100,7 @@ void OnReply( const moqt::FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) override; + std::variant<SubscribeOkData, MoqtErrorPair> response) override; void OnCanAckObjects(MoqtObjectAckFunction) override {}
diff --git a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc index dd7757e..2a61655 100644 --- a/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc +++ b/quiche/quic/moqt/tools/moqt_ingestion_server_bin.cc
@@ -129,9 +129,9 @@ << "Rejected remote publish_namespace as it contained " "disallowed characters; namespace: " << track_namespace; - std::move(callback)(MoqtPublishNamespaceErrorReason{ - RequestErrorCode::kInternalError, - "Track namespace contains disallowed characters"}); + std::move(callback)( + MoqtErrorPair{RequestErrorCode::kInternalError, + "Track namespace contains disallowed characters"}); return; } @@ -151,9 +151,8 @@ subscribed_namespaces_.erase(it); QUICHE_LOG(ERROR) << "Failed to create directory " << directory_path << "; " << status; - std::move(callback)( - MoqtPublishNamespaceErrorReason{RequestErrorCode::kInternalError, - "Failed to create output directory"}); + std::move(callback)(MoqtErrorPair{RequestErrorCode::kInternalError, + "Failed to create output directory"}); return; } @@ -176,11 +175,11 @@ void OnReply( const FullTrackName& full_track_name, - std::variant<SubscribeOkData, MoqtRequestError> response) override { - if (std::holds_alternative<MoqtRequestError>(response)) { + std::variant<SubscribeOkData, MoqtErrorPair> response) override { + if (std::holds_alternative<MoqtErrorPair>(response)) { QUICHE_LOG(ERROR) << "Failed to subscribe to the peer track " << full_track_name << ": " - << std::get<MoqtRequestError>(response).reason_phrase; + << std::get<MoqtErrorPair>(response).reason_phrase; } }
diff --git a/quiche/quic/moqt/tools/moqt_relay_test.cc b/quiche/quic/moqt/tools/moqt_relay_test.cc index ddb4928..e50b1f4 100644 --- a/quiche/quic/moqt/tools/moqt_relay_test.cc +++ b/quiche/quic/moqt/tools/moqt_relay_test.cc
@@ -131,7 +131,7 @@ // relay_ publishes a namespace, so upstream_ will route to relay_. relay_.client_session()->PublishNamespace( TrackNamespace({"foo"}), - [](TrackNamespace, std::optional<MoqtRequestError>) {}, + [](TrackNamespace, std::optional<MoqtErrorPair>) {}, VersionSpecificParameters()); upstream_.RunOneEvent(); // There is now an upstream session for "Foo". @@ -187,7 +187,7 @@ // Downstream publishes a namespace. It's stored in relay_ but upstream_ // hasn't been notified. downstream_.client_session()->PublishNamespace( - foobar, [](TrackNamespace, std::optional<MoqtRequestError>) {}, + foobar, [](TrackNamespace, std::optional<MoqtErrorPair>) {}, VersionSpecificParameters()); relay_.RunOneEvent(); upstream_.RunOneEvent(); @@ -205,7 +205,7 @@ // Downstream publishes another namespace. Everyone is notified. downstream_.client_session()->PublishNamespace( - foobaz, [](TrackNamespace, std::optional<MoqtRequestError>) {}, + foobaz, [](TrackNamespace, std::optional<MoqtErrorPair>) {}, VersionSpecificParameters()); relay_.RunOneEvent(); upstream_.RunOneEvent();