[DevTools] Roll third_party/inspector_protocol (v8)

This adds a DCHECK into v8-inspector-session-impl.cc, covering what
we previously checked within ConvertCBORToJSON.

Upstream reviews:

"Separate the lightweight check for CBOR messages from ParseCBOR."
https://chromium-review.googlesource.com/c/deps/inspector_protocol/+/2001536

"Remove Exported::writeBinary."
https://chromium-review.googlesource.com/c/deps/inspector_protocol/+/2005797

New Rev: ac6919eb836521a96cc18931f0bf270d8c1b53a1

Change-Id: I52076a8f77b27c24c3afb35c40afbbe94e0ca05c
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2002935Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Commit-Queue: Johannes Henkel <johannes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#65854}

src/inspector/v8-inspector-session-impl.cc

@@ -28,6 +28,7 @@ namespace {
 using v8_crdtp::span;
 using v8_crdtp::SpanFrom;
 using v8_crdtp::Status;
+using v8_crdtp::cbor::CheckCBORMessage;
 using v8_crdtp::json::ConvertCBORToJSON;
 using v8_crdtp::json::ConvertJSONToCBOR;
 
@@ -167,6 +168,7 @@ protocol::DictionaryValue* V8InspectorSessionImpl::agentState(
 std::unique_ptr<StringBuffer> V8InspectorSessionImpl::serializeForFrontend(
     std::unique_ptr<protocol::Serializable> message) {
   std::vector<uint8_t> cbor = std::move(*message).TakeSerialized();
+  DCHECK(CheckCBORMessage(SpanFrom(cbor)).ok());
   if (use_binary_protocol_)
     return std::unique_ptr<StringBuffer>(
         new BinaryStringBuffer(std::move(cbor)));

third_party/inspector_protocol/BUILD.gn

@@ -55,6 +55,8 @@ v8_source_set("crdtp_test") {
     "crdtp/serializer_traits_test.cc",
     "crdtp/span_test.cc",
     "crdtp/status_test.cc",
+    "crdtp/status_test_support.cc",
+    "crdtp/status_test_support.h",
   ]
   configs = [ ":crdtp_config" ]
   deps = [

third_party/inspector_protocol/README.v8

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

third_party/inspector_protocol/crdtp/cbor.cc

@@ -203,6 +203,20 @@ bool IsCBORMessage(span<uint8_t> msg) {
          msg[1] == InitialByteFor32BitLengthByteString();
 }
 
+Status CheckCBORMessage(span<uint8_t> msg) {
+  if (msg.empty())
+    return Status(Error::CBOR_NO_INPUT, 0);
+  if (msg[0] != InitialByteForEnvelope())
+    return Status(Error::CBOR_INVALID_START_BYTE, 0);
+  if (msg.size() < 6 || msg[1] != InitialByteFor32BitLengthByteString())
+    return Status(Error::CBOR_INVALID_ENVELOPE, 1);
+  if (msg[2] == 0 && msg[3] == 0 && msg[4] == 0 && msg[5] == 0)
+    return Status(Error::CBOR_INVALID_ENVELOPE, 1);
+  if (msg.size() < 7 || msg[6] != EncodeIndefiniteLengthMapStart())
+    return Status(Error::CBOR_MAP_START_EXPECTED, 6);
+  return Status();
+}
+
 // =============================================================================
 // Encoding invidiual CBOR items
 // =============================================================================
@@ -820,19 +834,12 @@ bool ParseEnvelope(int32_t stack_depth,
         return false;
       break;  // Continue to check pos_past_envelope below.
     case CBORTokenTag::ARRAY_START:
-      if (stack_depth == 0) {  // Not allowed at the top level.
-        out->HandleError(
-            Status{Error::CBOR_MAP_START_EXPECTED, tokenizer->Status().pos});
-        return false;
-      }
       if (!ParseArray(stack_depth + 1, tokenizer, out))
         return false;
       break;  // Continue to check pos_past_envelope below.
     default:
-      out->HandleError(Status{
-          stack_depth == 0 ? Error::CBOR_MAP_START_EXPECTED
-                           : Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
-          tokenizer->Status().pos});
+      out->HandleError(Status{Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                              tokenizer->Status().pos});
       return false;
   }
   // The contents of the envelope parsed OK, now check that we're at
@@ -977,19 +984,12 @@ void ParseCBOR(span<uint8_t> bytes, ParserHandler* out) {
     out->HandleError(Status{Error::CBOR_NO_INPUT, 0});
     return;
   }
-  if (bytes[0] != kInitialByteForEnvelope) {
-    out->HandleError(Status{Error::CBOR_INVALID_START_BYTE, 0});
-    return;
-  }
   CBORTokenizer tokenizer(bytes);
   if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
     out->HandleError(tokenizer.Status());
     return;
   }
-  // We checked for the envelope start byte above, so the tokenizer
-  // must agree here, since it's not an error.
-  assert(tokenizer.TokenTag() == CBORTokenTag::ENVELOPE);
-  if (!ParseEnvelope(/*stack_depth=*/0, &tokenizer, out))
+  if (!ParseValue(/*stack_depth=*/0, &tokenizer, out))
     return;
   if (tokenizer.TokenTag() == CBORTokenTag::DONE)
     return;

third_party/inspector_protocol/crdtp/cbor.h

@@ -53,6 +53,15 @@ uint8_t InitialByteFor32BitLengthByteString();
 // Checks whether |msg| is a cbor message.
 bool IsCBORMessage(span<uint8_t> msg);
 
+// Performs a leightweight check of |msg|.
+// Disallows:
+// - Empty message
+// - Not starting with the two bytes 0xd8, 0x5a
+// - Empty envelope (all length bytes are 0)
+// - Not starting with a map after the envelope stanza
+// DevTools messages should pass this check.
+Status CheckCBORMessage(span<uint8_t> msg);
+
 // =============================================================================
 // Encoding individual CBOR items
 // =============================================================================

third_party/inspector_protocol/crdtp/cbor_test.cc

@@ -17,6 +17,7 @@
 #include "parser_handler.h"
 #include "span.h"
 #include "status.h"
+#include "status_test_support.h"
 #include "test_platform.h"
 
 using testing::ElementsAreArray;
@@ -39,6 +40,73 @@ TEST(IsCBORMessage, SomeSmokeTests) {
   EXPECT_TRUE(IsCBORMessage(SpanFrom(one)));
 }
 
+TEST(CheckCBORMessage, SmallestValidExample) {
+  // The smallest example that we consider valid for this lightweight check is
+  // an empty dictionary inside of an envelope.
+  std::vector<uint8_t> empty_dict = {
+      0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
+  Status status = CheckCBORMessage(SpanFrom(empty_dict));
+  EXPECT_THAT(status, StatusIsOk());
+}
+
+TEST(CheckCBORMessage, ValidCBORButNotValidMessage) {
+  // The CBOR parser supports parsing values that aren't messages. E.g., this is
+  // the encoded unsigned int 7 (CBOR really encodes it as a single byte with
+  // value 7).
+  std::vector<uint8_t> not_a_message = {7};
+
+  // Show that the parser (happily) decodes it into JSON
+  std::string json;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&json, &status);
+  ParseCBOR(SpanFrom(not_a_message), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ("7", json);
+
+  // ... but it's not a message.
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(not_a_message)),
+              StatusIs(Error::CBOR_INVALID_START_BYTE, 0));
+}
+
+TEST(CheckCBORMessage, EmptyMessage) {
+  std::vector<uint8_t> empty;
+  Status status = CheckCBORMessage(SpanFrom(empty));
+  EXPECT_THAT(status, StatusIs(Error::CBOR_NO_INPUT, 0));
+}
+
+TEST(CheckCBORMessage, InvalidStartByte) {
+  // Here we test that some actual json, which usually starts with {, is not
+  // considered CBOR. CBOR messages must start with 0xd8, 0x5a, the envelope
+  // start bytes.
+  Status status = CheckCBORMessage(SpanFrom("{\"msg\": \"Hello, world.\"}"));
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_START_BYTE, 0));
+}
+
+TEST(CheckCBORMessage, InvalidEnvelopes) {
+  std::vector<uint8_t> bytes = {0xd8, 0x5a};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_INVALID_ENVELOPE, 1));
+  bytes = {0xd8, 0x5a, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_INVALID_ENVELOPE, 1));
+  bytes = {0xd8, 0x5a, 0, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_INVALID_ENVELOPE, 1));
+  bytes = {0xd8, 0x5a, 0, 0, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_INVALID_ENVELOPE, 1));
+  bytes = {0xd8, 0x5a, 0, 0, 0, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_INVALID_ENVELOPE, 1));
+}
+
+TEST(CheckCBORMessage, MapStartExpected) {
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, 1};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_MAP_START_EXPECTED, 6));
+}
+
 // =============================================================================
 // Encoding individual CBOR items
 // cbor::CBORTokenizer - for parsing individual CBOR items
