Skip to content

Commit a927077

Browse files
martindukecopybara-github
martinduke
authored and
copybara-github
committed
Consolidate MOQT *_ERROR message into REQUEST_ERROR.
Part of draft-16 update. PiperOrigin-RevId: 856330097
1 parent 41914a4 commit a927077

22 files changed

+250
-840
lines changed

‎quiche/quic/moqt/moqt_fetch_task.h‎

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
#ifndef QUICHE_QUIC_MOQT_MOQT_FETCH_TASK_H_
66
#define QUICHE_QUIC_MOQT_MOQT_FETCH_TASK_H_
77

8+
#include <string>
89
#include <utility>
910
#include <variant>
1011

@@ -22,7 +23,7 @@ class MoqtFetchTask {
2223
using ObjectsAvailableCallback = quiche::MultiUseCallback<void()>;
2324
// The request_id field will be ignored.
2425
using FetchResponseCallback = quiche::SingleUseCallback<void(
25-
std::variant<MoqtFetchOk, MoqtFetchError>)>;
26+
std::variant<MoqtFetchOk, MoqtRequestError>)>;
2627

2728
virtual ~MoqtFetchTask() = default;
2829

@@ -74,10 +75,8 @@ class MoqtFailedFetch : public MoqtFetchTask {
7475
void SetObjectAvailableCallback(
7576
ObjectsAvailableCallback /*callback*/) override {}
7677
void SetFetchResponseCallback(FetchResponseCallback callback) override {
77-
MoqtFetchError error;
78-
error.request_id = 0;
79-
error.error_code = StatusToRequestErrorCode(status_);
80-
error.error_reason = status_.message();
78+
MoqtRequestError error{/*request_id=*/0, StatusToRequestErrorCode(status_),
79+
std::string(status_.message())};
8180
std::move(callback)(error);
8281
}
8382

‎quiche/quic/moqt/moqt_framer.cc‎

Lines changed: 3 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -495,10 +495,10 @@ quiche::QuicheBuffer MoqtFramer::SerializeSubscribeOk(
495495
WireKeyValuePairList(parameters));
496496
}
497497

498-
quiche::QuicheBuffer MoqtFramer::SerializeSubscribeError(
499-
const MoqtSubscribeError& message, MoqtMessageType message_type) {
498+
quiche::QuicheBuffer MoqtFramer::SerializeRequestError(
499+
const MoqtRequestError& message) {
500500
return SerializeControlMessage(
501-
message_type, WireVarInt62(message.request_id),
501+
MoqtMessageType::kRequestError, WireVarInt62(message.request_id),
502502
WireVarInt62(message.error_code),
503503
WireStringWithVarInt62Length(message.reason_phrase));
504504
}
@@ -558,14 +558,6 @@ quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceOk(
558558
WireVarInt62(message.request_id));
559559
}
560560

561-
quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceError(
562-
const MoqtPublishNamespaceError& message) {
563-
return SerializeControlMessage(
564-
MoqtMessageType::kPublishNamespaceError, WireVarInt62(message.request_id),
565-
WireVarInt62(message.error_code),
566-
WireStringWithVarInt62Length(message.error_reason));
567-
}
568-
569561
quiche::QuicheBuffer MoqtFramer::SerializePublishNamespaceDone(
570562
const MoqtPublishNamespaceDone& message) {
571563
return SerializeControlMessage(MoqtMessageType::kPublishNamespaceDone,
@@ -591,11 +583,6 @@ quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusOk(
591583
return SerializeSubscribeOk(message, MoqtMessageType::kTrackStatusOk);
592584
}
593585

594-
quiche::QuicheBuffer MoqtFramer::SerializeTrackStatusError(
595-
const MoqtTrackStatusError& message) {
596-
return SerializeSubscribeError(message, MoqtMessageType::kTrackStatusError);
597-
}
598-
599586
quiche::QuicheBuffer MoqtFramer::SerializeGoAway(const MoqtGoAway& message) {
600587
return SerializeControlMessage(
601588
MoqtMessageType::kGoAway,
@@ -624,14 +611,6 @@ quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceOk(
624611
WireVarInt62(message.request_id));
625612
}
626613

627-
quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceError(
628-
const MoqtSubscribeNamespaceError& message) {
629-
return SerializeControlMessage(
630-
MoqtMessageType::kSubscribeNamespaceError,
631-
WireVarInt62(message.request_id), WireVarInt62(message.error_code),
632-
WireStringWithVarInt62Length(message.error_reason));
633-
}
634-
635614
quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeNamespace(
636615
const MoqtUnsubscribeNamespace& message) {
637616
return SerializeControlMessage(MoqtMessageType::kUnsubscribeNamespace,
@@ -716,14 +695,6 @@ quiche::QuicheBuffer MoqtFramer::SerializeFetchOk(const MoqtFetchOk& message) {
716695
WireKeyValuePairList(parameters));
717696
}
718697

719-
quiche::QuicheBuffer MoqtFramer::SerializeFetchError(
720-
const MoqtFetchError& message) {
721-
return SerializeControlMessage(
722-
MoqtMessageType::kFetchError, WireVarInt62(message.request_id),
723-
WireVarInt62(message.error_code),
724-
WireStringWithVarInt62Length(message.error_reason));
725-
}
726-
727698
quiche::QuicheBuffer MoqtFramer::SerializeFetchCancel(
728699
const MoqtFetchCancel& message) {
729700
return SerializeControlMessage(MoqtMessageType::kFetchCancel,
@@ -812,14 +783,6 @@ quiche::QuicheBuffer MoqtFramer::SerializePublishOk(
812783
WireOptional<WireVarInt62>(end_group), WireKeyValuePairList(parameters));
813784
}
814785

815-
quiche::QuicheBuffer MoqtFramer::SerializePublishError(
816-
const MoqtPublishError& message) {
817-
return SerializeControlMessage(
818-
MoqtMessageType::kPublishError, WireVarInt62(message.request_id),
819-
WireVarInt62(message.error_code),
820-
WireStringWithVarInt62Length(message.error_reason));
821-
}
822-
823786
quiche::QuicheBuffer MoqtFramer::SerializeObjectAck(
824787
const MoqtObjectAck& message) {
825788
return SerializeControlMessage(

‎quiche/quic/moqt/moqt_framer.h‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -48,9 +48,7 @@ class QUICHE_EXPORT MoqtFramer {
4848
quiche::QuicheBuffer SerializeSubscribeOk(
4949
const MoqtSubscribeOk& message,
5050
MoqtMessageType message_type = MoqtMessageType::kSubscribeOk);
51-
quiche::QuicheBuffer SerializeSubscribeError(
52-
const MoqtSubscribeError& message,
53-
MoqtMessageType message_type = MoqtMessageType::kSubscribeError);
51+
quiche::QuicheBuffer SerializeRequestError(const MoqtRequestError& message);
5452
quiche::QuicheBuffer SerializeUnsubscribe(const MoqtUnsubscribe& message);
5553
quiche::QuicheBuffer SerializePublishDone(const MoqtPublishDone& message);
5654
quiche::QuicheBuffer SerializeSubscribeUpdate(
@@ -59,35 +57,27 @@ class QUICHE_EXPORT MoqtFramer {
5957
const MoqtPublishNamespace& message);
6058
quiche::QuicheBuffer SerializePublishNamespaceOk(
6159
const MoqtPublishNamespaceOk& message);
62-
quiche::QuicheBuffer SerializePublishNamespaceError(
63-
const MoqtPublishNamespaceError& message);
6460
quiche::QuicheBuffer SerializePublishNamespaceDone(
6561
const MoqtPublishNamespaceDone& message);
6662
quiche::QuicheBuffer SerializePublishNamespaceCancel(
6763
const MoqtPublishNamespaceCancel& message);
6864
quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message);
6965
quiche::QuicheBuffer SerializeTrackStatusOk(const MoqtTrackStatusOk& message);
70-
quiche::QuicheBuffer SerializeTrackStatusError(
71-
const MoqtTrackStatusError& message);
7266
quiche::QuicheBuffer SerializeGoAway(const MoqtGoAway& message);
7367
quiche::QuicheBuffer SerializeSubscribeNamespace(
7468
const MoqtSubscribeNamespace& message);
7569
quiche::QuicheBuffer SerializeSubscribeNamespaceOk(
7670
const MoqtSubscribeNamespaceOk& message);
77-
quiche::QuicheBuffer SerializeSubscribeNamespaceError(
78-
const MoqtSubscribeNamespaceError& message);
7971
quiche::QuicheBuffer SerializeUnsubscribeNamespace(
8072
const MoqtUnsubscribeNamespace& message);
8173
quiche::QuicheBuffer SerializeMaxRequestId(const MoqtMaxRequestId& message);
8274
quiche::QuicheBuffer SerializeFetch(const MoqtFetch& message);
8375
quiche::QuicheBuffer SerializeFetchCancel(const MoqtFetchCancel& message);
8476
quiche::QuicheBuffer SerializeFetchOk(const MoqtFetchOk& message);
85-
quiche::QuicheBuffer SerializeFetchError(const MoqtFetchError& message);
8677
quiche::QuicheBuffer SerializeRequestsBlocked(
8778
const MoqtRequestsBlocked& message);
8879
quiche::QuicheBuffer SerializePublish(const MoqtPublish& message);
8980
quiche::QuicheBuffer SerializePublishOk(const MoqtPublishOk& message);
90-
quiche::QuicheBuffer SerializePublishError(const MoqtPublishError& message);
9181
quiche::QuicheBuffer SerializeObjectAck(const MoqtObjectAck& message);
9282

9383
private:

‎quiche/quic/moqt/moqt_framer_test.cc‎

Lines changed: 4 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -36,31 +36,26 @@ std::vector<MoqtFramerTestParams> GetMoqtFramerTestParams() {
3636
std::vector<MoqtMessageType> message_types = {
3737
MoqtMessageType::kSubscribe,
3838
MoqtMessageType::kSubscribeOk,
39-
MoqtMessageType::kSubscribeError,
39+
MoqtMessageType::kRequestError,
4040
MoqtMessageType::kUnsubscribe,
4141
MoqtMessageType::kPublishDone,
4242
MoqtMessageType::kPublishNamespace,
4343
MoqtMessageType::kPublishNamespaceOk,
44-
MoqtMessageType::kPublishNamespaceError,
4544
MoqtMessageType::kPublishNamespaceDone,
4645
MoqtMessageType::kPublishNamespaceCancel,
4746
MoqtMessageType::kTrackStatus,
4847
MoqtMessageType::kTrackStatusOk,
49-
MoqtMessageType::kTrackStatusError,
5048
MoqtMessageType::kGoAway,
5149
MoqtMessageType::kSubscribeNamespace,
5250
MoqtMessageType::kSubscribeNamespaceOk,
53-
MoqtMessageType::kSubscribeNamespaceError,
5451
MoqtMessageType::kUnsubscribeNamespace,
5552
MoqtMessageType::kMaxRequestId,
5653
MoqtMessageType::kFetch,
5754
MoqtMessageType::kFetchCancel,
5855
MoqtMessageType::kFetchOk,
59-
MoqtMessageType::kFetchError,
6056
MoqtMessageType::kRequestsBlocked,
6157
MoqtMessageType::kPublish,
6258
MoqtMessageType::kPublishOk,
63-
MoqtMessageType::kPublishError,
6459
MoqtMessageType::kObjectAck,
6560
MoqtMessageType::kClientSetup,
6661
MoqtMessageType::kServerSetup,
@@ -131,9 +126,9 @@ class MoqtFramerTest
131126
auto data = std::get<MoqtSubscribeOk>(structured_data);
132127
return framer_.SerializeSubscribeOk(data);
133128
}
134-
case MoqtMessageType::kSubscribeError: {
135-
auto data = std::get<MoqtSubscribeError>(structured_data);
136-
return framer_.SerializeSubscribeError(data);
129+
case MoqtMessageType::kRequestError: {
130+
auto data = std::get<MoqtRequestError>(structured_data);
131+
return framer_.SerializeRequestError(data);
137132
}
138133
case MoqtMessageType::kUnsubscribe: {
139134
auto data = std::get<MoqtUnsubscribe>(structured_data);
@@ -151,10 +146,6 @@ class MoqtFramerTest
151146
auto data = std::get<MoqtPublishNamespaceOk>(structured_data);
152147
return framer_.SerializePublishNamespaceOk(data);
153148
}
154-
case moqt::MoqtMessageType::kPublishNamespaceError: {
155-
auto data = std::get<MoqtPublishNamespaceError>(structured_data);
156-
return framer_.SerializePublishNamespaceError(data);
157-
}
158149
case MoqtMessageType::kPublishNamespaceDone: {
159150
auto data = std::get<MoqtPublishNamespaceDone>(structured_data);
160151
return framer_.SerializePublishNamespaceDone(data);
@@ -171,10 +162,6 @@ class MoqtFramerTest
171162
auto data = std::get<MoqtTrackStatusOk>(structured_data);
172163
return framer_.SerializeTrackStatusOk(data);
173164
}
174-
case moqt::MoqtMessageType::kTrackStatusError: {
175-
auto data = std::get<MoqtTrackStatusError>(structured_data);
176-
return framer_.SerializeTrackStatusError(data);
177-
}
178165
case moqt::MoqtMessageType::kGoAway: {
179166
auto data = std::get<MoqtGoAway>(structured_data);
180167
return framer_.SerializeGoAway(data);
@@ -187,10 +174,6 @@ class MoqtFramerTest
187174
auto data = std::get<MoqtSubscribeNamespaceOk>(structured_data);
188175
return framer_.SerializeSubscribeNamespaceOk(data);
189176
}
190-
case moqt::MoqtMessageType::kSubscribeNamespaceError: {
191-
auto data = std::get<MoqtSubscribeNamespaceError>(structured_data);
192-
return framer_.SerializeSubscribeNamespaceError(data);
193-
}
194177
case moqt::MoqtMessageType::kUnsubscribeNamespace: {
195178
auto data = std::get<MoqtUnsubscribeNamespace>(structured_data);
196179
return framer_.SerializeUnsubscribeNamespace(data);
@@ -211,10 +194,6 @@ class MoqtFramerTest
211194
auto data = std::get<MoqtFetchOk>(structured_data);
212195
return framer_.SerializeFetchOk(data);
213196
}
214-
case moqt::MoqtMessageType::kFetchError: {
215-
auto data = std::get<MoqtFetchError>(structured_data);
216-
return framer_.SerializeFetchError(data);
217-
}
218197
case moqt::MoqtMessageType::kRequestsBlocked: {
219198
auto data = std::get<MoqtRequestsBlocked>(structured_data);
220199
return framer_.SerializeRequestsBlocked(data);
@@ -227,10 +206,6 @@ class MoqtFramerTest
227206
auto data = std::get<MoqtPublishOk>(structured_data);
228207
return framer_.SerializePublishOk(data);
229208
}
230-
case moqt::MoqtMessageType::kPublishError: {
231-
auto data = std::get<MoqtPublishError>(structured_data);
232-
return framer_.SerializePublishError(data);
233-
}
234209
case moqt::MoqtMessageType::kObjectAck: {
235210
auto data = std::get<MoqtObjectAck>(structured_data);
236211
return framer_.SerializeObjectAck(data);

‎quiche/quic/moqt/moqt_messages.cc‎

Lines changed: 2 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -218,8 +218,8 @@ std::string MoqtMessageTypeToString(const MoqtMessageType message_type) {
218218
return "SUBSCRIBE";
219219
case MoqtMessageType::kSubscribeOk:
220220
return "SUBSCRIBE_OK";
221-
case MoqtMessageType::kSubscribeError:
222-
return "SUBSCRIBE_ERROR";
221+
case MoqtMessageType::kRequestError:
222+
return "REQUEST_ERROR";
223223
case MoqtMessageType::kUnsubscribe:
224224
return "UNSUBSCRIBE";
225225
case MoqtMessageType::kPublishDone:
@@ -232,14 +232,10 @@ std::string MoqtMessageTypeToString(const MoqtMessageType message_type) {
232232
return "TRACK_STATUS";
233233
case MoqtMessageType::kTrackStatusOk:
234234
return "TRACK_STATUS_OK";
235-
case MoqtMessageType::kTrackStatusError:
236-
return "TRACK_STATUS_ERROR";
237235
case MoqtMessageType::kPublishNamespace:
238236
return "PUBLISH_NAMESPACE";
239237
case MoqtMessageType::kPublishNamespaceOk:
240238
return "PUBLISH_NAMESPACE_OK";
241-
case MoqtMessageType::kPublishNamespaceError:
242-
return "PUBLISH_NAMESPACE_ERROR";
243239
case MoqtMessageType::kPublishNamespaceDone:
244240
return "PUBLISH_NAMESPACE_DONE";
245241
case MoqtMessageType::kGoAway:
@@ -248,8 +244,6 @@ std::string MoqtMessageTypeToString(const MoqtMessageType message_type) {
248244
return "SUBSCRIBE_NAMESPACE";
249245
case MoqtMessageType::kSubscribeNamespaceOk:
250246
return "SUBSCRIBE_NAMESPACE_OK";
251-
case MoqtMessageType::kSubscribeNamespaceError:
252-
return "SUBSCRIBE_NAMESPACE_ERROR";
253247
case MoqtMessageType::kUnsubscribeNamespace:
254248
return "UNSUBSCRIBE_NAMESPACE";
255249
case MoqtMessageType::kMaxRequestId:
@@ -258,16 +252,12 @@ std::string MoqtMessageTypeToString(const MoqtMessageType message_type) {
258252
return "PUBLISH";
259253
case MoqtMessageType::kPublishOk:
260254
return "PUBLISH_OK";
261-
case MoqtMessageType::kPublishError:
262-
return "PUBLISH_ERROR";
263255
case MoqtMessageType::kFetch:
264256
return "FETCH";
265257
case MoqtMessageType::kFetchCancel:
266258
return "FETCH_CANCEL";
267259
case MoqtMessageType::kFetchOk:
268260
return "FETCH_OK";
269-
case MoqtMessageType::kFetchError:
270-
return "FETCH_ERROR";
271261
case MoqtMessageType::kRequestsBlocked:
272262
return "REQUESTS_BLOCKED";
273263
case MoqtMessageType::kObjectAck:

0 commit comments

Comments
 (0)