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();
