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

package/pods/Headers/inspector/src/inspector/remote-object-id.h

@@ -0,0 +1,54 @@
+// Copyright 2015 the V8 project 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_INSPECTOR_REMOTE_OBJECT_ID_H_
+#define V8_INSPECTOR_REMOTE_OBJECT_ID_H_
+
+#include <memory>
+
+#include "src/inspector/protocol/Forward.h"
+
+namespace v8_inspector {
+
+using protocol::Response;
+
+class RemoteObjectIdBase {
+ public:
+  uint64_t isolateId() const { return m_isolateId; }
+  int contextId() const { return m_injectedScriptId; }
+
+ protected:
+  RemoteObjectIdBase();
+  ~RemoteObjectIdBase() = default;
+
+  bool parseId(const String16&);
+
+  uint64_t m_isolateId;
+  int m_injectedScriptId;
+  int m_id;
+};
+
+class RemoteObjectId final : public RemoteObjectIdBase {
+ public:
+  static Response parse(const String16&, std::unique_ptr<RemoteObjectId>*);
+  ~RemoteObjectId() = default;
+  int id() const { return m_id; }
+
+  static String16 serialize(uint64_t isolateId, int injectedScriptId, int id);
+};
+
+class RemoteCallFrameId final : public RemoteObjectIdBase {
+ public:
+  static Response parse(const String16&, std::unique_ptr<RemoteCallFrameId>*);
+  ~RemoteCallFrameId() = default;
+
+  int frameOrdinal() const { return m_id; }
+
+  static String16 serialize(uint64_t isolateId, int injectedScriptId,
+                            int frameOrdinal);
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_REMOTE_OBJECT_ID_H_

package/pods/Headers/inspector/src/inspector/search-util.h

@@ -0,0 +1,26 @@
+// Copyright 2016 the V8 project 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_INSPECTOR_SEARCH_UTIL_H_
+#define V8_INSPECTOR_SEARCH_UTIL_H_
+
+#include <memory>
+
+#include "src/inspector/protocol/Debugger.h"
+#include "src/inspector/string-util.h"
+
+namespace v8_inspector {
+
+class V8InspectorSession;
+
+String16 findSourceURL(const String16& content, bool multiline);
+String16 findSourceMapURL(const String16& content, bool multiline);
+std::vector<std::unique_ptr<protocol::Debugger::SearchMatch>>
+searchInTextByLinesImpl(V8InspectorSession*, const String16& text,
+                        const String16& query, bool caseSensitive,
+                        bool isRegex);
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_SEARCH_UTIL_H_

package/pods/Headers/inspector/src/inspector/string-16.h

@@ -0,0 +1,180 @@
+// Copyright 2016 the V8 project 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_INSPECTOR_STRING_16_H_
+#define V8_INSPECTOR_STRING_16_H_
+
+#include <stdint.h>
+#include <cctype>
+#include <climits>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "../../third_party/inspector_protocol/crdtp/serializer_traits.h"
+#include "src/base/compiler-specific.h"
+
+namespace v8_inspector {
+
+using UChar = uint16_t;
+
+class String16 {
+ public:
+  static const size_t kNotFound = static_cast<size_t>(-1);
+
+  String16() = default;
+  String16(const String16&) V8_NOEXCEPT = default;
+  String16(String16&&) V8_NOEXCEPT = default;
+  String16(const UChar* characters, size_t size);
+  V8_EXPORT String16(const UChar* characters);
+  V8_EXPORT String16(const char* characters);
+  String16(const char* characters, size_t size);
+  explicit String16(const std::basic_string<UChar>& impl);
+  explicit String16(std::basic_string<UChar>&& impl);
+
+  String16& operator=(const String16&) V8_NOEXCEPT = default;
+  String16& operator=(String16&&) V8_NOEXCEPT = default;
+
+  static String16 fromInteger(int);
+  static String16 fromInteger(size_t);
+  static String16 fromInteger64(int64_t);
+  static String16 fromUInt64(uint64_t);
+  static String16 fromDouble(double);
+  static String16 fromDouble(double, int precision);
+
+  int64_t toInteger64(bool* ok = nullptr) const;
+  uint64_t toUInt64(bool* ok = nullptr) const;
+  int toInteger(bool* ok = nullptr) const;
+  String16 stripWhiteSpace() const;
+  const UChar* characters16() const { return m_impl.c_str(); }
+  size_t length() const { return m_impl.length(); }
+  bool isEmpty() const { return !m_impl.length(); }
+  UChar operator[](size_t index) const { return m_impl[index]; }
+  String16 substring(size_t pos, size_t len = UINT_MAX) const {
+    return String16(m_impl.substr(pos, len));
+  }
+  size_t find(const String16& str, size_t start = 0) const {
+    return m_impl.find(str.m_impl, start);
+  }
+  size_t reverseFind(const String16& str, size_t start = UINT_MAX) const {
+    return m_impl.rfind(str.m_impl, start);
+  }
+  size_t find(UChar c, size_t start = 0) const { return m_impl.find(c, start); }
+  size_t reverseFind(UChar c, size_t start = UINT_MAX) const {
+    return m_impl.rfind(c, start);
+  }
+  void swap(String16& other) {
+    m_impl.swap(other.m_impl);
+    std::swap(hash_code, other.hash_code);
+  }
+
+  // Convenience methods.
+  V8_EXPORT std::string utf8() const;
+  V8_EXPORT static String16 fromUTF8(const char* stringStart, size_t length);
+
+  // Instantiates a String16 in native endianness from UTF16 LE.
+  // On Big endian architectures, byte order needs to be flipped.
+  V8_EXPORT static String16 fromUTF16LE(const UChar* stringStart,
+                                        size_t length);
+
+  std::size_t hash() const {
+    if (!hash_code) {
+      for (char c : m_impl) hash_code = 31 * hash_code + c;
+      // Map hash code 0 to 1. This double the number of hash collisions for 1,
+      // but avoids recomputing the hash code.
+      if (!hash_code) ++hash_code;
+    }
+    return hash_code;
+  }
+
+  inline bool operator==(const String16& other) const {
+    return m_impl == other.m_impl;
+  }
+  inline bool operator<(const String16& other) const {
+    return m_impl < other.m_impl;
+  }
+  inline bool operator!=(const String16& other) const {
+    return m_impl != other.m_impl;
+  }
+  inline String16 operator+(const String16& other) const {
+    return String16(m_impl + other.m_impl);
+  }
+  inline String16& operator+=(const String16& other) {
+    m_impl += other.m_impl;
+    return *this;
+  }
+
+  // Defined later, since it uses the String16Builder.
+  template <typename... T>
+  static String16 concat(T... args);
+
+ private:
+  std::basic_string<UChar> m_impl;
+  mutable std::size_t hash_code = 0;
+};
+
+inline String16 operator+(const char* a, const String16& b) {
+  return String16(a) + b;
+}
+
+class String16Builder {
+ public:
+  String16Builder();
+  void append(const String16&);
+  void append(UChar);
+  void append(char);
+  void append(const UChar*, size_t);
+  void append(const char*, size_t);
+  void appendNumber(int);
+  void appendNumber(size_t);
+  void appendUnsignedAsHex(uint64_t);
+  void appendUnsignedAsHex(uint32_t);
+  void appendUnsignedAsHex(uint8_t);
+  String16 toString();
+  void reserveCapacity(size_t);
+
+  template <typename T, typename... R>
+  void appendAll(T first, R... rest) {
+    append(first);
+    appendAll(rest...);
+  }
+  void appendAll() {}
+
+ private:
+  std::vector<UChar> m_buffer;
+};
+
+template <typename... T>
+String16 String16::concat(T... args) {
+  String16Builder builder;
+  builder.appendAll(args...);
+  return builder.toString();
+}
+
+}  // namespace v8_inspector
+
+#if !defined(__APPLE__) || defined(_LIBCPP_VERSION)
+
+namespace std {
+template <>
+struct hash<v8_inspector::String16> {
+  std::size_t operator()(const v8_inspector::String16& string) const {
+    return string.hash();
+  }
+};
+
+}  // namespace std
+
+#endif  // !defined(__APPLE__) || defined(_LIBCPP_VERSION)
+
+// See third_party/inspector_protocol/crdtp/serializer_traits.h.
+namespace v8_crdtp {
+template <>
+struct SerializerTraits<v8_inspector::String16> {
+  static void Serialize(const v8_inspector::String16& str,
+                        std::vector<uint8_t>* out);
+};
+}  // namespace v8_crdtp
+
+#endif  // V8_INSPECTOR_STRING_16_H_

package/pods/Headers/inspector/src/inspector/string-util.h

@@ -0,0 +1,128 @@
+// Copyright 2016 the V8 project 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_INSPECTOR_STRING_UTIL_H_
+#define V8_INSPECTOR_STRING_UTIL_H_
+
+#include <stdint.h>
+
+#include <memory>
+
+#include "../../third_party/inspector_protocol/crdtp/protocol_core.h"
+#include "include/v8-inspector.h"
+#include "src/base/logging.h"
+#include "src/base/macros.h"
+#include "src/inspector/string-16.h"
+
+namespace v8_inspector {
+
+namespace protocol {
+
+class Value;
+
+using String = v8_inspector::String16;
+
+class StringUtil {
+ public:
+  static String fromUTF8(const uint8_t* data, size_t length) {
+    return String16::fromUTF8(reinterpret_cast<const char*>(data), length);
+  }
+
+  static String fromUTF16LE(const uint16_t* data, size_t length) {
+    return String16::fromUTF16LE(data, length);
+  }
+
+  static const uint8_t* CharactersLatin1(const String& s) { return nullptr; }
+  static const uint8_t* CharactersUTF8(const String& s) { return nullptr; }
+  static const uint16_t* CharactersUTF16(const String& s) {
+    return s.characters16();
+  }
+  static size_t CharacterCount(const String& s) { return s.length(); }
+};
+
+// A read-only sequence of uninterpreted bytes with reference-counted storage.
+class V8_EXPORT Binary {
+ public:
+  Binary() = default;
+
+  const uint8_t* data() const { return bytes_->data(); }
+  size_t size() const { return bytes_->size(); }
+  String toBase64() const;
+  static Binary fromBase64(const String& base64, bool* success);
+  static Binary fromSpan(const uint8_t* data, size_t size) {
+    return Binary(std::make_shared<std::vector<uint8_t>>(data, data + size));
+  }
+
+ private:
+  std::shared_ptr<std::vector<uint8_t>> bytes_;
+
+  explicit Binary(std::shared_ptr<std::vector<uint8_t>> bytes)
+      : bytes_(bytes) {}
+};
+}  // namespace protocol
+
+v8::Local<v8::String> toV8String(v8::Isolate*, const String16&);
+v8::Local<v8::String> toV8StringInternalized(v8::Isolate*, const String16&);
+v8::Local<v8::String> toV8StringInternalized(v8::Isolate*, const char*);
+v8::Local<v8::String> toV8String(v8::Isolate*, const StringView&);
+// TODO(dgozman): rename to toString16.
+String16 toProtocolString(v8::Isolate*, v8::Local<v8::String>);
+String16 toProtocolStringWithTypeCheck(v8::Isolate*, v8::Local<v8::Value>);
+String16 toString16(const StringView&);
+StringView toStringView(const String16&);
+bool stringViewStartsWith(const StringView&, const char*);
+
+// Creates a string buffer instance which owns |str|, a 16 bit string.
+std::unique_ptr<StringBuffer> StringBufferFrom(String16 str);
+
+// Creates a string buffer instance which owns |str|, an 8 bit string.
+// 8 bit strings are used for LATIN1 text (which subsumes 7 bit ASCII, e.g.
+// our generated JSON), as well as for CBOR encoded binary messages.
+std::unique_ptr<StringBuffer> StringBufferFrom(std::vector<uint8_t> str);
+
+String16 stackTraceIdToString(uintptr_t id);
+
+}  // namespace v8_inspector
+
+// See third_party/inspector_protocol/crdtp/serializer_traits.h.
+namespace v8_crdtp {
+
+template <>
+struct ProtocolTypeTraits<v8_inspector::String16> {
+  static bool Deserialize(DeserializerState* state,
+                          v8_inspector::String16* value);
+  static void Serialize(const v8_inspector::String16& value,
+                        std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct ProtocolTypeTraits<v8_inspector::protocol::Binary> {
+  static bool Deserialize(DeserializerState* state,
+                          v8_inspector::protocol::Binary* value);
+  static void Serialize(const v8_inspector::protocol::Binary& value,
+                        std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct SerializerTraits<v8_inspector::protocol::Binary> {
+  static void Serialize(const v8_inspector::protocol::Binary& binary,
+                        std::vector<uint8_t>* out);
+};
+
+namespace detail {
+template <>
+struct MaybeTypedef<v8_inspector::String16> {
+  typedef ValueMaybe<v8_inspector::String16> type;
+};
+
+template <>
+struct MaybeTypedef<v8_inspector::protocol::Binary> {
+  typedef ValueMaybe<v8_inspector::protocol::Binary> type;
+};
+
+}  // namespace detail
+
+}  // namespace v8_crdtp
+
+#endif  // V8_INSPECTOR_STRING_UTIL_H_

package/pods/Headers/inspector/src/inspector/v8-console-agent-impl.h

@@ -0,0 +1,48 @@
+// Copyright 2016 the V8 project 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_INSPECTOR_V8_CONSOLE_AGENT_IMPL_H_
+#define V8_INSPECTOR_V8_CONSOLE_AGENT_IMPL_H_
+
+#include "src/base/macros.h"
+#include "src/inspector/protocol/Console.h"
+#include "src/inspector/protocol/Forward.h"
+
+namespace v8_inspector {
+
+class V8ConsoleMessage;
+class V8InspectorSessionImpl;
+
+using protocol::Response;
+
+class V8ConsoleAgentImpl : public protocol::Console::Backend {
+ public:
+  V8ConsoleAgentImpl(V8InspectorSessionImpl*, protocol::FrontendChannel*,
+                     protocol::DictionaryValue* state);
+  ~V8ConsoleAgentImpl() override;
+  V8ConsoleAgentImpl(const V8ConsoleAgentImpl&) = delete;
+  V8ConsoleAgentImpl& operator=(const V8ConsoleAgentImpl&) = delete;
+
+  Response enable() override;
+  Response disable() override;
+  Response clearMessages() override;
+
+  void restore();
+  void messageAdded(V8ConsoleMessage*);
+  void reset();
+  bool enabled();
+
+ private:
+  void reportAllMessages();
+  bool reportMessage(V8ConsoleMessage*, bool generatePreview);
+
+  V8InspectorSessionImpl* m_session;
+  protocol::DictionaryValue* m_state;
+  protocol::Console::Frontend m_frontend;
+  bool m_enabled;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_CONSOLE_AGENT_IMPL_H_

package/pods/Headers/inspector/src/inspector/v8-console-message.h

@@ -0,0 +1,147 @@
+// Copyright 2016 the V8 project 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_INSPECTOR_V8_CONSOLE_MESSAGE_H_
+#define V8_INSPECTOR_V8_CONSOLE_MESSAGE_H_
+
+#include <deque>
+#include <map>
+#include <memory>
+#include <set>
+
+#include "include/v8.h"
+#include "src/inspector/protocol/Console.h"
+#include "src/inspector/protocol/Forward.h"
+#include "src/inspector/protocol/Runtime.h"
+
+namespace v8_inspector {
+
+class InspectedContext;
+class V8InspectorImpl;
+class V8InspectorSessionImpl;
+class V8StackTraceImpl;
+
+enum class V8MessageOrigin { kConsole, kException, kRevokedException };
+
+enum class ConsoleAPIType {
+  kLog,
+  kDebug,
+  kInfo,
+  kError,
+  kWarning,
+  kDir,
+  kDirXML,
+  kTable,
+  kTrace,
+  kStartGroup,
+  kStartGroupCollapsed,
+  kEndGroup,
+  kClear,
+  kAssert,
+  kTimeEnd,
+  kCount
+};
+
+class V8ConsoleMessage {
+ public:
+  ~V8ConsoleMessage();
+
+  static std::unique_ptr<V8ConsoleMessage> createForConsoleAPI(
+      v8::Local<v8::Context> v8Context, int contextId, int groupId,
+      V8InspectorImpl* inspector, double timestamp, ConsoleAPIType,
+      const std::vector<v8::Local<v8::Value>>& arguments,
+      const String16& consoleContext, std::unique_ptr<V8StackTraceImpl>);
+
+  static std::unique_ptr<V8ConsoleMessage> createForException(
+      double timestamp, const String16& detailedMessage, const String16& url,
+      unsigned lineNumber, unsigned columnNumber,
+      std::unique_ptr<V8StackTraceImpl>, int scriptId, v8::Isolate*,
+      const String16& message, int contextId, v8::Local<v8::Value> exception,
+      unsigned exceptionId);
+
+  static std::unique_ptr<V8ConsoleMessage> createForRevokedException(
+      double timestamp, const String16& message, unsigned revokedExceptionId);
+
+  V8MessageOrigin origin() const;
+  void reportToFrontend(protocol::Console::Frontend*) const;
+  void reportToFrontend(protocol::Runtime::Frontend*, V8InspectorSessionImpl*,
+                        bool generatePreview) const;
+  ConsoleAPIType type() const;
+  void contextDestroyed(int contextId);
+
+  int estimatedSize() const {
+    return m_v8Size + static_cast<int>(m_message.length() * sizeof(UChar));
+  }
+
+ private:
+  V8ConsoleMessage(V8MessageOrigin, double timestamp, const String16& message);
+
+  using Arguments = std::vector<std::unique_ptr<v8::Global<v8::Value>>>;
+  std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>>
+  wrapArguments(V8InspectorSessionImpl*, bool generatePreview) const;
+  std::unique_ptr<protocol::Runtime::RemoteObject> wrapException(
+      V8InspectorSessionImpl*, bool generatePreview) const;
+  void setLocation(const String16& url, unsigned lineNumber,
+                   unsigned columnNumber, std::unique_ptr<V8StackTraceImpl>,
+                   int scriptId);
+
+  V8MessageOrigin m_origin;
+  double m_timestamp;
+  String16 m_message;
+  String16 m_url;
+  unsigned m_lineNumber;
+  unsigned m_columnNumber;
+  std::unique_ptr<V8StackTraceImpl> m_stackTrace;
+  int m_scriptId;
+  int m_contextId;
+  ConsoleAPIType m_type;
+  unsigned m_exceptionId;
+  unsigned m_revokedExceptionId;
+  int m_v8Size = 0;
+  Arguments m_arguments;
+  String16 m_detailedMessage;
+  String16 m_consoleContext;
+};
+
+class V8ConsoleMessageStorage {
+ public:
+  V8ConsoleMessageStorage(V8InspectorImpl*, int contextGroupId);
+  ~V8ConsoleMessageStorage();
+
+  int contextGroupId() { return m_contextGroupId; }
+  const std::deque<std::unique_ptr<V8ConsoleMessage>>& messages() const {
+    return m_messages;
+  }
+
+  void addMessage(std::unique_ptr<V8ConsoleMessage>);
+  void contextDestroyed(int contextId);
+  void clear();
+
+  bool shouldReportDeprecationMessage(int contextId, const String16& method);
+  int count(int contextId, const String16& id);
+  bool countReset(int contextId, const String16& id);
+  void time(int contextId, const String16& id);
+  double timeLog(int contextId, const String16& id);
+  double timeEnd(int contextId, const String16& id);
+  bool hasTimer(int contextId, const String16& id);
+
+ private:
+  V8InspectorImpl* m_inspector;
+  int m_contextGroupId;
+  int m_estimatedSize = 0;
+  std::deque<std::unique_ptr<V8ConsoleMessage>> m_messages;
+
+  struct PerContextData {
+    std::set<String16> m_reportedDeprecationMessages;
+    // Corresponds to https://console.spec.whatwg.org/#count-map
+    std::map<String16, int> m_count;
+    // Corresponds to https://console.spec.whatwg.org/#timer-table
+    std::map<String16, double> m_time;
+  };
+  std::map<int, PerContextData> m_data;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_INSPECTOR_V8_CONSOLE_MESSAGE_H_