@@ -164,7 +232,7 @@ TEST(EncodeDecodeInt32Test, CantRoundtripUint32) {
   CBORTokenizer tokenizer(SpanFrom(encoded));
   // 0xdeadbeef is > std::numerical_limits<int32_t>::max().
   EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-  EXPECT_EQ(Error::CBOR_INVALID_INT32, tokenizer.Status().error);
+  EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_INT32, 0u));
 }
 
 TEST(EncodeDecodeInt32Test, DecodeErrorCases) {
@@ -191,7 +259,7 @@ TEST(EncodeDecodeInt32Test, DecodeErrorCases) {
     SCOPED_TRACE(test.msg);
     CBORTokenizer tokenizer(SpanFrom(test.data));
     EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_INT32, tokenizer.Status().error);
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_INT32, 0u));
   }
 }
 
@@ -353,7 +421,7 @@ TEST(EncodeDecodeString16Test, ErrorCases) {
     SCOPED_TRACE(test.msg);
     CBORTokenizer tokenizer(SpanFrom(test.data));
     EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_STRING16, tokenizer.Status().error);
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_STRING16, 0u));
   }
 }
 
@@ -402,7 +470,7 @@ TEST(EncodeDecodeString8Test, ErrorCases) {
     SCOPED_TRACE(test.msg);
     CBORTokenizer tokenizer(SpanFrom(test.data));
     EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_STRING8, tokenizer.Status().error);
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_STRING8, 0u));
   }
 }
 
@@ -477,7 +545,7 @@ TEST(EncodeDecodeBinaryTest, RoundtripsHelloWorld) {
   std::vector<uint8_t> decoded;
   CBORTokenizer tokenizer(SpanFrom(encoded));
   EXPECT_EQ(CBORTokenTag::BINARY, tokenizer.TokenTag());
-  EXPECT_EQ(0, static_cast<int>(tokenizer.Status().error));
+  EXPECT_THAT(tokenizer.Status(), StatusIsOk());
   decoded = std::vector<uint8_t>(tokenizer.GetBinary().begin(),
                                  tokenizer.GetBinary().end());
   EXPECT_THAT(decoded, ElementsAreArray(binary));
@@ -499,7 +567,7 @@ TEST(EncodeDecodeBinaryTest, ErrorCases) {
     SCOPED_TRACE(test.msg);
     CBORTokenizer tokenizer(SpanFrom(test.data));
     EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_BINARY, tokenizer.Status().error);
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_BINARY, 0u));
   }
 }
 
@@ -631,7 +699,7 @@ TEST(JSONToCBOREncoderTest, SevenBitStrings) {
   std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
   std::vector<uint16_t> utf16 = {'f', 'o', 'o'};
   encoder->HandleString16(span<uint16_t>(utf16.data(), utf16.size()));
-  EXPECT_EQ(Error::OK, status.error);
+  EXPECT_THAT(status, StatusIsOk());
   // Here we assert that indeed, seven bit strings are represented as
   // bytes on the wire, "foo" is just "foo".
   EXPECT_THAT(encoded,
@@ -702,7 +770,7 @@ TEST(JsonCborRoundtrip, EncodingDecoding) {
   std::unique_ptr<ParserHandler> json_encoder =
       json::NewJSONEncoder(&decoded, &status);
   ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_encoder.get());
-  EXPECT_EQ(Error::OK, status.error);
+  EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ(json, decoded);
 }
 
@@ -722,7 +790,7 @@ TEST(JsonCborRoundtrip, MoreRoundtripExamples) {
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&decoded, &status);
     ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_writer.get());
-    EXPECT_EQ(Error::OK, status.error);
+    EXPECT_THAT(status, StatusIsOk());
     EXPECT_EQ(json, decoded);
   }
 }
@@ -747,15 +815,14 @@ TEST(JSONToCBOREncoderTest, HelloWorldBinary_WithTripToJson) {
   encoder->HandleBinary(SpanFrom(std::vector<uint8_t>{
       'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'}));
   encoder->HandleMapEnd();
-  EXPECT_EQ(Error::OK, status.error);
+  EXPECT_THAT(status, StatusIsOk());
 
   // Now drive the json writer via the CBOR decoder.
   std::string decoded;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&decoded, &status);
   ParseCBOR(SpanFrom(encoded), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
+  EXPECT_THAT(status, StatusIsOk());
   // "Hello, world." in base64 is "SGVsbG8sIHdvcmxkLg==".
   EXPECT_EQ("{\"foo\":\"SGVsbG8sIHdvcmxkLg==\"}", decoded);
 }
@@ -774,7 +841,7 @@ TEST(ParseCBORTest, ParseEmptyCBORMessage) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
+  EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ("{}", out);
 }
 
@@ -798,7 +865,7 @@ TEST(ParseCBORTest, ParseCBORHelloWorld) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
+  EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ("{\"msg\":\"Hello, \\ud83c\\udf0e.\"}", out);
 }
 
@@ -823,7 +890,7 @@ TEST(ParseCBORTest, UTF8IsSupportedInKeys) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
+  EXPECT_THAT(status, StatusIsOk());
   EXPECT_EQ("{\"\\ud83c\\udf0e\":\"\\u263e\"}", out);
 }
 
@@ -834,21 +901,7 @@ TEST(ParseCBORTest, NoInputError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_NO_INPUT, status.error);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidStartByteError) {
-  // Here we test that some actual json, which usually starts with {,
-  // is not considered CBOR. CBOR messages must start with 0x5a, the
-  // envelope start byte.
-  std::string json = "{\"msg\": \"Hello, world.\"}";
-  std::string out;
-  Status status;
-  std::unique_ptr<ParserHandler> json_writer =
-      json::NewJSONEncoder(&out, &status);
-  ParseCBOR(SpanFrom(json), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_START_BYTE, status.error);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_NO_INPUT, 0u));
   EXPECT_EQ("", out);
 }
 
@@ -864,8 +917,8 @@ TEST(ParseCBORTest, UnexpectedEofExpectedValueError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE, status.error);
-  EXPECT_EQ(bytes.size(), status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
+                               bytes.size()));
   EXPECT_EQ("", out);
 }
 
@@ -882,8 +935,8 @@ TEST(ParseCBORTest, UnexpectedEofInArrayError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, status.error);
-  EXPECT_EQ(bytes.size(), status.pos);
+  EXPECT_THAT(status,
+              StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, bytes.size()));
   EXPECT_EQ("", out);
 }
 
@@ -897,44 +950,19 @@ TEST(ParseCBORTest, UnexpectedEofInMapError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNEXPECTED_EOF_IN_MAP, status.error);
-  EXPECT_EQ(7u, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_MAP, 7u));
   EXPECT_EQ("", out);
 }
 
-TEST(ParseCBORTest, TopLevelCantBeEmptyEnvelope) {
-  // Normally, an array would be allowed inside an envelope, but
-  // the top-level envelope is required to contain a map.
+TEST(ParseCBORTest, NoEmptyEnvelopesAllowed) {
   std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, 0};  // envelope
   std::string out;
   Status status;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_MAP_START_EXPECTED, status.error);
-  EXPECT_EQ(bytes.size(), status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, MapStartExpectedAtTopLevel) {
-  // Normally, an array would be allowed inside an envelope, but
-  // the top-level envelope is required to contain a map.
-  constexpr uint8_t kPayloadLen = 1;
-  std::vector<uint8_t> bytes = {0xd8,
-                                0x5a,
-                                0,
-                                0,
-                                0,
-                                kPayloadLen,  // envelope
-                                EncodeIndefiniteLengthArrayStart()};
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<ParserHandler> json_writer =
-      json::NewJSONEncoder(&out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_MAP_START_EXPECTED, status.error);
-  EXPECT_EQ(6u, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                               bytes.size()));
   EXPECT_EQ("", out);
 }
 
@@ -963,8 +991,8 @@ TEST(ParseCBORTest, OnlyMapsAndArraysSupportedInsideEnvelopes) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                               error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -980,8 +1008,7 @@ TEST(ParseCBORTest, InvalidMapKeyError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_MAP_KEY, status.error);
-  EXPECT_EQ(7u, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_MAP_KEY, 7u));
   EXPECT_EQ("", out);
 }
 
@@ -1011,8 +1038,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
     ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
+    EXPECT_THAT(status, StatusIsOk());
     EXPECT_EQ("{\"key\":{\"key\":{\"key\":\"innermost_value\"}}}", out);
   }
   {  // Depth 300: no stack limit exceeded.
@@ -1022,8 +1048,7 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
     ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
+    EXPECT_THAT(status, StatusIsOk());
   }
 
   // We just want to know the length of one opening map so we can compute
@@ -1042,8 +1067,8 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
     ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::CBOR_STACK_LIMIT_EXCEEDED, status.error);
-    EXPECT_EQ(opening_segment_size * 301, status.pos);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
+                                 opening_segment_size * 301));
   }
   {  // Depth 320: still limit exceeded, and at the same pos as for 1001
     std::vector<uint8_t> bytes = MakeNestedCBOR(320);
@@ -1052,8 +1077,8 @@ TEST(ParseCBORTest, StackLimitExceededError) {
     std::unique_ptr<ParserHandler> json_writer =
         json::NewJSONEncoder(&out, &status);
     ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::CBOR_STACK_LIMIT_EXCEEDED, status.error);
-    EXPECT_EQ(opening_segment_size * 301, status.pos);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
+                                 opening_segment_size * 301));
   }
 }
 
@@ -1071,8 +1096,7 @@ TEST(ParseCBORTest, UnsupportedValueError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNSUPPORTED_VALUE, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNSUPPORTED_VALUE, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1094,8 +1118,7 @@ TEST(ParseCBORTest, InvalidString16Error) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_STRING16, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING16, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1114,8 +1137,7 @@ TEST(ParseCBORTest, InvalidString8Error) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_STRING8, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING8, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1136,8 +1158,7 @@ TEST(ParseCBORTest, InvalidBinaryError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_BINARY, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_BINARY, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1157,8 +1178,7 @@ TEST(ParseCBORTest, InvalidDoubleError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_DOUBLE, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_DOUBLE, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1178,8 +1198,7 @@ TEST(ParseCBORTest, InvalidSignedError) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_INT32, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_INT32, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1201,8 +1220,7 @@ TEST(ParseCBORTest, TrailingJunk) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_TRAILING_JUNK, status.error);
-  EXPECT_EQ(error_pos, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_TRAILING_JUNK, error_pos));
   EXPECT_EQ("", out);
 }
 
@@ -1224,8 +1242,8 @@ TEST(ParseCBORTest, EnvelopeContentsLengthMismatch) {
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH, status.error);
-  EXPECT_EQ(bytes.size(), status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH,
+                               bytes.size()));
   EXPECT_EQ("", out);
 }
 
@@ -1253,29 +1271,27 @@ TEST(AppendString8EntryToMapTest, AppendsEntrySuccessfully) {
 
   Status status =
       AppendString8EntryToCBORMap(SpanFrom("foo"), SpanFrom("bar"), &msg);
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
+  EXPECT_THAT(status, StatusIsOk());
   std::string out;
   std::unique_ptr<ParserHandler> json_writer =
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(SpanFrom(msg), json_writer.get());
   EXPECT_EQ("{\"key\":\"value\",\"foo\":\"bar\"}", out);
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
+  EXPECT_THAT(status, StatusIsOk());
 }
 
 TYPED_TEST(AppendString8EntryToMapTest, AppendThreeEntries) {
   std::vector<uint8_t> encoded = {
       0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
-  EXPECT_EQ(Error::OK, AppendString8EntryToCBORMap(SpanFrom("key"),
-                                                   SpanFrom("value"), &encoded)
-                           .error);
-  EXPECT_EQ(Error::OK, AppendString8EntryToCBORMap(SpanFrom("key1"),
-                                                   SpanFrom("value1"), &encoded)
-                           .error);
-  EXPECT_EQ(Error::OK, AppendString8EntryToCBORMap(SpanFrom("key2"),
-                                                   SpanFrom("value2"), &encoded)
-                           .error);
+  EXPECT_THAT(
+      AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &encoded),
+      StatusIsOk());
+  EXPECT_THAT(AppendString8EntryToCBORMap(SpanFrom("key1"), SpanFrom("value1"),
+                                          &encoded),
+              StatusIsOk());
+  EXPECT_THAT(AppendString8EntryToCBORMap(SpanFrom("key2"), SpanFrom("value2"),
+                                          &encoded),
+              StatusIsOk());
   TypeParam msg(encoded.begin(), encoded.end());
   std::string out;
   Status status;
@@ -1283,8 +1299,7 @@ TYPED_TEST(AppendString8EntryToMapTest, AppendThreeEntries) {
       json::NewJSONEncoder(&out, &status);
   ParseCBOR(SpanFrom(msg), json_writer.get());
   EXPECT_EQ("{\"key\":\"value\",\"key1\":\"value1\",\"key2\":\"value2\"}", out);
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
+  EXPECT_THAT(status, StatusIsOk());
 }
 
 TEST(AppendString8EntryToMapTest, MapStartExpected_Error) {
@@ -1292,8 +1307,7 @@ TEST(AppendString8EntryToMapTest, MapStartExpected_Error) {
       0xd8, 0x5a, 0, 0, 0, 1, EncodeIndefiniteLengthArrayStart()};
   Status status =
       AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-  EXPECT_EQ(Error::CBOR_MAP_START_EXPECTED, status.error);
-  EXPECT_EQ(6u, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_START_EXPECTED, 6u));
 }
 
 TEST(AppendString8EntryToMapTest, MapStopExpected_Error) {
@@ -1301,8 +1315,7 @@ TEST(AppendString8EntryToMapTest, MapStopExpected_Error) {
       0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), 42};
   Status status =
       AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-  EXPECT_EQ(Error::CBOR_MAP_STOP_EXPECTED, status.error);
-  EXPECT_EQ(7u, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_STOP_EXPECTED, 7u));
 }
 
 TEST(AppendString8EntryToMapTest, InvalidEnvelope_Error) {
@@ -1311,16 +1324,14 @@ TEST(AppendString8EntryToMapTest, InvalidEnvelope_Error) {
         0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop(), 0};
     Status status =
         AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 0u));
   }
   {  // Second byte is wrong.
     std::vector<uint8_t> msg = {
         0xd8, 0x7a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
     Status status =
         AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 0u));
   }
   {  // Invalid envelope size example.
     std::vector<uint8_t> msg = {
@@ -1328,8 +1339,7 @@ TEST(AppendString8EntryToMapTest, InvalidEnvelope_Error) {
     };
     Status status =
         AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 0u));
   }
   {  // Invalid envelope size example.
     std::vector<uint8_t> msg = {
@@ -1337,8 +1347,7 @@ TEST(AppendString8EntryToMapTest, InvalidEnvelope_Error) {
     };
     Status status =
         AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 0u));
   }
 }
 }  // namespace cbor

third_party/inspector_protocol/crdtp/json_test.cc

@@ -18,6 +18,7 @@
 #include "parser_handler.h"
 #include "span.h"
 #include "status.h"
+#include "status_test_support.h"
 #include "test_platform.h"
 
 namespace v8_crdtp {
@@ -180,8 +181,7 @@ TEST(JsonStdStringWriterTest, HandlesErrors) {
   writer->HandleMapBegin();
   WriteUTF8AsUTF16(writer.get(), "msg1");
   writer->HandleError(Status{Error::JSON_PARSER_VALUE_EXPECTED, 42});
-  EXPECT_EQ(Error::JSON_PARSER_VALUE_EXPECTED, status.error);
-  EXPECT_EQ(42u, status.pos);
+  EXPECT_THAT(status, StatusIs(Error::JSON_PARSER_VALUE_EXPECTED, 42u));
   EXPECT_EQ("", out);
 }
 
@@ -401,8 +401,8 @@ TEST_F(JsonParserTest, UnprocessedInputRemainsError) {
   size_t junk_idx = json.find("junk");
   EXPECT_NE(junk_idx, std::string::npos);
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, log_.status().error);
-  EXPECT_EQ(junk_idx, log_.status().pos);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, junk_idx));
   EXPECT_EQ("", log_.str());
 }
 
@@ -442,38 +442,36 @@ TEST_F(JsonParserTest, StackLimitExceededError_AtLimit) {
   ParseJSON(span<uint8_t>(reinterpret_cast<const uint8_t*>(json_limit.data()),
                           json_limit.size()),
             &log_);
-  EXPECT_TRUE(log_.status().ok());
+  EXPECT_THAT(log_.status(), StatusIsOk());
 }
 
 TEST_F(JsonParserTest, StackLimitExceededError_AboveLimit) {
   // Now with kStackLimit + 1 (301) - it exceeds in the innermost instance.
   std::string exceeded = MakeNestedJson(301);
   ParseJSON(SpanFrom(exceeded), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, log_.status().error);
-  EXPECT_EQ(strlen("{\"foo\":") * 301, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED,
+                                      strlen("{\"foo\":") * 301));
 }
 
 TEST_F(JsonParserTest, StackLimitExceededError_WayAboveLimit) {
   // Now way past the limit. Still, the point of exceeding is 301.
   std::string far_out = MakeNestedJson(320);
   ParseJSON(SpanFrom(far_out), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, log_.status().error);
-  EXPECT_EQ(strlen("{\"foo\":") * 301, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED,
+                                      strlen("{\"foo\":") * 301));
 }
 
 TEST_F(JsonParserTest, NoInputError) {
   std::string json = "";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_NO_INPUT, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_NO_INPUT, 0u));
   EXPECT_EQ("", log_.str());
 }
 
 TEST_F(JsonParserTest, InvalidTokenError) {
   std::string json = "|";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_INVALID_TOKEN, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_INVALID_TOKEN, 0u));
   EXPECT_EQ("", log_.str());
 }
 
@@ -481,8 +479,7 @@ TEST_F(JsonParserTest, InvalidNumberError) {
   // Mantissa exceeds max (the constant used here is int64_t max).
   std::string json = "1E9223372036854775807";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_INVALID_NUMBER, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_INVALID_NUMBER, 0u));
   EXPECT_EQ("", log_.str());
 }
 
@@ -490,25 +487,23 @@ TEST_F(JsonParserTest, InvalidStringError) {
   // \x22 is an unsupported escape sequence
   std::string json = "\"foo\\x22\"";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_INVALID_STRING, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_INVALID_STRING, 0u));
   EXPECT_EQ("", log_.str());
 }
 
 TEST_F(JsonParserTest, UnexpectedArrayEndError) {
   std::string json = "[1,2,]";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, log_.status().error);
-  EXPECT_EQ(5u, log_.status().pos);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, 5u));
   EXPECT_EQ("", log_.str());
 }
 
 TEST_F(JsonParserTest, CommaOrArrayEndExpectedError) {
   std::string json = "[1,2 2";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED,
-            log_.status().error);
-  EXPECT_EQ(5u, log_.status().pos);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED, 5u));
   EXPECT_EQ("", log_.str());
 }
 
@@ -516,24 +511,23 @@ TEST_F(JsonParserTest, StringLiteralExpectedError) {
   // There's an error because the key bar, a string, is not terminated.
   std::string json = "{\"foo\": 3.1415, \"bar: 31415e-4}";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_STRING_LITERAL_EXPECTED, log_.status().error);
-  EXPECT_EQ(16u, log_.status().pos);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_STRING_LITERAL_EXPECTED, 16u));
   EXPECT_EQ("", log_.str());
 }
 
 TEST_F(JsonParserTest, ColonExpectedError) {
   std::string json = "{\"foo\", 42}";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_COLON_EXPECTED, log_.status().error);
-  EXPECT_EQ(6u, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_COLON_EXPECTED, 6u));
   EXPECT_EQ("", log_.str());
 }
 
 TEST_F(JsonParserTest, UnexpectedMapEndError) {
   std::string json = "{\"foo\": 42, }";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_UNEXPECTED_MAP_END, log_.status().error);
-  EXPECT_EQ(12u, log_.status().pos);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_UNEXPECTED_MAP_END, 12u));
   EXPECT_EQ("", log_.str());
 }
 
@@ -541,16 +535,15 @@ TEST_F(JsonParserTest, CommaOrMapEndExpectedError) {
   // The second separator should be a comma.
   std::string json = "{\"foo\": 3.1415: \"bar\": 0}";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED, log_.status().error);
-  EXPECT_EQ(14u, log_.status().pos);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED, 14u));
   EXPECT_EQ("", log_.str());
 }
 
 TEST_F(JsonParserTest, ValueExpectedError) {
   std::string json = "}";
   ParseJSON(SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_VALUE_EXPECTED, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_VALUE_EXPECTED, 0u));
   EXPECT_EQ("", log_.str());
 }
 
@@ -561,21 +554,29 @@ using ContainerTestTypes = ::testing::Types<std::vector<uint8_t>, std::string>;
 TYPED_TEST_SUITE(ConvertJSONToCBORTest, ContainerTestTypes);
 
 TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson) {
-  std::string json_in = "{\"msg\":\"Hello, world.\",\"lst\":[1,2,3]}";
-  TypeParam json(json_in.begin(), json_in.end());
-  std::vector<uint8_t> cbor;
-  {
-    Status status = ConvertJSONToCBOR(SpanFrom(json), &cbor);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-  }
-  TypeParam roundtrip_json;
-  {
-    Status status = ConvertCBORToJSON(SpanFrom(cbor), &roundtrip_json);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
+  for (const std::string& json_in : {
+           "{\"msg\":\"Hello, world.\",\"lst\":[1,2,3]}",
+           "3.1415",
+           "false",
+           "true",
+           "\"Hello, world.\"",
+           "[1,2,3]",
+           "[]",
+       }) {
+    SCOPED_TRACE(json_in);
+    TypeParam json(json_in.begin(), json_in.end());
+    std::vector<uint8_t> cbor;
+    {
+      Status status = ConvertJSONToCBOR(SpanFrom(json), &cbor);
+      EXPECT_THAT(status, StatusIsOk());
+    }
+    TypeParam roundtrip_json;
+    {
+      Status status = ConvertCBORToJSON(SpanFrom(cbor), &roundtrip_json);
+      EXPECT_THAT(status, StatusIsOk());
+    }
+    EXPECT_EQ(json, roundtrip_json);
   }
-  EXPECT_EQ(json, roundtrip_json);
 }
 
 TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson16) {
@@ -587,14 +588,12 @@ TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson16) {
   {
     Status status =
         ConvertJSONToCBOR(span<uint16_t>(json16.data(), json16.size()), &cbor);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
+    EXPECT_THAT(status, StatusIsOk());
   }
   TypeParam roundtrip_json;
   {
     Status status = ConvertCBORToJSON(SpanFrom(cbor), &roundtrip_json);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
+    EXPECT_THAT(status, StatusIsOk());
   }
   std::string json = "{\"msg\":\"Hello, \\ud83c\\udf0e.\",\"lst\":[1,2,3]}";
   TypeParam expected_json(json.begin(), json.end());

third_party/inspector_protocol/crdtp/status_test.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "status.h"
+#include "status_test_support.h"
 #include "test_platform.h"
 
 namespace v8_crdtp {
@@ -18,4 +19,11 @@ TEST(StatusTest, StatusToASCIIString) {
   Status cbor_error(Error::CBOR_TRAILING_JUNK, 21);
   EXPECT_EQ("CBOR: trailing junk at position 21", cbor_error.ToASCIIString());
 }
+
+TEST(StatusTest, StatusTestSupport) {
+  Status ok_status;
+  EXPECT_THAT(ok_status, StatusIsOk());
+  Status json_error(Error::JSON_PARSER_COLON_EXPECTED, 42);
+  EXPECT_THAT(json_error, StatusIs(Error::JSON_PARSER_COLON_EXPECTED, 42));
+}
 }  // namespace v8_crdtp

third_party/inspector_protocol/crdtp/status_test_support.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "status_test_support.h"
+
+namespace v8_crdtp {
+void PrintTo(const Status& status, std::ostream* os) {
+  *os << status.ToASCIIString() << " (error: 0x" << std::hex
+      << static_cast<int>(status.error) << ", "
+      << "pos: " << std::dec << status.pos << ")";
+}
+
+namespace {
+class StatusIsMatcher : public testing::MatcherInterface<Status> {
+ public:
+  explicit StatusIsMatcher(Status status) : expected_(status) {}
+
+  bool MatchAndExplain(Status status,
+                       testing::MatchResultListener* listener) const override {
+    return status.error == expected_.error && status.pos == expected_.pos;
+  }
+
+  void DescribeTo(std::ostream* os) const override {
+    *os << "equals to ";
+    PrintTo(expected_, os);
+  }
+
+ private:
+  Status expected_;
+};
+
+class StatusIsOkMatcher : public testing::MatcherInterface<Status> {
+  bool MatchAndExplain(Status status,
+                       testing::MatchResultListener* listener) const override {
+    return status.ok();
+  }
+
+  void DescribeTo(std::ostream* os) const override { *os << "is ok"; }
+};
+}  // namespace
+
+testing::Matcher<Status> StatusIsOk() {
+  return MakeMatcher(new StatusIsOkMatcher());
+}
+
+testing::Matcher<Status> StatusIs(Error error, size_t pos) {
+  return MakeMatcher(new StatusIsMatcher(Status(error, pos)));
+}
+}  // namespace v8_crdtp

third_party/inspector_protocol/crdtp/status_test_support.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_CRDTP_STATUS_TEST_SUPPORT_H_
+#define V8_CRDTP_STATUS_TEST_SUPPORT_H_
+
+#include <ostream>
+#include "status.h"
+#include "test_platform.h"
+
+namespace v8_crdtp {
+// Supports gtest, to conveniently match Status objects and
+// get useful error messages when tests fail.
+// Typically used with EXPECT_THAT, e.g.
+//
+// EXPECT_THAT(status, StatusIs(Error::JSON_PARSER_COLON_EXPECTED, 42));
+//
+// EXPECT_THAT(status, StatusIsOk());
+
+// Prints a |status|, including its generated error message, error code, and
+// position. This is used by gtest for pretty printing actual vs. expected.
+void PrintTo(const Status& status, std::ostream* os);
+
+// Matches any status with |status.ok()|.
+testing::Matcher<Status> StatusIsOk();
+
+// Matches any status with |error| and |pos|.
+testing::Matcher<Status> StatusIs(Error error, size_t pos);
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_STATUS_TEST_SUPPORT_H_

third_party/inspector_protocol/roll.py

@@ -38,6 +38,8 @@ FILES_TO_SYNC = [
     'crdtp/status.cc',
     'crdtp/status.h',
     'crdtp/status_test.cc',
+    'crdtp/status_test_support.cc',
+    'crdtp/status_test_support.h',
     'inspector_protocol.gni',
     'inspector_protocol.gypi',
     'lib/*',

third_party/inspector_protocol/templates/Exported_h.template

@@ -22,9 +22,6 @@ class {{config.exported.export_macro}} Exported {
 public:
     virtual {{config.exported.string_out}} toJSONString() const = 0;
 
-    V8_DEPRECATE_SOON("Use AppendSerialized instead.")
-    virtual void writeBinary(std::vector<uint8_t>* out) const = 0;
-
     virtual void AppendSerialized(std::vector<uint8_t>* out) const = 0;
 
     virtual ~Exported() { }

third_party/inspector_protocol/templates/TypeBuilder_cpp.template

@@ -120,11 +120,6 @@ std::unique_ptr<{{type.id}}> {{type.id}}::clone() const
     return {{config.exported.to_string_out % "json"}};
 }
 
-void {{type.id}}::writeBinary(std::vector<uint8_t>* out) const
-{
-    AppendSerialized(out);
-}
-
 // static
 std::unique_ptr<API::{{type.id}}> API::{{type.id}}::fromBinary(const uint8_t* data, size_t length)
 {

third_party/inspector_protocol/templates/TypeBuilder_h.template

@@ -105,7 +105,6 @@ public:
     std::unique_ptr<{{type.id}}> clone() const;
     {% if protocol.is_exported(domain.domain, type.id) %}
     {{config.exported.string_out}} toJSONString() const override;
-    void writeBinary(std::vector<uint8_t>* out) const override;
     {% endif %}
 
     template<int STATE>