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

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

@@ -0,0 +1,58 @@
+// 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_FIND_BY_FIRST_H_
+#define V8_CRDTP_FIND_BY_FIRST_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "export.h"
+#include "span.h"
+
+namespace v8_crdtp {
+// =============================================================================
+// FindByFirst - Retrieval from a sorted vector that's keyed by span<uint8_t>.
+// =============================================================================
+
+// Given a vector of pairs sorted by the first element of each pair, find
+// the corresponding value given a key to be compared to the first element.
+// Together with std::inplace_merge and pre-sorting or std::sort, this can
+// be used to implement a minimalistic equivalent of Chromium's flat_map.
+
+// In this variant, the template parameter |T| is a value type and a
+// |default_value| is provided.
+template <typename T>
+T FindByFirst(const std::vector<std::pair<span<uint8_t>, T>>& sorted_by_first,
+              span<uint8_t> key,
+              T default_value) {
+  auto it = std::lower_bound(
+      sorted_by_first.begin(), sorted_by_first.end(), key,
+      [](const std::pair<span<uint8_t>, T>& left, span<uint8_t> right) {
+        return SpanLessThan(left.first, right);
+      });
+  return (it != sorted_by_first.end() && SpanEquals(it->first, key))
+             ? it->second
+             : default_value;
+}
+
+// In this variant, the template parameter |T| is a class or struct that's
+// instantiated in std::unique_ptr, and we return either a T* or a nullptr.
+template <typename T>
+T* FindByFirst(const std::vector<std::pair<span<uint8_t>, std::unique_ptr<T>>>&
+                   sorted_by_first,
+               span<uint8_t> key) {
+  auto it = std::lower_bound(
+      sorted_by_first.begin(), sorted_by_first.end(), key,
+      [](const std::pair<span<uint8_t>, std::unique_ptr<T>>& left,
+         span<uint8_t> right) { return SpanLessThan(left.first, right); });
+  return (it != sorted_by_first.end() && SpanEquals(it->first, key))
+             ? it->second.get()
+             : nullptr;
+}
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_FIND_BY_FIRST_H_

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

@@ -0,0 +1,47 @@
+// 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_FRONTEND_CHANNEL_H_
+#define V8_CRDTP_FRONTEND_CHANNEL_H_
+
+#include <cstdint>
+#include <memory>
+#include "export.h"
+#include "serializable.h"
+#include "span.h"
+
+namespace v8_crdtp {
+// =============================================================================
+// FrontendChannel - For sending notifications and responses to protocol clients
+// =============================================================================
+class FrontendChannel {
+ public:
+  virtual ~FrontendChannel() = default;
+
+  // Sends protocol responses and notifications. The |call_id| parameter is
+  // seemingly redundant because it's also included in the message, but
+  // responses may be sent from an untrusted source to a trusted process (e.g.
+  // from Chromium's renderer (blink) to the browser process), which needs
+  // to be able to match the response to an earlier request without parsing the
+  // messsage.
+  virtual void SendProtocolResponse(int call_id,
+                                    std::unique_ptr<Serializable> message) = 0;
+  virtual void SendProtocolNotification(
+      std::unique_ptr<Serializable> message) = 0;
+
+  // FallThrough indicates that |message| should be handled in another layer.
+  // Usually this means the layer responding to the message didn't handle it,
+  // but in some cases messages are handled by multiple layers (e.g. both
+  // the embedder and the content layer in Chromium).
+  virtual void FallThrough(int call_id,
+                           span<uint8_t> method,
+                           span<uint8_t> message) = 0;
+
+  // Session implementations may queue notifications for performance or
+  // other considerations; this is a hook for domain handlers to manually flush.
+  virtual void FlushProtocolNotifications() = 0;
+};
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_FRONTEND_CHANNEL_H_

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

@@ -0,0 +1,80 @@
+// 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_GLUE_H_
+#define V8_CRDTP_GLUE_H_
+
+#include <cassert>
+#include <memory>
+
+namespace v8_crdtp {
+namespace glue {
+// =============================================================================
+// glue::detail::PtrMaybe, glue::detail::ValueMaybe, templates for optional
+// pointers / values which are used in ../lib/Forward_h.template.
+// =============================================================================
+namespace detail {
+template <typename T>
+class PtrMaybe {
+ public:
+  PtrMaybe() = default;
+  PtrMaybe(std::unique_ptr<T> value) : value_(std::move(value)) {}
+  PtrMaybe(PtrMaybe&& other) noexcept : value_(std::move(other.value_)) {}
+  void operator=(std::unique_ptr<T> value) { value_ = std::move(value); }
+  T* fromJust() const {
+    assert(value_);
+    return value_.get();
+  }
+  T* fromMaybe(T* default_value) const {
+    return value_ ? value_.get() : default_value;
+  }
+  bool isJust() const { return value_ != nullptr; }
+  std::unique_ptr<T> takeJust() {
+    assert(value_);
+    return std::move(value_);
+  }
+
+ private:
+  std::unique_ptr<T> value_;
+};
+
+template <typename T>
+class ValueMaybe {
+ public:
+  ValueMaybe() : is_just_(false), value_() {}
+  ValueMaybe(T value) : is_just_(true), value_(std::move(value)) {}
+  ValueMaybe(ValueMaybe&& other) noexcept
+      : is_just_(other.is_just_), value_(std::move(other.value_)) {}
+  void operator=(T value) {
+    value_ = value;
+    is_just_ = true;
+  }
+  const T& fromJust() const {
+    assert(is_just_);
+    return value_;
+  }
+  const T& fromMaybe(const T& default_value) const {
+    return is_just_ ? value_ : default_value;
+  }
+  bool isJust() const { return is_just_; }
+  T takeJust() {
+    assert(is_just_);
+    is_just_ = false;
+    return std::move(value_);
+  }
+
+ private:
+  bool is_just_;
+  T value_;
+};
+}  // namespace detail
+}  // namespace glue
+}  // namespace v8_crdtp
+
+#define PROTOCOL_DISALLOW_COPY(ClassName) \
+ private:                                 \
+  ClassName(const ClassName&) = delete;   \
+  ClassName& operator=(const ClassName&) = delete
+
+#endif  // V8_CRDTP_GLUE_H_

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

@@ -0,0 +1,52 @@
+// 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 <memory>
+#include <vector>
+#include "export.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<ParserHandler> NewJSONEncoder(std::vector<uint8_t>* out,
+                                              Status* status);
+
+std::unique_ptr<ParserHandler> NewJSONEncoder(std::string* out, Status* status);
+
+// =============================================================================
+// json::ParseJSON - for receiving streaming parser events for JSON
+// =============================================================================
+
+void ParseJSON(span<uint8_t> chars, ParserHandler* handler);
+
+void ParseJSON(span<uint16_t> chars, ParserHandler* handler);
+
+// =============================================================================
+// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
+// =============================================================================
+
+Status ConvertCBORToJSON(span<uint8_t> cbor, std::string* json);
+
+Status ConvertCBORToJSON(span<uint8_t> cbor, std::vector<uint8_t>* json);
+
+Status ConvertJSONToCBOR(span<uint8_t> json, std::vector<uint8_t>* cbor);
+
+Status ConvertJSONToCBOR(span<uint16_t> json, std::vector<uint8_t>* cbor);
+}  // namespace json
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_JSON_H_

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

@@ -0,0 +1,26 @@
+// 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 <string>
+
+namespace v8_crdtp {
+namespace json {
+// These routines are implemented in json_platform.cc, or in a
+// platform-dependent (code-base dependent) custom replacement.
+// E.g., json_platform_chromium.cc, json_platform_v8.cc.
+namespace platform {
+// Parses |str| into |result|. Returns false iff there are
+// leftover characters or parsing errors.
+bool StrToD(const char* str, double* result);
+
+// Prints |value| in a format suitable for JSON.
+std::string DToStr(double value);
+}  // namespace platform
+}  // namespace json
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_JSON_PLATFORM_H_

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

@@ -0,0 +1,104 @@
+// 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_MAYBE_H_
+#define V8_CRDTP_MAYBE_H_
+
+#include <cassert>
+#include <memory>
+
+namespace v8_crdtp {
+
+// =============================================================================
+// detail::PtrMaybe, detail::ValueMaybe, templates for optional
+// pointers / values which are used in ../lib/Forward_h.template.
+// =============================================================================
+
+namespace detail {
+template <typename T>
+class PtrMaybe {
+ public:
+  PtrMaybe() = default;
+  PtrMaybe(std::unique_ptr<T> value) : value_(std::move(value)) {}
+  PtrMaybe(PtrMaybe&& other) noexcept : value_(std::move(other.value_)) {}
+  void operator=(std::unique_ptr<T> value) { value_ = std::move(value); }
+  T* fromJust() const {
+    assert(value_);
+    return value_.get();
+  }
+  T* fromMaybe(T* default_value) const {
+    return value_ ? value_.get() : default_value;
+  }
+  bool isJust() const { return value_ != nullptr; }
+  std::unique_ptr<T> takeJust() {
+    assert(value_);
+    return std::move(value_);
+  }
+
+ private:
+  std::unique_ptr<T> value_;
+};
+
+template <typename T>
+class ValueMaybe {
+ public:
+  ValueMaybe() : is_just_(false), value_() {}
+  ValueMaybe(T value) : is_just_(true), value_(std::move(value)) {}
+  ValueMaybe(ValueMaybe&& other) noexcept
+      : is_just_(other.is_just_), value_(std::move(other.value_)) {}
+  void operator=(T value) {
+    value_ = value;
+    is_just_ = true;
+  }
+  const T& fromJust() const {
+    assert(is_just_);
+    return value_;
+  }
+  const T& fromMaybe(const T& default_value) const {
+    return is_just_ ? value_ : default_value;
+  }
+  bool isJust() const { return is_just_; }
+  T takeJust() {
+    assert(is_just_);
+    is_just_ = false;
+    return std::move(value_);
+  }
+
+ private:
+  bool is_just_;
+  T value_;
+};
+
+template <typename T>
+struct MaybeTypedef {
+  typedef PtrMaybe<T> type;
+};
+
+template <>
+struct MaybeTypedef<bool> {
+  typedef ValueMaybe<bool> type;
+};
+
+template <>
+struct MaybeTypedef<int> {
+  typedef ValueMaybe<int> type;
+};
+
+template <>
+struct MaybeTypedef<double> {
+  typedef ValueMaybe<double> type;
+};
+
+template <>
+struct MaybeTypedef<std::string> {
+  typedef ValueMaybe<std::string> type;
+};
+
+}  // namespace detail
+
+template <typename T>
+using Maybe = typename detail::MaybeTypedef<T>::type;
+
+}  // namespace v8_crdtp
+
+#endif  // V8_CRDTP_MAYBE_H_

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

@@ -0,0 +1,39 @@
+// 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 <cstdint>
+#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 ParserHandler {
+ public:
+  virtual ~ParserHandler() = 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_