[DevTools] Roll inspector_protocol (v8) (file split)

This decomposes the crdtp library into multiple files.
Since it wasn't previously rolled
it's a bit more than just that.

Upstream review: https://chromium-review.googlesource.com/c/deps/inspector_protocol/+/1907115

New Revision: d020a9e614d4a5116a7c71f288c0340e282e1a6e

Change-Id: I5c588469654bec3e933804ac706fa967c6fe57bc
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1907973
Auto-Submit: Johannes Henkel <johannes@chromium.org>
Reviewed-by: Yang Guo <yangguo@chromium.org>
Commit-Queue: Yang Guo <yangguo@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64902}

src/inspector/BUILD.gn

@@ -65,9 +65,7 @@ config("inspector_config") {
   visibility = [ ":*" ]  # Only targets in this file can depend on this.
 
   configs = [ "../../:internal_config" ]
-  include_dirs = [
-    "../../include",
-  ]
+  include_dirs = [ "../../include" ]
 }
 
 v8_header_set("inspector_test_headers") {
@@ -97,8 +95,7 @@ v8_source_set("inspector") {
   deps = [
     ":inspector_string_conversions",
     "../..:v8_version",
-    "../../third_party/inspector_protocol:encoding",
-    "../../third_party/inspector_protocol:bindings",
+    "../../third_party/inspector_protocol:crdtp",
   ]
 
   public_deps = [

src/inspector/DEPS

@@ -18,8 +18,6 @@ include_rules = [
   "+src/debug/debug-interface.h",
   "+src/debug/interface-types.h",
   "+src/utils/vector.h",
-  "+third_party/inspector_protocol/encoding/encoding.h",
-  "+third_party/inspector_protocol/encoding/encoding.cc",
-  "+../../third_party/inspector_protocol/encoding/encoding.h",
-  "+../../third_party/inspector_protocol/encoding/encoding.cc",
+  "+third_party/inspector_protocol/crdtp",
+  "+../../third_party/inspector_protocol/crdtp",
 ]

src/inspector/inspector_protocol_config.json

@@ -46,11 +46,7 @@
         "string_header": "src/inspector/string-util.h"
     },
 
-    "encoding_lib": {
-        "namespace": "v8_inspector_protocol_encoding"
-    },
-
-    "bindings_lib": {
-        "namespace": "v8_inspector_protocol_bindings"
+    "crdtp": {
+        "namespace": "v8_crdtp"
     }
 }

src/inspector/v8-inspector-protocol-encoding.cc

@@ -5,21 +5,24 @@
 #include "src/inspector/v8-inspector-protocol-encoding.h"
 
 #include <cmath>
-#include "../../third_party/inspector_protocol/encoding/encoding.h"
+#include "../../third_party/inspector_protocol/crdtp/json.h"
 #include "src/numbers/conversions.h"
 #include "src/utils/vector.h"
 
 namespace v8_inspector {
 namespace {
-using IPEStatus = ::v8_inspector_protocol_encoding::Status;
-using ::v8_inspector_protocol_encoding::span;
+using v8_crdtp::span;
+using v8_crdtp::Status;
 
-class Platform : public ::v8_inspector_protocol_encoding::json::Platform {
- public:
+class Platform : public v8_crdtp::json::Platform {
+  // Parses |str| into |result|. Returns false iff there are
+  // leftover characters or parsing errors.
   bool StrToD(const char* str, double* result) const override {
     *result = v8::internal::StringToDouble(str, v8::internal::NO_FLAGS);
     return !std::isnan(*result);
   }
+
+  // Prints |value| in a format suitable for JSON.
   std::unique_ptr<char[]> DToStr(double value) const override {
     v8::internal::ScopedVector<char> buffer(
         v8::internal::kDoubleToCStringMinBufferSize);
@@ -33,19 +36,18 @@ class Platform : public ::v8_inspector_protocol_encoding::json::Platform {
 };
 }  // namespace
 
-IPEStatus ConvertCBORToJSON(span<uint8_t> cbor, std::vector<uint8_t>* json) {
+Status ConvertCBORToJSON(span<uint8_t> cbor, std::vector<uint8_t>* json) {
   Platform platform;
-  return ConvertCBORToJSON(platform, cbor, json);
+  return v8_crdtp::json::ConvertCBORToJSON(platform, cbor, json);
 }
 
-IPEStatus ConvertJSONToCBOR(span<uint8_t> json, std::vector<uint8_t>* cbor) {
+Status ConvertJSONToCBOR(span<uint8_t> json, std::vector<uint8_t>* cbor) {
   Platform platform;
-  return ConvertJSONToCBOR(platform, json, cbor);
+  return v8_crdtp::json::ConvertJSONToCBOR(platform, json, cbor);
 }
 
-IPEStatus ConvertJSONToCBOR(span<uint16_t> json, std::vector<uint8_t>* cbor) {
+Status ConvertJSONToCBOR(span<uint16_t> json, std::vector<uint8_t>* cbor) {
   Platform platform;
-  return ConvertJSONToCBOR(platform, json, cbor);
+  return v8_crdtp::json::ConvertJSONToCBOR(platform, json, cbor);
 }
-
 }  // namespace v8_inspector

src/inspector/v8-inspector-protocol-encoding.h

@@ -5,21 +5,19 @@
 #ifndef V8_INSPECTOR_V8_INSPECTOR_PROTOCOL_ENCODING_H_
 #define V8_INSPECTOR_V8_INSPECTOR_PROTOCOL_ENCODING_H_
 
-#include "../../third_party/inspector_protocol/encoding/encoding.h"
+#include "../../third_party/inspector_protocol/crdtp/span.h"
+#include "../../third_party/inspector_protocol/crdtp/status.h"
 
 namespace v8_inspector {
 
-::v8_inspector_protocol_encoding::Status ConvertCBORToJSON(
-    ::v8_inspector_protocol_encoding::span<uint8_t> cbor,
-    std::vector<uint8_t>* json);
+v8_crdtp::Status ConvertCBORToJSON(v8_crdtp::span<uint8_t> cbor,
+                                   std::vector<uint8_t>* json);
 
-::v8_inspector_protocol_encoding::Status ConvertJSONToCBOR(
-    ::v8_inspector_protocol_encoding::span<uint8_t> json,
-    std::vector<uint8_t>* cbor);
+v8_crdtp::Status ConvertJSONToCBOR(v8_crdtp::span<uint8_t> json,
+                                   std::vector<uint8_t>* cbor);
 
-::v8_inspector_protocol_encoding::Status ConvertJSONToCBOR(
-    ::v8_inspector_protocol_encoding::span<uint16_t> json,
-    std::vector<uint8_t>* cbor);
+v8_crdtp::Status ConvertJSONToCBOR(v8_crdtp::span<uint16_t> json,
+                                   std::vector<uint8_t>* cbor);
 
 }  // namespace v8_inspector
 

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

@@ -24,9 +24,9 @@
 
 namespace v8_inspector {
 namespace {
-using ::v8_inspector_protocol_encoding::span;
-using ::v8_inspector_protocol_encoding::SpanFrom;
-using IPEStatus = ::v8_inspector_protocol_encoding::Status;
+using v8_crdtp::span;
+using v8_crdtp::SpanFrom;
+using IPEStatus = v8_crdtp::Status;
 
 bool IsCBORMessage(const StringView& msg) {
   return msg.is8Bit() && msg.length() >= 2 && msg.characters8()[0] == 0xd8 &&
@@ -332,8 +332,8 @@ void V8InspectorSessionImpl::reportAllContexts(V8RuntimeAgentImpl* agent) {
 
 void V8InspectorSessionImpl::dispatchProtocolMessage(
     const StringView& message) {
-  using ::v8_inspector_protocol_encoding::span;
-  using ::v8_inspector_protocol_encoding::SpanFrom;
+  using v8_crdtp::span;
+  using v8_crdtp::SpanFrom;
   span<uint8_t> cbor;
   std::vector<uint8_t> converted_cbor;
   if (IsCBORMessage(message)) {

test/unittests/BUILD.gn

@@ -295,8 +295,7 @@ v8_source_set("unittests_sources") {
     "../..:v8_for_testing",
     "../..:v8_libbase",
     "../..:v8_libplatform",
-    "../../third_party/inspector_protocol:bindings_test",
-    "../../third_party/inspector_protocol:encoding_test",
+    "../../third_party/inspector_protocol:crdtp_test",
     "//build/win:default_exe_manifest",
     "//testing/gmock",
     "//testing/gtest",

third_party/inspector_protocol/BUILD.gn

@@ -2,60 +2,47 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-static_library("encoding") {
-  sources = [
-    "encoding/encoding.cc",
-    "encoding/encoding.h",
-  ]
-}
+import("../../gni/v8.gni")
 
-static_library("bindings") {
+v8_source_set("crdtp") {
   sources = [
-    "bindings/bindings.cc",
-    "bindings/bindings.h",
-  ]
+    "crdtp/cbor.cc",
+    "crdtp/cbor.h",
+    "crdtp/export.h",
+    "crdtp/glue.h",
+    "crdtp/json.cc",
+    "crdtp/json.h",
+    "crdtp/json_platform.h",
+    "crdtp/parser_handler.h",
+    "crdtp/span.h",
+    "crdtp/status.cc",
+    "crdtp/status.h",
+  ]
+  configs = [ "../../:internal_config" ]
 }
 
-# encoding_test is part of the unittests, defined in
+# crdtp_test is part of the unittests, defined in
 # test/unittests/BUILD.gn.
-
-import("../../gni/v8.gni")
-
-v8_source_set("encoding_test") {
-  sources = [
-    "encoding/encoding_test.cc",
-    "encoding/encoding_test_helper.h",
-  ]
-  configs = [
-    "../..:external_config",
-    "../..:internal_config_base",
-  ]
-  deps = [
-    ":encoding",
-    "../..:v8_libbase",
-    "../../src/inspector:inspector_string_conversions",
-    "//testing/gmock",
-    "//testing/gtest",
-  ]
+v8_source_set("crdtp_test") {
   testonly = true
-}
-
-v8_source_set("bindings_test") {
   sources = [
-    "bindings/bindings_test.cc",
-    "bindings/bindings_test_helper.h",
+    "crdtp/cbor_test.cc",
+    "crdtp/glue_test.cc",
+    "crdtp/json_test.cc",
+    "crdtp/span_test.cc",
+    "crdtp/status_test.cc",
+    "crdtp/test_platform.cc",
+    "crdtp/test_platform.h",
   ]
   configs = [
     "../..:external_config",
     "../..:internal_config_base",
   ]
   deps = [
-    ":bindings",
+    ":crdtp",
     "../..:v8_libbase",
     "../../src/inspector:inspector_string_conversions",
     "//testing/gmock",
     "//testing/gtest",
   ]
-  testonly = true
 }
-

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: d2fc9b958e1eeb1e956f3e2208afa9923bdc9b67
+Revision: d020a9e614d4a5116a7c71f288c0340e282e1a6e
 License: BSD
 License File: LICENSE
 Security Critical: no

third_party/inspector_protocol/code_generator.py

@@ -112,16 +112,9 @@ def read_config():
       ".lib": False,
       ".lib.export_macro": "",
       ".lib.export_header": False,
-      # The encoding lib consists of encoding/encoding.h and
-      # encoding/encoding.cc in its subdirectory, which binaries
-      # must link / depend on.
-      ".encoding_lib.header": os.path.join(inspector_protocol_dir,
-                                           "encoding/encoding.h"),
-      ".encoding_lib.namespace": "",
-      # Ditto for bindings, see bindings/bindings.h.
-      ".bindings_lib.header": os.path.join(inspector_protocol_dir,
-                                           "bindings/bindings.h"),
-      ".bindings_lib.namespace": ""
+      ".crdtp": False,
+      ".crdtp.dir": os.path.join(inspector_protocol_dir, "crdtp"),
+      ".crdtp.namespace": "inspector_protocol",
     }
     for key_value in config_values:
       parts = key_value.split("=")

third_party/inspector_protocol/bindings/bindings.cc → third_party/inspector_protocol/crdtp/export.h

@@ -2,4 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "bindings.h"
+// This file is V8 specific.
+// It is not rolled from the upstream project.
+// CRDTP doesn't export symbols from V8, so it's empty.

third_party/inspector_protocol/bindings/bindings.h → third_party/inspector_protocol/crdtp/glue.h

@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef V8_INSPECTOR_PROTOCOL_BINDINGS_BINDINGS_H_
-#define V8_INSPECTOR_PROTOCOL_BINDINGS_BINDINGS_H_
+#ifndef V8_CRDTP_GLUE_H_
+#define V8_CRDTP_GLUE_H_
 
 #include <cassert>
 #include <memory>
 
-namespace v8_inspector_protocol_bindings {
+namespace v8_crdtp {
 namespace glue {
 // =============================================================================
 // glue::detail::PtrMaybe, glue::detail::ValueMaybe, templates for optional
@@ -70,11 +70,11 @@ class ValueMaybe {
 };
 }  // namespace detail
 }  // namespace glue
-}  // namespace v8_inspector_protocol_bindings
+}  // namespace v8_crdtp
 
 #define PROTOCOL_DISALLOW_COPY(ClassName) \
-    private: \
-        ClassName(const ClassName&) = delete; \
-        ClassName& operator=(const ClassName&) = delete
+ private:                                 \
+  ClassName(const ClassName&) = delete;   \
+  ClassName& operator=(const ClassName&) = delete
 
-#endif  // V8_INSPECTOR_PROTOCOL_BINDINGS_BINDINGS_H_
+#endif  // V8_CRDTP_GLUE_H_

third_party/inspector_protocol/bindings/bindings_test.cc → third_party/inspector_protocol/crdtp/glue_test.cc

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "bindings.h"
+#include "glue.h"
 
 #include <string>
 #include <vector>
 
-#include "bindings_test_helper.h"
+#include "test_platform.h"
 
-namespace v8_inspector_protocol_bindings {
+namespace v8_crdtp {
 namespace glue {
 // =============================================================================
 // glue::detail::PtrMaybe, glue::detail::ValueMaybe, templates for optional
@@ -41,4 +41,4 @@ TEST(PtrValueTest, SmokeTest) {
   EXPECT_EQ(out, 42);
 }
 }  // namespace glue
-}  // namespace v8_inspector_protocol_bindings
+}  // namespace v8_crdtp

third_party/inspector_protocol/crdtp/json.h

+// Copyright 2019 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_JSON_H_
+#define V8_CRDTP_JSON_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+#include "json_platform.h"
+#include "parser_handler.h"
+
+namespace v8_crdtp {
+namespace json {
+// =============================================================================
+// json::NewJSONEncoder - for encoding streaming parser events as JSON
+// =============================================================================
+
+// Returns a handler object which will write ascii characters to |out|.
+// |status->ok()| will be false iff the handler routine HandleError() is called.
+// In that case, we'll stop emitting output.
+// Except for calling the HandleError routine at any time, the client
+// code must call the Handle* methods in an order in which they'd occur
+// in valid JSON; otherwise we may crash (the code uses assert).
+std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
+    const Platform* platform,
+    std::vector<uint8_t>* out,
+    Status* status);
+std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
+                                                       std::string* out,
+                                                       Status* status);
+
+// =============================================================================
+// json::ParseJSON - for receiving streaming parser events for JSON
+// =============================================================================
+
+void ParseJSON(const Platform& platform,
+               span<uint8_t> chars,
+               StreamingParserHandler* handler);
+void ParseJSON(const Platform& platform,
+               span<uint16_t> chars,
+               StreamingParserHandler* handler);
+
+// =============================================================================
+// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
+// =============================================================================
+Status ConvertCBORToJSON(const Platform& platform,
+                         span<uint8_t> cbor,
+                         std::string* json);
+Status ConvertCBORToJSON(const Platform& platform,
+                         span<uint8_t> cbor,
+                         std::vector<uint8_t>* json);
+Status ConvertJSONToCBOR(const Platform& platform,
+                         span<uint8_t> json,
+                         std::vector<uint8_t>* cbor);
+Status ConvertJSONToCBOR(const Platform& platform,
+                         span<uint16_t> json,
+                         std::vector<uint8_t>* cbor);
+Status ConvertJSONToCBOR(const Platform& platform,
+                         span<uint8_t> json,
+                         std::string* cbor);
+Status ConvertJSONToCBOR(const Platform& platform,
+                         span<uint16_t> json,
+                         std::string* cbor);
+}  // namespace json
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_JSON_H_

third_party/inspector_protocol/crdtp/json_platform.h

+// Copyright 2019 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_JSON_PLATFORM_H_
+#define V8_CRDTP_JSON_PLATFORM_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+
+namespace v8_crdtp {
+namespace json {
+// Client code must provide an instance. Implementation should delegate
+// to whatever is appropriate.
+class Platform {
+ public:
+  virtual ~Platform() = default;
+  // Parses |str| into |result|. Returns false iff there are
+  // leftover characters or parsing errors.
+  virtual bool StrToD(const char* str, double* result) const = 0;
+
+  // Prints |value| in a format suitable for JSON.
+  virtual std::unique_ptr<char[]> DToStr(double value) const = 0;
+};
+}  // namespace json
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_JSON_PLATFORM_H_

third_party/inspector_protocol/crdtp/parser_handler.h

+// Copyright 2019 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_PARSER_HANDLER_H_
+#define V8_CRDTP_PARSER_HANDLER_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+#include "span.h"
+#include "status.h"
+
+namespace v8_crdtp {
+// Handler interface for parser events emitted by a streaming parser.
+// See cbor::NewCBOREncoder, cbor::ParseCBOR, json::NewJSONEncoder,
+// json::ParseJSON.
+class StreamingParserHandler {
+ public:
+  virtual ~StreamingParserHandler() = default;
+  virtual void HandleMapBegin() = 0;
+  virtual void HandleMapEnd() = 0;
+  virtual void HandleArrayBegin() = 0;
+  virtual void HandleArrayEnd() = 0;
+  virtual void HandleString8(span<uint8_t> chars) = 0;
+  virtual void HandleString16(span<uint16_t> chars) = 0;
+  virtual void HandleBinary(span<uint8_t> bytes) = 0;
+  virtual void HandleDouble(double value) = 0;
+  virtual void HandleInt32(int32_t value) = 0;
+  virtual void HandleBool(bool value) = 0;
+  virtual void HandleNull() = 0;
+
+  // The parser may send one error even after other events have already
+  // been received. Client code is reponsible to then discard the
+  // already processed events.
+  // |error| must be an eror, as in, |error.is_ok()| can't be true.
+  virtual void HandleError(Status error) = 0;
+};
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_PARSER_HANDLER_H_

third_party/inspector_protocol/crdtp/span.h

+// Copyright 2019 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_SPAN_H_
+#define V8_CRDTP_SPAN_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+
+namespace v8_crdtp {
+// =============================================================================
+// span - sequence of bytes
+// =============================================================================
+
+// This template is similar to std::span, which will be included in C++20.
+template <typename T>
+class span {
+ public:
+  using index_type = size_t;
+
+  span() : data_(nullptr), size_(0) {}
+  span(const T* data, index_type size) : data_(data), size_(size) {}
+
+  const T* data() const { return data_; }
+
+  const T* begin() const { return data_; }
+  const T* end() const { return data_ + size_; }
+
+  const T& operator[](index_type idx) const { return data_[idx]; }
+
+  span<T> subspan(index_type offset, index_type count) const {
+    return span(data_ + offset, count);
+  }
+
+  span<T> subspan(index_type offset) const {
+    return span(data_ + offset, size_ - offset);
+  }
+
+  bool empty() const { return size_ == 0; }
+
+  index_type size() const { return size_; }
+  index_type size_bytes() const { return size_ * sizeof(T); }
+
+ private:
+  const T* data_;
+  index_type size_;
+};
+
+template <typename T>
+span<T> SpanFrom(const std::vector<T>& v) {
+  return span<T>(v.data(), v.size());
+}
+
+template <size_t N>
+span<uint8_t> SpanFrom(const char (&str)[N]) {
+  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
+}
+
+inline span<uint8_t> SpanFrom(const char* str) {
+  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
+             : span<uint8_t>();
+}
+
+inline span<uint8_t> SpanFrom(const std::string& v) {
+  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
+}
+
+// Less than / equality comparison functions for sorting / searching for byte
+// spans. These are similar to absl::string_view's < and == operators.
+inline bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept {
+  auto min_size = std::min(x.size(), y.size());
+  const int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
+  return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+inline bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept {
+  auto len = x.size();
+  if (len != y.size())
+    return false;
+  return x.data() == y.data() || len == 0 ||
+         std::memcmp(x.data(), y.data(), len) == 0;
+}
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_SPAN_H_

third_party/inspector_protocol/crdtp/span_test.cc

+// Copyright 2018 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 "span.h"
+
+#include <array>
+#include <clocale>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "test_platform.h"
+
+using testing::ElementsAreArray;
+
+namespace v8_crdtp {
+// =============================================================================
+// span - sequence of bytes
+// =============================================================================
+
+template <typename T>
+class SpanTest : public ::testing::Test {};
+
+using TestTypes = ::testing::Types<uint8_t, uint16_t>;
+TYPED_TEST_SUITE(SpanTest, TestTypes);
+
+TYPED_TEST(SpanTest, Empty) {
+  span<TypeParam> empty;
+  EXPECT_TRUE(empty.empty());
+  EXPECT_EQ(0u, empty.size());
+  EXPECT_EQ(0u, empty.size_bytes());
+  EXPECT_EQ(empty.begin(), empty.end());
+}
+
+TYPED_TEST(SpanTest, SingleItem) {
+  TypeParam single_item = 42;
+  span<TypeParam> singular(&single_item, 1);
+  EXPECT_FALSE(singular.empty());
+  EXPECT_EQ(1u, singular.size());
+  EXPECT_EQ(sizeof(TypeParam), singular.size_bytes());
+  EXPECT_EQ(singular.begin() + 1, singular.end());
+  EXPECT_EQ(42, singular[0]);
+}
+
+TYPED_TEST(SpanTest, FiveItems) {
+  std::vector<TypeParam> test_input = {31, 32, 33, 34, 35};
+  span<TypeParam> five_items(test_input.data(), 5);
+  EXPECT_FALSE(five_items.empty());
+  EXPECT_EQ(5u, five_items.size());
+  EXPECT_EQ(sizeof(TypeParam) * 5, five_items.size_bytes());
+  EXPECT_EQ(five_items.begin() + 5, five_items.end());
+  EXPECT_EQ(31, five_items[0]);
+  EXPECT_EQ(32, five_items[1]);
+  EXPECT_EQ(33, five_items[2]);
+  EXPECT_EQ(34, five_items[3]);
+  EXPECT_EQ(35, five_items[4]);
+  span<TypeParam> three_items = five_items.subspan(2);
+  EXPECT_EQ(3u, three_items.size());
+  EXPECT_EQ(33, three_items[0]);
+  EXPECT_EQ(34, three_items[1]);
+  EXPECT_EQ(35, three_items[2]);
+  span<TypeParam> two_items = five_items.subspan(2, 2);
+  EXPECT_EQ(2u, two_items.size());
+  EXPECT_EQ(33, two_items[0]);
+  EXPECT_EQ(34, two_items[1]);
+}
+
+TEST(SpanFromTest, FromConstCharAndLiteral) {
+  // Testing this is useful because strlen(nullptr) is undefined.
+  EXPECT_EQ(nullptr, SpanFrom(nullptr).data());
+  EXPECT_EQ(0u, SpanFrom(nullptr).size());
+
+  const char* kEmpty = "";
+  EXPECT_EQ(kEmpty, reinterpret_cast<const char*>(SpanFrom(kEmpty).data()));
+  EXPECT_EQ(0u, SpanFrom(kEmpty).size());
+
+  const char* kFoo = "foo";
+  EXPECT_EQ(kFoo, reinterpret_cast<const char*>(SpanFrom(kFoo).data()));
+  EXPECT_EQ(3u, SpanFrom(kFoo).size());
+
+  EXPECT_EQ(3u, SpanFrom("foo").size());
+}
+
+TEST(SpanComparisons, ByteWiseLexicographicalOrder) {
+  // Compare the empty span.
+  EXPECT_FALSE(SpanLessThan(span<uint8_t>(), span<uint8_t>()));
+  EXPECT_TRUE(SpanEquals(span<uint8_t>(), span<uint8_t>()));
+
+  // Compare message with itself.
+  std::string msg = "Hello, world";
+  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(msg)));
+  EXPECT_TRUE(SpanEquals(SpanFrom(msg), SpanFrom(msg)));
+
+  // Compare message and copy.
+  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(std::string(msg))));
+  EXPECT_TRUE(SpanEquals(SpanFrom(msg), SpanFrom(std::string(msg))));
+
+  // Compare two messages. |lesser_msg| < |msg| because of the first
+  // byte ('A' < 'H').
+  std::string lesser_msg = "A lesser message.";
+  EXPECT_TRUE(SpanLessThan(SpanFrom(lesser_msg), SpanFrom(msg)));
+  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(lesser_msg)));
+  EXPECT_FALSE(SpanEquals(SpanFrom(msg), SpanFrom(lesser_msg)));
+}
+}  // namespace v8_crdtp

third_party/inspector_protocol/crdtp/status.cc

+// Copyright 2019 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.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <stack>
+
+namespace v8_crdtp {
+// =============================================================================
+// Status and Error codes
+// =============================================================================
+
+std::string Status::ToASCIIString() const {
+  switch (error) {
+    case Error::OK:
+      return "OK";
+    case Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS:
+      return ToASCIIString("JSON: unprocessed input remains");
+    case Error::JSON_PARSER_STACK_LIMIT_EXCEEDED:
+      return ToASCIIString("JSON: stack limit exceeded");
+    case Error::JSON_PARSER_NO_INPUT:
+      return ToASCIIString("JSON: no input");
+    case Error::JSON_PARSER_INVALID_TOKEN:
+      return ToASCIIString("JSON: invalid token");
+    case Error::JSON_PARSER_INVALID_NUMBER:
+      return ToASCIIString("JSON: invalid number");
+    case Error::JSON_PARSER_INVALID_STRING:
+      return ToASCIIString("JSON: invalid string");
+    case Error::JSON_PARSER_UNEXPECTED_ARRAY_END:
+      return ToASCIIString("JSON: unexpected array end");
+    case Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED:
+      return ToASCIIString("JSON: comma or array end expected");
+    case Error::JSON_PARSER_STRING_LITERAL_EXPECTED:
+      return ToASCIIString("JSON: string literal expected");
+    case Error::JSON_PARSER_COLON_EXPECTED:
+      return ToASCIIString("JSON: colon expected");
+    case Error::JSON_PARSER_UNEXPECTED_MAP_END:
+      return ToASCIIString("JSON: unexpected map end");
+    case Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED:
+      return ToASCIIString("JSON: comma or map end expected");
+    case Error::JSON_PARSER_VALUE_EXPECTED:
+      return ToASCIIString("JSON: value expected");
+
+    case Error::CBOR_INVALID_INT32:
+      return ToASCIIString("CBOR: invalid int32");
+    case Error::CBOR_INVALID_DOUBLE:
+      return ToASCIIString("CBOR: invalid double");
+    case Error::CBOR_INVALID_ENVELOPE:
+      return ToASCIIString("CBOR: invalid envelope");
+    case Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH:
+      return ToASCIIString("CBOR: envelope contents length mismatch");
+    case Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE:
+      return ToASCIIString("CBOR: map or array expected in envelope");
+    case Error::CBOR_INVALID_STRING8:
+      return ToASCIIString("CBOR: invalid string8");
+    case Error::CBOR_INVALID_STRING16:
+      return ToASCIIString("CBOR: invalid string16");
+    case Error::CBOR_INVALID_BINARY:
+      return ToASCIIString("CBOR: invalid binary");
+    case Error::CBOR_UNSUPPORTED_VALUE:
+      return ToASCIIString("CBOR: unsupported value");
+    case Error::CBOR_NO_INPUT:
+      return ToASCIIString("CBOR: no input");
+    case Error::CBOR_INVALID_START_BYTE:
+      return ToASCIIString("CBOR: invalid start byte");
+    case Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE:
+      return ToASCIIString("CBOR: unexpected eof expected value");
+    case Error::CBOR_UNEXPECTED_EOF_IN_ARRAY:
+      return ToASCIIString("CBOR: unexpected eof in array");
+    case Error::CBOR_UNEXPECTED_EOF_IN_MAP:
+      return ToASCIIString("CBOR: unexpected eof in map");
+    case Error::CBOR_INVALID_MAP_KEY:
+      return ToASCIIString("CBOR: invalid map key");
+    case Error::CBOR_STACK_LIMIT_EXCEEDED:
+      return ToASCIIString("CBOR: stack limit exceeded");
+    case Error::CBOR_TRAILING_JUNK:
+      return ToASCIIString("CBOR: trailing junk");
+    case Error::CBOR_MAP_START_EXPECTED:
+      return ToASCIIString("CBOR: map start expected");
+    case Error::CBOR_MAP_STOP_EXPECTED:
+      return ToASCIIString("CBOR: map stop expected");
+    case Error::CBOR_ARRAY_START_EXPECTED:
+      return ToASCIIString("CBOR: array start expected");
+    case Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED:
+      return ToASCIIString("CBOR: envelope size limit exceeded");
+
+    case Error::BINDINGS_MANDATORY_FIELD_MISSING:
+      return ToASCIIString("BINDINGS: mandatory field missing");
+    case Error::BINDINGS_BOOL_VALUE_EXPECTED:
+      return ToASCIIString("BINDINGS: bool value expected");
+    case Error::BINDINGS_INT32_VALUE_EXPECTED:
+      return ToASCIIString("BINDINGS: int32 value expected");
+    case Error::BINDINGS_DOUBLE_VALUE_EXPECTED:
+      return ToASCIIString("BINDINGS: double value expected");
+    case Error::BINDINGS_STRING_VALUE_EXPECTED:
+      return ToASCIIString("BINDINGS: string value expected");
+    case Error::BINDINGS_STRING8_VALUE_EXPECTED:
+      return ToASCIIString("BINDINGS: string8 value expected");
+    case Error::BINDINGS_BINARY_VALUE_EXPECTED:
+      return ToASCIIString("BINDINGS: binary value expected");
+  }
+  // Some compilers can't figure out that we can't get here.
+  return "INVALID ERROR CODE";
+}
+
+std::string Status::ToASCIIString(const char* msg) const {
+  return std::string(msg) + " at position " + std::to_string(pos);
+}
+}  // namespace v8_crdtp

third_party/inspector_protocol/crdtp/status.h

+// Copyright 2019 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_ENCODING_H_
+#define V8_CRDTP_ENCODING_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+
+namespace v8_crdtp {
+// =============================================================================
+// Status and Error codes
+// =============================================================================
+enum class Error {
+  OK = 0,
+  // JSON parsing errors - json_parser.{h,cc}.
+  JSON_PARSER_UNPROCESSED_INPUT_REMAINS = 0x01,
+  JSON_PARSER_STACK_LIMIT_EXCEEDED = 0x02,
+  JSON_PARSER_NO_INPUT = 0x03,
+  JSON_PARSER_INVALID_TOKEN = 0x04,
+  JSON_PARSER_INVALID_NUMBER = 0x05,
+  JSON_PARSER_INVALID_STRING = 0x06,
+  JSON_PARSER_UNEXPECTED_ARRAY_END = 0x07,
+  JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED = 0x08,
+  JSON_PARSER_STRING_LITERAL_EXPECTED = 0x09,
+  JSON_PARSER_COLON_EXPECTED = 0x0a,
+  JSON_PARSER_UNEXPECTED_MAP_END = 0x0b,
+  JSON_PARSER_COMMA_OR_MAP_END_EXPECTED = 0x0c,
+  JSON_PARSER_VALUE_EXPECTED = 0x0d,
+
+  CBOR_INVALID_INT32 = 0x0e,
+  CBOR_INVALID_DOUBLE = 0x0f,
+  CBOR_INVALID_ENVELOPE = 0x10,
+  CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH = 0x11,
+  CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE = 0x12,
+  CBOR_INVALID_STRING8 = 0x13,
+  CBOR_INVALID_STRING16 = 0x14,
+  CBOR_INVALID_BINARY = 0x15,
+  CBOR_UNSUPPORTED_VALUE = 0x16,
+  CBOR_NO_INPUT = 0x17,
+  CBOR_INVALID_START_BYTE = 0x18,
+  CBOR_UNEXPECTED_EOF_EXPECTED_VALUE = 0x19,
+  CBOR_UNEXPECTED_EOF_IN_ARRAY = 0x1a,
+  CBOR_UNEXPECTED_EOF_IN_MAP = 0x1b,
+  CBOR_INVALID_MAP_KEY = 0x1c,
+  CBOR_STACK_LIMIT_EXCEEDED = 0x1d,
+  CBOR_TRAILING_JUNK = 0x1e,
+  CBOR_MAP_START_EXPECTED = 0x1f,
+  CBOR_MAP_STOP_EXPECTED = 0x20,
+  CBOR_ARRAY_START_EXPECTED = 0x21,
+  CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED = 0x22,
+
+  BINDINGS_MANDATORY_FIELD_MISSING = 0x23,
+  BINDINGS_BOOL_VALUE_EXPECTED = 0x24,
+  BINDINGS_INT32_VALUE_EXPECTED = 0x25,
+  BINDINGS_DOUBLE_VALUE_EXPECTED = 0x26,
+  BINDINGS_STRING_VALUE_EXPECTED = 0x27,
+  BINDINGS_STRING8_VALUE_EXPECTED = 0x28,
+  BINDINGS_BINARY_VALUE_EXPECTED = 0x29,
+};
+
+// A status value with position that can be copied. The default status
+// is OK. Usually, error status values should come with a valid position.
+struct Status {
+  static constexpr size_t npos() { return std::numeric_limits<size_t>::max(); }
+
+  bool ok() const { return error == Error::OK; }
+
+  Error error = Error::OK;
+  size_t pos = npos();
+  Status(Error error, size_t pos) : error(error), pos(pos) {}
+  Status() = default;
+
+  // Returns a 7 bit US-ASCII string, either "OK" or an error message
+  // that includes the position.
+  std::string ToASCIIString() const;
+
+ private:
+  std::string ToASCIIString(const char* msg) const;
+};
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_ENCODING_H_

third_party/inspector_protocol/lib/DispatcherBase_cpp.template

@@ -316,10 +316,10 @@ std::unique_ptr<Serializable> InternalResponse::createErrorResponse(int callId,
 
 void InternalResponse::AppendSerialized(std::vector<uint8_t>* out) const
 {
-    using {{config.encoding_lib.namespace}}::cbor::NewCBOREncoder;
-    using {{config.encoding_lib.namespace}}::StreamingParserHandler;
-    using {{config.encoding_lib.namespace}}::Status;
-    using {{config.encoding_lib.namespace}}::SpanFrom;
+    using {{config.crdtp.namespace}}::cbor::NewCBOREncoder;
+    using {{config.crdtp.namespace}}::StreamingParserHandler;
+    using {{config.crdtp.namespace}}::Status;
+    using {{config.crdtp.namespace}}::SpanFrom;
 
     Status status;
     std::unique_ptr<StreamingParserHandler> encoder =