OSSForks/node
1
0
Fork 0
mirror of https://github.com/zebrajr/node.git synced 2025-12-06 00:20:08 +01:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

deps: update inspector_protocol to af7f5a8173fdbc29f0835ec94395932e328b

Browse Source 
PR-URL: https://github.com/nodejs/node/pull/60312
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
This commit is contained in:
Node.js GitHub Bot 2025-10-21 01:44:16 +01:00 committed by GitHub
parent b9dedf416b
commit f1acefa9a9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
11 changed files with 116 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/inspector_protocol/README.node vendored
View File

@ -2,7 +2,7 @@ Name: inspector protocol
Short Name: inspector_protocol Short Name: inspector_protocol
URL: https://chromium.googlesource.com/deps/inspector_protocol/ URL: https://chromium.googlesource.com/deps/inspector_protocol/
Version: 0 Version: 0
Revision: 69d69ddf3aa698b171886551a4a672c5af1ad902 Revision: af7f5a8173fdbc29f0835ec94395932e328b2ea2
License: BSD License: BSD
License File: LICENSE License File: LICENSE
Security Critical: no Security Critical: no

4
deps/inspector_protocol/crdtp/cbor.cc vendored
View File

@ -833,7 +833,7 @@ void ParseUTF16String(CBORTokenizer* tokenizer, ParserHandler* out) {
span<uint8_t> rep = tokenizer->GetString16WireRep(); span<uint8_t> rep = tokenizer->GetString16WireRep();
for (size_t ii = 0; ii < rep.size(); ii += 2) for (size_t ii = 0; ii < rep.size(); ii += 2)
value.push_back((rep[ii + 1] << 8) | rep[ii]); value.push_back((rep[ii + 1] << 8) | rep[ii]);
out->HandleString16(span<uint16_t>(value.data(), value.size())); out->HandleString16(value);
tokenizer->Next(); tokenizer->Next();
} }
@ -1037,7 +1037,7 @@ void ParseCBOR(span<uint8_t> bytes, ParserHandler* out) {
Status AppendString8EntryToCBORMap(span<uint8_t> string8_key, Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
span<uint8_t> string8_value, span<uint8_t> string8_value,
std::vector<uint8_t>* cbor) { std::vector<uint8_t>* cbor) {
span<uint8_t> bytes(cbor->data(), cbor->size()); span<uint8_t> bytes(*cbor);
CBORTokenizer tokenizer(bytes); CBORTokenizer tokenizer(bytes);
if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE)
return tokenizer.Status(); return tokenizer.Status();

64
deps/inspector_protocol/crdtp/cbor_test.cc vendored
View File

@ -349,7 +349,7 @@ TEST(EncodeDecodeString16Test, RoundtripsHelloWorld) {
std::array<uint16_t, 10> msg{ std::array<uint16_t, 10> msg{
{'H', 'e', 'l', 'l', 'o', ',', ' ', 0xd83c, 0xdf0e, '.'}}; {'H', 'e', 'l', 'l', 'o', ',', ' ', 0xd83c, 0xdf0e, '.'}};
std::vector<uint8_t> encoded; std::vector<uint8_t> encoded;
EncodeString16(span<uint16_t>(msg.data(), msg.size()), &encoded); EncodeString16(msg, &encoded);
// This will be encoded as BYTE_STRING of length 20, so the 20 is encoded in // This will be encoded as BYTE_STRING of length 20, so the 20 is encoded in
// the additional info part of the initial byte. Payload is two bytes for each // the additional info part of the initial byte. Payload is two bytes for each
// UTF16 character. // UTF16 character.
@ -384,7 +384,7 @@ TEST(EncodeDecodeString16Test, Roundtrips500) {
for (uint16_t ii = 0; ii < 250; ++ii) for (uint16_t ii = 0; ii < 250; ++ii)
two_fifty.push_back(ii); two_fifty.push_back(ii);
std::vector<uint8_t> encoded; std::vector<uint8_t> encoded;
EncodeString16(span<uint16_t>(two_fifty.data(), two_fifty.size()), &encoded); EncodeString16(two_fifty, &encoded);
EXPECT_EQ(3u + 250u * 2, encoded.size()); EXPECT_EQ(3u + 250u * 2, encoded.size());
// Now check the first three bytes: // Now check the first three bytes:
// Major type: 2 (BYTE_STRING) // Major type: 2 (BYTE_STRING)
@ -501,7 +501,7 @@ TEST(EncodeFromLatin1Test, ConvertsToUTF8IfNeeded) {
TEST(EncodeFromUTF16Test, ConvertsToUTF8IfEasy) { TEST(EncodeFromUTF16Test, ConvertsToUTF8IfEasy) {
std::vector<uint16_t> ascii = {'e', 'a', 's', 'y'}; std::vector<uint16_t> ascii = {'e', 'a', 's', 'y'};
std::vector<uint8_t> encoded; std::vector<uint8_t> encoded;
EncodeFromUTF16(span<uint16_t>(ascii.data(), ascii.size()), &encoded); EncodeFromUTF16(ascii, &encoded);
CBORTokenizer tokenizer(SpanFrom(encoded)); CBORTokenizer tokenizer(SpanFrom(encoded));
EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag()); EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
@ -518,7 +518,7 @@ TEST(EncodeFromUTF16Test, EncodesAsString16IfNeeded) {
std::vector<uint16_t> msg = {'H', 'e', 'l', 'l', 'o', std::vector<uint16_t> msg = {'H', 'e', 'l', 'l', 'o',
',', ' ', 0xd83c, 0xdf0e, '.'}; ',', ' ', 0xd83c, 0xdf0e, '.'};
std::vector<uint8_t> encoded; std::vector<uint8_t> encoded;
EncodeFromUTF16(span<uint16_t>(msg.data(), msg.size()), &encoded); EncodeFromUTF16(msg, &encoded);
CBORTokenizer tokenizer(SpanFrom(encoded)); CBORTokenizer tokenizer(SpanFrom(encoded));
EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag()); EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
@ -535,7 +535,7 @@ TEST(EncodeDecodeBinaryTest, RoundtripsHelloWorld) {
std::vector<uint8_t> binary = {'H', 'e', 'l', 'l', 'o', ',', ' ', std::vector<uint8_t> binary = {'H', 'e', 'l', 'l', 'o', ',', ' ',
'w', 'o', 'r', 'l', 'd', '.'}; 'w', 'o', 'r', 'l', 'd', '.'};
std::vector<uint8_t> encoded; std::vector<uint8_t> encoded;
EncodeBinary(span<uint8_t>(binary.data(), binary.size()), &encoded); EncodeBinary(binary, &encoded);
// So, on the wire we see that the binary blob travels unmodified. // So, on the wire we see that the binary blob travels unmodified.
EXPECT_THAT( EXPECT_THAT(
encoded, encoded,
@ -699,7 +699,7 @@ TEST(JSONToCBOREncoderTest, SevenBitStrings) {
Status status; Status status;
std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status); std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
std::vector<uint16_t> utf16 = {'f', 'o', 'o'}; std::vector<uint16_t> utf16 = {'f', 'o', 'o'};
encoder->HandleString16(span<uint16_t>(utf16.data(), utf16.size())); encoder->HandleString16(utf16);
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
// Here we assert that indeed, seven bit strings are represented as // Here we assert that indeed, seven bit strings are represented as
// bytes on the wire, "foo" is just "foo". // bytes on the wire, "foo" is just "foo".
@ -771,7 +771,7 @@ TEST(JsonCborRoundtrip, EncodingDecoding) {
std::string decoded; std::string decoded;
std::unique_ptr<ParserHandler> json_encoder = std::unique_ptr<ParserHandler> json_encoder =
json::NewJSONEncoder(&decoded, &status); json::NewJSONEncoder(&decoded, &status);
ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_encoder.get()); ParseCBOR(encoded, json_encoder.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ(json, decoded); EXPECT_EQ(json, decoded);
} }
@ -791,7 +791,7 @@ TEST(JsonCborRoundtrip, MoreRoundtripExamples) {
std::string decoded; std::string decoded;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&decoded, &status); json::NewJSONEncoder(&decoded, &status);
ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_writer.get()); ParseCBOR(encoded, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ(json, decoded); EXPECT_EQ(json, decoded);
} }
@ -842,7 +842,7 @@ TEST(ParseCBORTest, ParseEmptyCBORMessage) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get()); ParseCBOR(in, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ("{}", out); EXPECT_EQ("{}", out);
} }
@ -866,7 +866,7 @@ TEST(ParseCBORTest, ParseCBORHelloWorld) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ("{\"msg\":\"Hello, \\ud83c\\udf0e.\"}", out); EXPECT_EQ("{\"msg\":\"Hello, \\ud83c\\udf0e.\"}", out);
} }
@ -887,7 +887,7 @@ TEST(ParseCBORTest, UTF8IsSupportedInKeys) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ("{\"\\ud83c\\udf0e\":\"\\u263e\"}", out); EXPECT_EQ("{\"\\ud83c\\udf0e\":\"\\u263e\"}", out);
} }
@ -898,7 +898,7 @@ TEST(ParseCBORTest, NoInputError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get()); ParseCBOR(in, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0u)); EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0u));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -914,7 +914,7 @@ TEST(ParseCBORTest, UnexpectedEofExpectedValueError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE, EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
bytes.size())); bytes.size()));
EXPECT_EQ("", out); EXPECT_EQ("", out);
@ -932,7 +932,7 @@ TEST(ParseCBORTest, UnexpectedEofInArrayError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, EXPECT_THAT(status,
StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, bytes.size())); StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, bytes.size()));
EXPECT_EQ("", out); EXPECT_EQ("", out);
@ -947,7 +947,7 @@ TEST(ParseCBORTest, UnexpectedEofInMapError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_MAP, 7u)); EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_MAP, 7u));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -963,7 +963,7 @@ TEST(ParseCBORTest, EnvelopeEncodingLegacy) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ(out, "{\"foo\":42}"); EXPECT_EQ(out, "{\"foo\":42}");
} }
@ -980,7 +980,7 @@ TEST(ParseCBORTest, EnvelopeEncodingBySpec) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ(out, "{\"foo\":42}"); EXPECT_EQ(out, "{\"foo\":42}");
} }
@ -991,7 +991,7 @@ TEST(ParseCBORTest, NoEmptyEnvelopesAllowed) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE, EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
bytes.size())); bytes.size()));
EXPECT_EQ("", out); EXPECT_EQ("", out);
@ -1021,7 +1021,7 @@ TEST(ParseCBORTest, OnlyMapsAndArraysSupportedInsideEnvelopes) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE, EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
error_pos)); error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
@ -1038,7 +1038,7 @@ TEST(ParseCBORTest, InvalidMapKeyError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_MAP_KEY, 7u)); EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_MAP_KEY, 7u));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1068,7 +1068,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
EXPECT_EQ("{\"key\":{\"key\":{\"key\":\"innermost_value\"}}}", out); EXPECT_EQ("{\"key\":{\"key\":{\"key\":\"innermost_value\"}}}", out);
} }
@ -1078,7 +1078,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
} }
@ -1097,7 +1097,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED, EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
opening_segment_size * 301)); opening_segment_size * 301));
} }
@ -1107,7 +1107,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED, EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
opening_segment_size * 301)); opening_segment_size * 301));
} }
@ -1126,7 +1126,7 @@ TEST(ParseCBORTest, UnsupportedValueError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_UNSUPPORTED_VALUE, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_UNSUPPORTED_VALUE, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1148,7 +1148,7 @@ TEST(ParseCBORTest, InvalidString16Error) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING16, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING16, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1167,7 +1167,7 @@ TEST(ParseCBORTest, InvalidString8Error) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING8, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING8, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1188,7 +1188,7 @@ TEST(ParseCBORTest, InvalidBinaryError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_BINARY, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_BINARY, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1208,7 +1208,7 @@ TEST(ParseCBORTest, InvalidDoubleError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_DOUBLE, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_DOUBLE, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1228,7 +1228,7 @@ TEST(ParseCBORTest, InvalidSignedError) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_INT32, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_INT32, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1250,7 +1250,7 @@ TEST(ParseCBORTest, TrailingJunk) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_TRAILING_JUNK, error_pos)); EXPECT_THAT(status, StatusIs(Error::CBOR_TRAILING_JUNK, error_pos));
EXPECT_EQ("", out); EXPECT_EQ("", out);
} }
@ -1272,7 +1272,7 @@ TEST(ParseCBORTest, EnvelopeContentsLengthMismatch) {
Status status; Status status;
std::unique_ptr<ParserHandler> json_writer = std::unique_ptr<ParserHandler> json_writer =
json::NewJSONEncoder(&out, &status); json::NewJSONEncoder(&out, &status);
ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get()); ParseCBOR(bytes, json_writer.get());
EXPECT_THAT(status, StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH, EXPECT_THAT(status, StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH,
bytes.size())); bytes.size()));
EXPECT_EQ("", out); EXPECT_EQ("", out);

