@triniwiz/nativescript-masonkit 1.0.0-alpha.5 → 1.0.0-alpha.6

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/cbor.h

@@ -0,0 +1,305 @@
+// 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_CBOR_H_
+#define V8_CRDTP_CBOR_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+#include "parser_handler.h"
+#include "span.h"
+
+namespace v8_crdtp {
+namespace cbor {
+// The binary encoding for the inspector protocol follows the CBOR specification
+// (RFC 7049). Additional constraints:
+// - Only indefinite length maps and arrays are supported.
+// - Maps and arrays are wrapped with an envelope, that is, a
+//   CBOR tag with value 24 followed by a byte string specifying
+//   the byte length of the enclosed map / array. The byte string
+//   must use a 32 bit wide length.
+// - At the top level, a message must be an indefinite length map
+//   wrapped by an envelope.
+// - Maximal size for messages is 2^32 (4 GB).
+// - For scalars, we support only the int32_t range, encoded as
+//   UNSIGNED/NEGATIVE (major types 0 / 1).
+// - UTF16 strings, including with unbalanced surrogate pairs, are encoded
+//   as CBOR BYTE_STRING (major type 2). For such strings, the number of
+//   bytes encoded must be even.
+// - UTF8 strings (major type 3) are supported.
+// - 7 bit US-ASCII strings must always be encoded as UTF8 strings, never
+//   as UTF16 strings.
+// - Arbitrary byte arrays, in the inspector protocol called 'binary',
+//   are encoded as BYTE_STRING (major type 2), prefixed with a byte
+//   indicating base64 when rendered as JSON.
+
+// =============================================================================
+// Detecting CBOR content
+// =============================================================================
+
+// The first byte for an envelope, which we use for wrapping dictionaries
+// and arrays; and the byte that indicates a byte string with 32 bit length.
+// These two bytes start an envelope, and thereby also any CBOR message
+// produced or consumed by this protocol. See also |EnvelopeEncoder| below.
+uint8_t InitialByteForEnvelope();
+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
+// =============================================================================
+
+// Some constants for CBOR tokens that only take a single byte on the wire.
+uint8_t EncodeTrue();
+uint8_t EncodeFalse();
+uint8_t EncodeNull();
+uint8_t EncodeIndefiniteLengthArrayStart();
+uint8_t EncodeIndefiniteLengthMapStart();
+uint8_t EncodeStop();
+
+// Encodes |value| as |UNSIGNED| (major type 0) iff >= 0, or |NEGATIVE|
+// (major type 1) iff < 0.
+void EncodeInt32(int32_t value, std::vector<uint8_t>* out);
+
+// Encodes a UTF16 string as a BYTE_STRING (major type 2). Each utf16
+// character in |in| is emitted with most significant byte first,
+// appending to |out|.
+void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out);
+
+// Encodes a UTF8 string |in| as STRING (major type 3).
+void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out);
+
+// Encodes the given |latin1| string as STRING8.
+// If any non-ASCII character is present, it will be represented
+// as a 2 byte UTF8 sequence.
+void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out);
+
+// Encodes the given |utf16| string as STRING8 if it's entirely US-ASCII.
+// Otherwise, encodes as STRING16.
+void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out);
+
+// Encodes arbitrary binary data in |in| as a BYTE_STRING (major type 2) with
+// definitive length, prefixed with tag 22 indicating expected conversion to
+// base64 (see RFC 7049, Table 3 and Section 2.4.4.2).
+void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out);
+
+// Encodes / decodes a double as Major type 7 (SIMPLE_VALUE),
+// with additional info = 27, followed by 8 bytes in big endian.
+void EncodeDouble(double value, std::vector<uint8_t>* out);
+
+// =============================================================================
+// cbor::EnvelopeEncoder - for wrapping submessages
+// =============================================================================
+
+// An envelope indicates the byte length of a wrapped item.
+// We use this for maps and array, which allows the decoder
+// to skip such (nested) values whole sale.
+// It's implemented as a CBOR tag (major type 6) with additional
+// info = 24, followed by a byte string with a 32 bit length value;
+// so the maximal structure that we can wrap is 2^32 bits long.
+// See also: https://tools.ietf.org/html/rfc7049#section-2.4.4.1
+class EnvelopeEncoder {
+ public:
+  // Emits the envelope start bytes and records the position for the
+  // byte size in |byte_size_pos_|. Also emits empty bytes for the
+  // byte sisze so that encoding can continue.
+  void EncodeStart(std::vector<uint8_t>* out);
+  // This records the current size in |out| at position byte_size_pos_.
+  // Returns true iff successful.
+  bool EncodeStop(std::vector<uint8_t>* out);
+
+ private:
+  size_t byte_size_pos_ = 0;
+};
+
+// =============================================================================
+// cbor::NewCBOREncoder - for encoding from a streaming parser
+// =============================================================================
+
+// This can be used to convert to CBOR, by passing the return value to a parser
+// that drives it. The handler will encode into |out|, and iff an error occurs
+// it will set |status| to an error and clear |out|. Otherwise, |status.ok()|
+// will be |true|.
+std::unique_ptr<ParserHandler> NewCBOREncoder(std::vector<uint8_t>* out,
+                                              Status* status);
+
+// =============================================================================
+// cbor::CBORTokenizer - for parsing individual CBOR items
+// =============================================================================
+
+// Tags for the tokens within a CBOR message that CBORTokenizer understands.
+// Note that this is not the same terminology as the CBOR spec (RFC 7049),
+// but rather, our adaptation. For instance, we lump unsigned and signed
+// major type into INT32 here (and disallow values outside the int32_t range).
+enum class CBORTokenTag {
+  // Encountered an error in the structure of the message. Consult
+  // status() for details.
+  ERROR_VALUE,
+  // Booleans and NULL.
+  TRUE_VALUE,
+  FALSE_VALUE,
+  NULL_VALUE,
+  // An int32_t (signed 32 bit integer).
+  INT32,
+  // A double (64 bit floating point).
+  DOUBLE,
+  // A UTF8 string.
+  STRING8,
+  // A UTF16 string.
+  STRING16,
+  // A binary string.
+  BINARY,
+  // Starts an indefinite length map; after the map start we expect
+  // alternating keys and values, followed by STOP.
+  MAP_START,
+  // Starts an indefinite length array; after the array start we
+  // expect values, followed by STOP.
+  ARRAY_START,
+  // Ends a map or an array.
+  STOP,
+  // An envelope indicator, wrapping a map or array.
+  // Internally this carries the byte length of the wrapped
+  // map or array. While CBORTokenizer::Next() will read / skip the entire
+  // envelope, CBORTokenizer::EnterEnvelope() reads the tokens
+  // inside of it.
+  ENVELOPE,
+  // We've reached the end there is nothing else to read.
+  DONE,
+};
+
+// The major types from RFC 7049 Section 2.1.
+enum class MajorType {
+  UNSIGNED = 0,
+  NEGATIVE = 1,
+  BYTE_STRING = 2,
+  STRING = 3,
+  ARRAY = 4,
+  MAP = 5,
+  TAG = 6,
+  SIMPLE_VALUE = 7
+};
+
+// CBORTokenizer segments a CBOR message, presenting the tokens therein as
+// numbers, strings, etc. This is not a complete CBOR parser, but makes it much
+// easier to implement one (e.g. ParseCBOR, above). It can also be used to parse
+// messages partially.
+class CBORTokenizer {
+ public:
+  explicit CBORTokenizer(span<uint8_t> bytes);
+  ~CBORTokenizer();
+
+  // Identifies the current token that we're looking at,
+  // or ERROR_VALUE (in which ase ::Status() has details)
+  // or DONE (if we're past the last token).
+  CBORTokenTag TokenTag() const;
+
+  // Advances to the next token.
+  void Next();
+  // Can only be called if TokenTag() == CBORTokenTag::ENVELOPE.
+  // While Next() would skip past the entire envelope / what it's
+  // wrapping, EnterEnvelope positions the cursor inside of the envelope,
+  // letting the client explore the nested structure.
+  void EnterEnvelope();
+
+  // If TokenTag() is CBORTokenTag::ERROR_VALUE, then Status().error describes
+  // the error more precisely; otherwise it'll be set to Error::OK.
+  // In either case, Status().pos is the current position.
+  struct Status Status() const;
+
+  // The following methods retrieve the token values. They can only
+  // be called if TokenTag() matches.
+
+  // To be called only if ::TokenTag() == CBORTokenTag::INT32.
+  int32_t GetInt32() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::DOUBLE.
+  double GetDouble() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::STRING8.
+  span<uint8_t> GetString8() const;
+
+  // Wire representation for STRING16 is low byte first (little endian).
+  // To be called only if ::TokenTag() == CBORTokenTag::STRING16.
+  span<uint8_t> GetString16WireRep() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::BINARY.
+  span<uint8_t> GetBinary() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
+  // Returns the envelope including its payload; message which
+  // can be passed to the CBORTokenizer constructor, which will
+  // then see the envelope token first (looking at it a second time,
+  // basically).
+  span<uint8_t> GetEnvelope() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
+  // Returns only the payload inside the envelope, e.g., a map
+  // or an array. This is not a complete message by our
+  // IsCBORMessage definition, since it doesn't include the
+  // enclosing envelope (the header, basically).
+  span<uint8_t> GetEnvelopeContents() const;
+
+ private:
+  void ReadNextToken(bool enter_envelope);
+  void SetToken(CBORTokenTag token, size_t token_byte_length);
+  void SetError(Error error);
+
+  span<uint8_t> bytes_;
+  CBORTokenTag token_tag_;
+  struct Status status_;
+  size_t token_byte_length_;
+  MajorType token_start_type_;
+  uint64_t token_start_internal_value_;
+};
+
+// =============================================================================
+// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
+// =============================================================================
+
+// Parses a CBOR encoded message from |bytes|, sending events to
+// |out|. If an error occurs, sends |out->HandleError|, and parsing stops.
+// The client is responsible for discarding the already received information in
+// that case.
+void ParseCBOR(span<uint8_t> bytes, ParserHandler* out);
+
+// =============================================================================
+// cbor::AppendString8EntryToMap - for limited in-place editing of messages
+// =============================================================================
+
+// Modifies the |cbor| message by appending a new key/value entry at the end
+// of the map. Patches up the envelope size; Status.ok() iff successful.
+// If not successful, |cbor| may be corrupted after this call.
+Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
+                                   span<uint8_t> string8_value,
+                                   std::vector<uint8_t>* cbor);
+
+namespace internals {  // Exposed only for writing tests.
+size_t ReadTokenStart(span<uint8_t> bytes,
+                      cbor::MajorType* type,
+                      uint64_t* value);
+
+void WriteTokenStart(cbor::MajorType type,
+                     uint64_t value,
+                     std::vector<uint8_t>* encoded);
+}  // namespace internals
+}  // namespace cbor
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_CBOR_H_

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/dispatch.h

@@ -0,0 +1,314 @@
+// 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_DISPATCH_H_
+#define V8_CRDTP_DISPATCH_H_
+
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <unordered_set>
+#include "export.h"
+#include "serializable.h"
+#include "span.h"
+#include "status.h"
+
+namespace v8_crdtp {
+class DeserializerState;
+class ErrorSupport;
+class FrontendChannel;
+namespace cbor {
+class CBORTokenizer;
+}  // namespace cbor
+
+// =============================================================================
+// DispatchResponse - Error status and chaining / fall through
+// =============================================================================
+enum class DispatchCode {
+  SUCCESS = 1,
+  FALL_THROUGH = 2,
+  // For historical reasons, these error codes correspond to commonly used
+  // XMLRPC codes (e.g. see METHOD_NOT_FOUND in
+  // https://github.com/python/cpython/blob/master/Lib/xmlrpc/client.py).
+  PARSE_ERROR = -32700,
+  INVALID_REQUEST = -32600,
+  METHOD_NOT_FOUND = -32601,
+  INVALID_PARAMS = -32602,
+  INTERNAL_ERROR = -32603,
+  SERVER_ERROR = -32000,
+};
+
+// Information returned by command handlers. Usually returned after command
+// execution attempts.
+class DispatchResponse {
+ public:
+  const std::string& Message() const { return message_; }
+
+  DispatchCode Code() const { return code_; }
+
+  bool IsSuccess() const { return code_ == DispatchCode::SUCCESS; }
+  bool IsFallThrough() const { return code_ == DispatchCode::FALL_THROUGH; }
+  bool IsError() const { return code_ < DispatchCode::SUCCESS; }
+
+  static DispatchResponse Success();
+  static DispatchResponse FallThrough();
+
+  // Indicates that a message could not be parsed. E.g., malformed JSON.
+  static DispatchResponse ParseError(std::string message);
+
+  // Indicates that a request is lacking required top-level properties
+  // ('id', 'method'), has top-level properties of the wrong type, or has
+  // unknown top-level properties.
+  static DispatchResponse InvalidRequest(std::string message);
+
+  // Indicates that a protocol method such as "Page.bringToFront" could not be
+  // dispatched because it's not known to the (domain) dispatcher.
+  static DispatchResponse MethodNotFound(std::string message);
+
+  // Indicates that the params sent to a domain handler are invalid.
+  static DispatchResponse InvalidParams(std::string message);
+
+  // Used for application level errors, e.g. within protocol agents.
+  static DispatchResponse InternalError();
+
+  // Used for application level errors, e.g. within protocol agents.
+  static DispatchResponse ServerError(std::string message);
+
+ private:
+  DispatchResponse() = default;
+  DispatchCode code_;
+  std::string message_;
+};
+
+// =============================================================================
+// Dispatchable - a shallow parser for CBOR encoded DevTools messages
+// =============================================================================
+
+// This parser extracts only the known top-level fields from a CBOR encoded map;
+// method, id, sessionId, and params.
+class Dispatchable {
+ public:
+  // This constructor parses the |serialized| message. If successful,
+  // |ok()| will yield |true|, and |Method()|, |SessionId()|, |CallId()|,
+  // |Params()| can be used to access, the extracted contents. Otherwise,
+  // |ok()| will yield |false|, and |DispatchError()| can be
+  // used to send a response or notification to the client.
+  explicit Dispatchable(span<uint8_t> serialized);
+
+  // The serialized message that we just parsed.
+  span<uint8_t> Serialized() const { return serialized_; }
+
+  // Yields true if parsing was successful. This is cheaper than calling
+  // ::DispatchError().
+  bool ok() const;
+
+  // If !ok(), returns a DispatchResponse with appropriate code and error
+  // which can be sent to the client as a response or notification.
+  DispatchResponse DispatchError() const;
+
+  // Top level field: the command to be executed, fully qualified by
+  // domain. E.g. "Page.createIsolatedWorld".
+  span<uint8_t> Method() const { return method_; }
+  // Used to identify protocol connections attached to a specific
+  // target. See Target.attachToTarget, Target.setAutoAttach.
+  span<uint8_t> SessionId() const { return session_id_; }
+  // The call id, a sequence number that's used in responses to indicate
+  // the request to which the response belongs.
+  int32_t CallId() const { return call_id_; }
+  bool HasCallId() const { return has_call_id_; }
+  // The payload of the request in CBOR format. The |Dispatchable| parser does
+  // not parse into this; it only provides access to its raw contents here.
+  span<uint8_t> Params() const { return params_; }
+
+ private:
+  bool MaybeParseProperty(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseCallId(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseMethod(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseParams(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseSessionId(cbor::CBORTokenizer* tokenizer);
+
+  span<uint8_t> serialized_;
+
+  Status status_;
+
+  bool has_call_id_ = false;
+  int32_t call_id_;
+  span<uint8_t> method_;
+  bool params_seen_ = false;
+  span<uint8_t> params_;
+  span<uint8_t> session_id_;
+};
+
+// =============================================================================
+// Helpers for creating protocol cresponses and notifications.
+// =============================================================================
+
+// The resulting notifications can be sent to a protocol client,
+// usually via a FrontendChannel (see frontend_channel.h).
+
+std::unique_ptr<Serializable> CreateErrorResponse(
+    int callId,
+    DispatchResponse dispatch_response,
+    const ErrorSupport* errors = nullptr);
+
+std::unique_ptr<Serializable> CreateErrorNotification(
+    DispatchResponse dispatch_response);
+
+std::unique_ptr<Serializable> CreateResponse(
+    int callId,
+    std::unique_ptr<Serializable> params);
+
+std::unique_ptr<Serializable> CreateNotification(
+    const char* method,
+    std::unique_ptr<Serializable> params = nullptr);
+
+// =============================================================================
+// DomainDispatcher - Dispatching betwen protocol methods within a domain.
+// =============================================================================
+
+// This class is subclassed by |DomainDispatcherImpl|, which we generate per
+// DevTools domain. It contains routines called from the generated code,
+// e.g. ::MaybeReportInvalidParams, which are optimized for small code size.
+// The most important method is ::Dispatch, which implements method dispatch
+// by command name lookup.
+class DomainDispatcher {
+ public:
+  class WeakPtr {
+   public:
+    explicit WeakPtr(DomainDispatcher*);
+    ~WeakPtr();
+    DomainDispatcher* get() { return dispatcher_; }
+    void dispose() { dispatcher_ = nullptr; }
+
+   private:
+    DomainDispatcher* dispatcher_;
+  };
+
+  class Callback {
+   public:
+    virtual ~Callback();
+    void dispose();
+
+   protected:
+    // |method| must point at static storage (a C++ string literal in practice).
+    Callback(std::unique_ptr<WeakPtr> backend_impl,
+             int call_id,
+             span<uint8_t> method,
+             span<uint8_t> message);
+
+    void sendIfActive(std::unique_ptr<Serializable> partialMessage,
+                      const DispatchResponse& response);
+    void fallThroughIfActive();
+
+   private:
+    std::unique_ptr<WeakPtr> backend_impl_;
+    int call_id_;
+    // Subclasses of this class are instantiated from generated code which
+    // passes a string literal for the method name to the constructor. So the
+    // storage for |method| is the binary of the running process.
+    span<uint8_t> method_;
+    std::vector<uint8_t> message_;
+  };
+
+  explicit DomainDispatcher(FrontendChannel*);
+  virtual ~DomainDispatcher();
+
+  // Given a |command_name| without domain qualification, looks up the
+  // corresponding method. If the method is not found, returns nullptr.
+  // Otherwise, Returns a closure that will parse the provided
+  // Dispatchable.params() to a protocol object and execute the
+  // apprpropriate method. If the parsing fails it will issue an
+  // error response on the frontend channel, otherwise it will execute the
+  // command.
+  virtual std::function<void(const Dispatchable&)> Dispatch(
+      span<uint8_t> command_name) = 0;
+
+  // Sends a response to the client via the channel.
+  void sendResponse(int call_id,
+                    const DispatchResponse&,
+                    std::unique_ptr<Serializable> result = nullptr);
+
+  // Returns true if |errors| contains errors *and* reports these errors
+  // as a response on the frontend channel. Called from generated code,
+  // optimized for code size of the callee.
+  bool MaybeReportInvalidParams(const Dispatchable& dispatchable,
+                                const ErrorSupport& errors);
+  bool MaybeReportInvalidParams(const Dispatchable& dispatchable,
+                                const DeserializerState& state);
+
+  FrontendChannel* channel() { return frontend_channel_; }
+
+  void clearFrontend();
+
+  std::unique_ptr<WeakPtr> weakPtr();
+
+ private:
+  FrontendChannel* frontend_channel_;
+  std::unordered_set<WeakPtr*> weak_ptrs_;
+};
+
+// =============================================================================
+// UberDispatcher - dispatches between domains (backends).
+// =============================================================================
+class UberDispatcher {
+ public:
+  // Return type for ::Dispatch.
+  class DispatchResult {
+   public:
+    DispatchResult(bool method_found, std::function<void()> runnable);
+
+    // Indicates whether the method was found, that is, it could be dispatched
+    // to a backend registered with this dispatcher.
+    bool MethodFound() const { return method_found_; }
+
+    // Runs the dispatched result. This will send the appropriate error
+    // responses if the method wasn't found or if something went wrong during
+    // parameter parsing.
+    void Run();
+
+   private:
+    bool method_found_;
+    std::function<void()> runnable_;
+  };
+
+  // |frontend_hannel| can't be nullptr.
+  explicit UberDispatcher(FrontendChannel* frontend_channel);
+  virtual ~UberDispatcher();
+
+  // Dispatches the provided |dispatchable| considering all redirects and domain
+  // handlers registered with this uber dispatcher. Also see |DispatchResult|.
+  // |dispatchable.ok()| must hold - callers must check this separately and
+  // deal with errors.
+  DispatchResult Dispatch(const Dispatchable& dispatchable) const;
+
+  // Invoked from generated code for wiring domain backends; that is,
+  // connecting domain handlers to an uber dispatcher.
+  // See <domain-namespace>::Dispatcher::Wire(UberDispatcher*,Backend*).
+  FrontendChannel* channel() const {
+    assert(frontend_channel_);
+    return frontend_channel_;
+  }
+
+  // Invoked from generated code for wiring domain backends; that is,
+  // connecting domain handlers to an uber dispatcher.
+  // See <domain-namespace>::Dispatcher::Wire(UberDispatcher*,Backend*).
+  void WireBackend(span<uint8_t> domain,
+                   const std::vector<std::pair<span<uint8_t>, span<uint8_t>>>&,
+                   std::unique_ptr<DomainDispatcher> dispatcher);
+
+ private:
+  DomainDispatcher* findDispatcher(span<uint8_t> method);
+  FrontendChannel* const frontend_channel_;
+  // Pairs of ascii strings of the form ("Domain1.method1","Domain2.method2")
+  // indicating that the first element of each pair redirects to the second.
+  // Sorted by first element.
+  std::vector<std::pair<span<uint8_t>, span<uint8_t>>> redirects_;
+  // Domain dispatcher instances, sorted by their domain name.
+  std::vector<std::pair<span<uint8_t>, std::unique_ptr<DomainDispatcher>>>
+      dispatchers_;
+};
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_DISPATCH_H_

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/error_support.h

@@ -0,0 +1,62 @@
+// 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_ERROR_SUPPORT_H_
+#define V8_CRDTP_ERROR_SUPPORT_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "export.h"
+#include "span.h"
+
+namespace v8_crdtp {
+// =============================================================================
+// ErrorSupport - For tracking errors in tree structures.
+// =============================================================================
+
+// This abstraction is used when converting between Values and inspector
+// objects, e.g. in lib/ValueConversions_{h,cc}.template. As the processing
+// enters and exits a branch, we call Push / Pop. Within the branch,
+// we either set the name or an index (in case we're processing the element of a
+// list/vector). Only once an error is seen, the path which is now on the
+// stack is materialized and prefixes the error message. E.g.,
+// "foo.bar.2: some error". After error collection, ::Errors() is used to
+// access the message.
+class ErrorSupport {
+ public:
+  // Push / Pop operations for the path segments; after Push, either SetName or
+  // SetIndex must be called exactly once.
+  void Push();
+  void Pop();
+
+  // Sets the name of the current segment on the stack; e.g. a field name.
+  // |name| must be a C++ string literal in 7 bit US-ASCII.
+  void SetName(const char* name);
+  // Sets the index of the current segment on the stack; e.g. an array index.
+  void SetIndex(size_t index);
+
+  // Materializes the error internally. |error| must be a C++ string literal
+  // in 7 bit US-ASCII.
+  void AddError(const char* error);
+
+  // Returns the semicolon-separated list of errors as in 7 bit ASCII.
+  span<uint8_t> Errors() const;
+
+ private:
+  enum SegmentType { EMPTY, NAME, INDEX };
+  struct Segment {
+    SegmentType type = EMPTY;
+    union {
+      const char* name;
+      size_t index;
+    };
+  };
+  std::vector<Segment> stack_;
+  std::string errors_;
+};
+
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_ERROR_SUPPORT_H_

package/pods/Headers/inspector/third_party/inspector_protocol/crdtp/export.h

@@ -0,0 +1,6 @@
+// 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.
+
+// This file is V8 specific. It's not rolled from the upstream project.
+// CRDTP doesn't export symbols from V8, so it's empty.