70
deps/inspector_protocol/crdtp/json.cc vendored
View File

@ -149,23 +149,31 @@ class JSONEncoder : public ParserHandler {
Emit('"'); Emit('"');
for (const uint16_t ch : chars) { for (const uint16_t ch : chars) {
if (ch == '"') { if (ch == '"') {
Emit('\\'); Emit('"'); Emit('\\');
Emit('"');
} else if (ch == '\\') { } else if (ch == '\\') {
Emit('\\'); Emit('\\'); Emit('\\');
Emit('\\');
} else if (ch >= 32 && ch <= 127) { } else if (ch >= 32 && ch <= 127) {
Emit(ch); Emit(ch);
} else if (ch == '\n') { } else if (ch == '\n') {
Emit('\\'); Emit('n'); Emit('\\');
Emit('n');
} else if (ch == '\r') { } else if (ch == '\r') {
Emit('\\'); Emit('r'); Emit('\\');
Emit('r');
} else if (ch == '\t') { } else if (ch == '\t') {
Emit('\\'); Emit('t'); Emit('\\');
Emit('t');
} else if (ch == '\b') { } else if (ch == '\b') {
Emit('\\'); Emit('b'); Emit('\\');
Emit('b');
} else if (ch == '\f') { } else if (ch == '\f') {
Emit('\\'); Emit('f'); Emit('\\');
Emit('f');
} else { } else {
Emit('\\'); Emit('u'); Emit('\\');
Emit('u');
PrintHex(ch, out_); PrintHex(ch, out_);
} }
} }
@ -177,26 +185,42 @@ class JSONEncoder : public ParserHandler {
return; return;
state_.top().StartElement(out_); state_.top().StartElement(out_);
Emit('"'); Emit('"');
// Fast path for input strings that can be emitted as-is.
if (std::all_of(chars.begin(), chars.end(), [](uint8_t c) {
return c != '"' && c != '\\' && c >= 32 && c <= 127;
})) {
Emit(chars);
Emit('"');
return;
}
for (size_t ii = 0; ii < chars.size(); ++ii) { for (size_t ii = 0; ii < chars.size(); ++ii) {
uint8_t c = chars[ii]; uint8_t c = chars[ii];
if (c == '"') { if (c == '"') {
Emit('\\'); Emit('"'); Emit('\\');
Emit('"');
} else if (c == '\\') { } else if (c == '\\') {
Emit('\\'); Emit('\\'); Emit('\\');
Emit('\\');
} else if (c >= 32 && c <= 127) { } else if (c >= 32 && c <= 127) {
Emit(c); Emit(c);
} else if (c == '\n') { } else if (c == '\n') {
Emit('\\'); Emit('n'); Emit('\\');
Emit('n');
} else if (c == '\r') { } else if (c == '\r') {
Emit('\\'); Emit('r'); Emit('\\');
Emit('r');
} else if (c == '\t') { } else if (c == '\t') {
Emit('\\'); Emit('t'); Emit('\\');
Emit('t');
} else if (c == '\b') { } else if (c == '\b') {
Emit('\\'); Emit('b'); Emit('\\');
Emit('b');
} else if (c == '\f') { } else if (c == '\f') {
Emit('\\'); Emit('f'); Emit('\\');
Emit('f');
} else if (c < 32) { } else if (c < 32) {
Emit('\\'); Emit('u'); Emit('\\');
Emit('u');
PrintHex(static_cast<uint16_t>(c), out_); PrintHex(static_cast<uint16_t>(c), out_);
} else { } else {
// Inspect the leading byte to figure out how long the utf8 // Inspect the leading byte to figure out how long the utf8
@ -330,10 +354,11 @@ class JSONEncoder : public ParserHandler {
if (!status_->ok()) if (!status_->ok())
return; return;
state_.top().StartElement(out_); state_.top().StartElement(out_);
if (value) if (value) {
Emit("true"); Emit("true");
else } else {
Emit("false"); Emit("false");
}
} }
void HandleNull() override { void HandleNull() override {
@ -351,13 +376,16 @@ class JSONEncoder : public ParserHandler {
private: private:
inline void Emit(char c) { out_->push_back(c); } inline void Emit(char c) { out_->push_back(c); }
template<size_t N> template <size_t N>
inline void Emit(const char (&str)[N]) { inline void Emit(const char (&str)[N]) {
out_->insert(out_->end(), str, str + N - 1); out_->insert(out_->end(), str, str + N - 1);
} }
inline void Emit(const std::string& str) { inline void Emit(const std::string& str) {
out_->insert(out_->end(), str.begin(), str.end()); out_->insert(out_->end(), str.begin(), str.end());
} }
inline void Emit(const span<uint8_t>& bytes) {
out_->insert(out_->end(), bytes.begin(), bytes.end());
}
C* out_; C* out_;
Status* status_; Status* status_;
@ -882,7 +910,7 @@ class JsonParser {
HandleError(Error::JSON_PARSER_INVALID_STRING, token_start); HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
return; return;
} }
handler_->HandleString16(span<uint16_t>(value.data(), value.size())); handler_->HandleString16(value);
break; break;
} }
case ArrayBegin: { case ArrayBegin: {
@ -929,7 +957,7 @@ class JsonParser {
HandleError(Error::JSON_PARSER_INVALID_STRING, token_start); HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
return; return;
} }
handler_->HandleString16(span<uint16_t>(key.data(), key.size())); handler_->HandleString16(key);
start = token_end; start = token_end;
token = ParseToken(start, end, &token_start, &token_end); token = ParseToken(start, end, &token_start, &token_end);

13
deps/inspector_protocol/crdtp/json_test.cc vendored
View File

@ -90,7 +90,7 @@ TEST(JsonEncoder, EscapesLoneHighSurrogates) {
std::string out; std::string out;
Status status; Status status;
std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status); std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
writer->HandleString16(span<uint16_t>(chars.data(), chars.size())); writer->HandleString16(chars);
EXPECT_EQ("\"a\\ud800b\\udadac\\udbffd\"", out); EXPECT_EQ("\"a\\ud800b\\udadac\\udbffd\"", out);
} }
@ -103,7 +103,7 @@ TEST(JsonEncoder, EscapesLoneLowSurrogates) {
std::string out; std::string out;
Status status; Status status;
std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status); std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
writer->HandleString16(span<uint16_t>(chars.data(), chars.size())); writer->HandleString16(chars);
EXPECT_EQ("\"a\\udc00b\\udedec\\udfffd\"", out); EXPECT_EQ("\"a\\udc00b\\udedec\\udfffd\"", out);
} }
@ -114,7 +114,7 @@ TEST(JsonEncoder, EscapesFFFF) {
std::string out; std::string out;
Status status; Status status;
std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status); std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
writer->HandleString16(span<uint16_t>(chars.data(), chars.size())); writer->HandleString16(chars);
EXPECT_EQ("\"abc\\uffffd\"", out); EXPECT_EQ("\"abc\\uffffd\"", out);
} }
@ -123,7 +123,7 @@ TEST(JsonEncoder, Passes0x7FString8) {
std::string out; std::string out;
Status status; Status status;
std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status); std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
writer->HandleString8(span<uint8_t>(chars.data(), chars.size())); writer->HandleString8(chars);
EXPECT_EQ( EXPECT_EQ(
"\"a\x7f" "\"a\x7f"
"b\"", "b\"",
@ -135,7 +135,7 @@ TEST(JsonEncoder, Passes0x7FString16) {
std::string out; std::string out;
Status status; Status status;
std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status); std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
writer->HandleString16(span<uint16_t>(chars16.data(), chars16.size())); writer->HandleString16(chars16);
EXPECT_EQ( EXPECT_EQ(
"\"a\x7f" "\"a\x7f"
"b\"", "b\"",
@ -737,8 +737,7 @@ TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson16) {
'"', ':', '[', '1', ',', '2', ',', '3', ']', '}'}; '"', ':', '[', '1', ',', '2', ',', '3', ']', '}'};
std::vector<uint8_t> cbor; std::vector<uint8_t> cbor;
{ {
Status status = Status status = ConvertJSONToCBOR(json16, &cbor);
ConvertJSONToCBOR(span<uint16_t>(json16.data(), json16.size()), &cbor);
EXPECT_THAT(status, StatusIsOk()); EXPECT_THAT(status, StatusIsOk());
} }
TypeParam roundtrip_json; TypeParam roundtrip_json;

2
deps/inspector_protocol/crdtp/protocol_core.cc vendored
View File

@ -12,7 +12,7 @@ namespace crdtp {
DeserializerState::DeserializerState(std::vector<uint8_t> bytes) DeserializerState::DeserializerState(std::vector<uint8_t> bytes)
: storage_(new std::vector<uint8_t>(std::move(bytes))), : storage_(new std::vector<uint8_t>(std::move(bytes))),
tokenizer_(span<uint8_t>(storage_->data(), storage_->size())) {} tokenizer_(*storage_) {}
DeserializerState::DeserializerState(Storage storage, span<uint8_t> span) DeserializerState::DeserializerState(Storage storage, span<uint8_t> span)
: storage_(std::move(storage)), tokenizer_(span) {} : storage_(std::move(storage)), tokenizer_(span) {}

7
deps/inspector_protocol/crdtp/protocol_core.h vendored
View File

@ -219,8 +219,7 @@ struct CRDTP_EXPORT ProtocolTypeTraits<DeferredMessage> {
template <typename T> template <typename T>
struct ProtocolTypeTraits<std::optional<T>> { struct ProtocolTypeTraits<std::optional<T>> {
static bool Deserialize(DeserializerState* state, static bool Deserialize(DeserializerState* state, std::optional<T>* value) {
std::optional<T>* value) {
T res; T res;
if (!ProtocolTypeTraits<T>::Deserialize(state, &res)) if (!ProtocolTypeTraits<T>::Deserialize(state, &res))
return false; return false;
@ -341,9 +340,7 @@ template <typename T, typename F>
bool ConvertProtocolValue(const F& from, T* to) { bool ConvertProtocolValue(const F& from, T* to) {
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
ProtocolTypeTraits<F>::Serialize(from, &bytes); ProtocolTypeTraits<F>::Serialize(from, &bytes);
auto deserializer = auto deserializer = DeferredMessage::FromSpan(bytes)->MakeDeserializer();
DeferredMessage::FromSpan(span<uint8_t>(bytes.data(), bytes.size()))
->MakeDeserializer();
return ProtocolTypeTraits<T>::Deserialize(&deserializer, to); return ProtocolTypeTraits<T>::Deserialize(&deserializer, to);
} }

40
deps/inspector_protocol/crdtp/span.h vendored
View File

@ -7,49 +7,17 @@
#include <cstdint> #include <cstdint>
#include <cstring> #include <cstring>
#include <type_traits> #include <span>
#include <string> #include <string>
#include <type_traits>
#include "export.h" #include "export.h"
namespace crdtp { namespace crdtp {
// =============================================================================
// span - sequence of bytes
// =============================================================================
// This template is similar to std::span, which will be included in C++20. // crdtp::span is a std::span which always holds const elements.
template <typename T> template <typename T>
class span { using span = std::span<const T>;
public:
using index_type = size_t;
constexpr span() : data_(nullptr), size_(0) {}
constexpr span(const T* data, index_type size) : data_(data), size_(size) {}
constexpr const T* data() const { return data_; }
constexpr const T* begin() const { return data_; }
constexpr const T* end() const { return data_ + size_; }
constexpr const T& operator[](index_type idx) const { return data_[idx]; }
constexpr span<T> subspan(index_type offset, index_type count) const {
return span(data_ + offset, count);
}
constexpr span<T> subspan(index_type offset) const {
return span(data_ + offset, size_ - offset);
}
constexpr bool empty() const { return size_ == 0; }
constexpr index_type size() const { return size_; }
constexpr index_type size_bytes() const { return size_ * sizeof(T); }
private:
const T* data_;
index_type size_;
};
template <size_t N> template <size_t N>
constexpr span<char> MakeSpan(const char (&str)[N]) { constexpr span<char> MakeSpan(const char (&str)[N]) {

6
deps/inspector_protocol/crdtp/span_test.cc vendored
View File

@ -85,6 +85,12 @@ TEST(SpanFromTest, FromVectorUint8AndUint16) {
EXPECT_EQ(bar.size(), bar_span.size()); EXPECT_EQ(bar.size(), bar_span.size());
} }
TEST(SpanFromTest, FromVectorImplicit) {
std::vector<uint8_t> foo = {'f', 'o', 'o'};
span<uint8_t> foo_span(foo);
EXPECT_EQ(foo.size(), foo_span.size());
}
TEST(SpanComparisons, ByteWiseLexicographicalOrder) { TEST(SpanComparisons, ByteWiseLexicographicalOrder) {
// Compare the empty span. // Compare the empty span.
EXPECT_FALSE(SpanLessThan(span<uint8_t>(), span<uint8_t>())); EXPECT_FALSE(SpanLessThan(span<uint8_t>(), span<uint8_t>()));

2
deps/inspector_protocol/lib/Values_cpp.template vendored
View File

@ -300,7 +300,7 @@ namespace {
// transcodes to UTF8 if needed. // transcodes to UTF8 if needed.
void EncodeString(const String& s, std::vector<uint8_t>* out) { void EncodeString(const String& s, std::vector<uint8_t>* out) {
if (StringUtil::CharacterCount(s) == 0) { if (StringUtil::CharacterCount(s) == 0) {
cbor::EncodeString8(span<uint8_t>(nullptr, 0), out); // Empty string. cbor::EncodeString8(span<uint8_t>(), out); // Empty string.
} else if (StringUtil::CharactersLatin1(s)) { } else if (StringUtil::CharactersLatin1(s)) {
cbor::EncodeFromLatin1(span<uint8_t>(StringUtil::CharactersLatin1(s), cbor::EncodeFromLatin1(span<uint8_t>(StringUtil::CharactersLatin1(s),
StringUtil::CharacterCount(s)), StringUtil::CharacterCount(s)),

12
deps/inspector_protocol/pdl.py vendored
View File

@ -86,6 +86,18 @@ def parse(data, file_name, map_binary_to_string=False):
protocol['domains'].append(domain) protocol['domains'].append(domain)
continue continue
match = re.compile(
r'^include (.*)').match(line)
if match:
included_filename = match.group(1)
if path.isabs(included_filename):
raise Exception("Only relative paths are supported in include's")
resolved_path = path.normpath(path.join(path.dirname(file_name), included_filename))
with open(resolved_path, 'r') as file:
included_data = parse(file.read(), resolved_path, map_binary_to_string)
protocol['domains'].extend(included_data['domains'])
continue
match = re.compile(r'^ depends on ([^\s]+)').match(line) match = re.compile(r'^ depends on ([^\s]+)').match(line)
if match: if match:
if 'dependencies' not in domain: if 'dependencies' not in domain: