@triniwiz/nativescript-masonkit 1.0.0-alpha.8 → 1.0.0-beta.0

package/src-native/pods/Headers/include/v8-initialization.h

@@ -1,315 +0,0 @@
-// Copyright 2021 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 INCLUDE_V8_INITIALIZATION_H_
-#define INCLUDE_V8_INITIALIZATION_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "v8-callbacks.h"  // NOLINT(build/include_directory)
-#include "v8-internal.h"   // NOLINT(build/include_directory)
-#include "v8-isolate.h"    // NOLINT(build/include_directory)
-#include "v8-platform.h"   // NOLINT(build/include_directory)
-#include "v8config.h"      // NOLINT(build/include_directory)
-
-// We reserve the V8_* prefix for macros defined in V8 public API and
-// assume there are no name conflicts with the embedder's code.
-
-/**
- * The v8 JavaScript engine.
- */
-namespace v8 {
-
-class PageAllocator;
-class Platform;
-template <class K, class V, class T>
-class PersistentValueMapBase;
-
-/**
- * EntropySource is used as a callback function when v8 needs a source
- * of entropy.
- */
-using EntropySource = bool (*)(unsigned char* buffer, size_t length);
-
-/**
- * ReturnAddressLocationResolver is used as a callback function when v8 is
- * resolving the location of a return address on the stack. Profilers that
- * change the return address on the stack can use this to resolve the stack
- * location to wherever the profiler stashed the original return address.
- *
- * \param return_addr_location A location on stack where a machine
- *    return address resides.
- * \returns Either return_addr_location, or else a pointer to the profiler's
- *    copy of the original return address.
- *
- * \note The resolver function must not cause garbage collection.
- */
-using ReturnAddressLocationResolver =
-    uintptr_t (*)(uintptr_t return_addr_location);
-
-using DcheckErrorCallback = void (*)(const char* file, int line,
-                                     const char* message);
-
-/**
- * Container class for static utility functions.
- */
-class V8_EXPORT V8 {
- public:
-  /**
-   * Hand startup data to V8, in case the embedder has chosen to build
-   * V8 with external startup data.
-   *
-   * Note:
-   * - By default the startup data is linked into the V8 library, in which
-   *   case this function is not meaningful.
-   * - If this needs to be called, it needs to be called before V8
-   *   tries to make use of its built-ins.
-   * - To avoid unnecessary copies of data, V8 will point directly into the
-   *   given data blob, so pretty please keep it around until V8 exit.
-   * - Compression of the startup blob might be useful, but needs to
-   *   handled entirely on the embedders' side.
-   * - The call will abort if the data is invalid.
-   */
-  static void SetSnapshotDataBlob(StartupData* startup_blob);
-
-  /** Set the callback to invoke in case of Dcheck failures. */
-  static void SetDcheckErrorHandler(DcheckErrorCallback that);
-
-  /**
-   * Sets V8 flags from a string.
-   */
-  static void SetFlagsFromString(const char* str);
-  static void SetFlagsFromString(const char* str, size_t length);
-
-  /**
-   * Sets V8 flags from the command line.
-   */
-  static void SetFlagsFromCommandLine(int* argc, char** argv,
-                                      bool remove_flags);
-
-  /** Get the version string. */
-  static const char* GetVersion();
-
-  /**
-   * Initializes V8. This function needs to be called before the first Isolate
-   * is created. It always returns true.
-   */
-  V8_INLINE static bool Initialize() {
-    const int kBuildConfiguration =
-        (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) |
-        (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) |
-        (internal::SandboxedExternalPointersAreEnabled()
-             ? kSandboxedExternalPointers
-             : 0) |
-        (internal::SandboxIsEnabled() ? kSandbox : 0);
-    return Initialize(kBuildConfiguration);
-  }
-
-  /**
-   * Allows the host application to provide a callback which can be used
-   * as a source of entropy for random number generators.
-   */
-  static void SetEntropySource(EntropySource source);
-
-  /**
-   * Allows the host application to provide a callback that allows v8 to
-   * cooperate with a profiler that rewrites return addresses on stack.
-   */
-  static void SetReturnAddressLocationResolver(
-      ReturnAddressLocationResolver return_address_resolver);
-
-  /**
-   * Releases any resources used by v8 and stops any utility threads
-   * that may be running.  Note that disposing v8 is permanent, it
-   * cannot be reinitialized.
-   *
-   * It should generally not be necessary to dispose v8 before exiting
-   * a process, this should happen automatically.  It is only necessary
-   * to use if the process needs the resources taken up by v8.
-   */
-  static bool Dispose();
-
-  /**
-   * Initialize the ICU library bundled with V8. The embedder should only
-   * invoke this method when using the bundled ICU. Returns true on success.
-   *
-   * If V8 was compiled with the ICU data in an external file, the location
-   * of the data file has to be provided.
-   */
-  static bool InitializeICU(const char* icu_data_file = nullptr);
-
-  /**
-   * Initialize the ICU library bundled with V8. The embedder should only
-   * invoke this method when using the bundled ICU. If V8 was compiled with
-   * the ICU data in an external file and when the default location of that
-   * file should be used, a path to the executable must be provided.
-   * Returns true on success.
-   *
-   * The default is a file called icudtl.dat side-by-side with the executable.
-   *
-   * Optionally, the location of the data file can be provided to override the
-   * default.
-   */
-  static bool InitializeICUDefaultLocation(const char* exec_path,
-                                           const char* icu_data_file = nullptr);
-
-  /**
-   * Initialize the external startup data. The embedder only needs to
-   * invoke this method when external startup data was enabled in a build.
-   *
-   * If V8 was compiled with the startup data in an external file, then
-   * V8 needs to be given those external files during startup. There are
-   * three ways to do this:
-   * - InitializeExternalStartupData(const char*)
-   *   This will look in the given directory for the file "snapshot_blob.bin".
-   * - InitializeExternalStartupDataFromFile(const char*)
-   *   As above, but will directly use the given file name.
-   * - Call SetSnapshotDataBlob.
-   *   This will read the blobs from the given data structure and will
-   *   not perform any file IO.
-   */
-  static void InitializeExternalStartupData(const char* directory_path);
-  static void InitializeExternalStartupDataFromFile(const char* snapshot_blob);
-
-  /**
-   * Sets the v8::Platform to use. This should be invoked before V8 is
-   * initialized.
-   */
-  static void InitializePlatform(Platform* platform);
-
-  /**
-   * Clears all references to the v8::Platform. This should be invoked after
-   * V8 was disposed.
-   */
-  static void DisposePlatform();
-  V8_DEPRECATED("Use DisposePlatform()")
-  static void ShutdownPlatform() { DisposePlatform(); }
-
-#ifdef V8_SANDBOX
-  //
-  // Sandbox related API.
-  //
-  // This API is not yet stable and subject to changes in the future.
-  //
-
-  /**
-   * Initializes the V8 sandbox.
-   *
-   * This must be invoked after the platform was initialized but before V8 is
-   * initialized. The sandbox is torn down during platform shutdown.
-   * Returns true on success, false otherwise.
-   *
-   * TODO(saelo) Once it is no longer optional to initialize the sandbox when
-   * compiling with V8_SANDBOX, the sandbox initialization will likely happen
-   * as part of V8::Initialize, at which point this function should be removed.
-   */
-  static bool InitializeSandbox();
-  V8_DEPRECATE_SOON("Use InitializeSandbox()")
-  static bool InitializeVirtualMemoryCage() { return InitializeSandbox(); }
-
-  /**
-   * Provides access to the virtual address subspace backing the sandbox.
-   *
-   * This can be used to allocate pages inside the sandbox, for example to
-   * obtain virtual memory for ArrayBuffer backing stores, which must be
-   * located inside the sandbox.
-   *
-   * It should be assumed that an attacker can corrupt data inside the sandbox,
-   * and so in particular the contents of pages allocagted in this virtual
-   * address space, arbitrarily and concurrently. Due to this, it is
-   * recommended to to only place pure data buffers in them.
-   *
-   * This function must only be called after initializing the sandbox.
-   */
-  static VirtualAddressSpace* GetSandboxAddressSpace();
-  V8_DEPRECATE_SOON("Use GetSandboxAddressSpace()")
-  static PageAllocator* GetVirtualMemoryCagePageAllocator();
-
-  /**
-   * Returns the size of the sandbox in bytes.
-   *
-   * If the sandbox has not been initialized, or if the initialization failed,
-   * this returns zero.
-   */
-  static size_t GetSandboxSizeInBytes();
-  V8_DEPRECATE_SOON("Use GetSandboxSizeInBytes()")
-  static size_t GetVirtualMemoryCageSizeInBytes() {
-    return GetSandboxSizeInBytes();
-  }
-
-  /**
-   * Returns whether the sandbox is configured securely.
-   *
-   * If V8 cannot create a proper sandbox, it will fall back to creating a
-   * sandbox that doesn't have the desired security properties but at least
-   * still allows V8 to function. This API can be used to determine if such an
-   * insecure sandbox is being used, in which case it will return false.
-   */
-  static bool IsSandboxConfiguredSecurely();
-  V8_DEPRECATE_SOON("Use IsSandboxConfiguredSecurely()")
-  static bool IsUsingSecureVirtualMemoryCage() {
-    return IsSandboxConfiguredSecurely();
-  }
-#endif
-
-  /**
-   * Activate trap-based bounds checking for WebAssembly.
-   *
-   * \param use_v8_signal_handler Whether V8 should install its own signal
-   * handler or rely on the embedder's.
-   */
-  static bool EnableWebAssemblyTrapHandler(bool use_v8_signal_handler);
-
-#if defined(V8_OS_WIN)
-  /**
-   * On Win64, by default V8 does not emit unwinding data for jitted code,
-   * which means the OS cannot walk the stack frames and the system Structured
-   * Exception Handling (SEH) cannot unwind through V8-generated code:
-   * https://code.google.com/p/v8/issues/detail?id=3598.
-   *
-   * This function allows embedders to register a custom exception handler for
-   * exceptions in V8-generated code.
-   */
-  static void SetUnhandledExceptionCallback(
-      UnhandledExceptionCallback unhandled_exception_callback);
-#endif
-
-  /**
-   * Allows the host application to provide a callback that will be called when
-   * v8 has encountered a fatal failure to allocate memory and is about to
-   * terminate.
-   */
-
-  static void SetFatalMemoryErrorCallback(OOMErrorCallback oom_error_callback);
-
-  /**
-   * Get statistics about the shared memory usage.
-   */
-  static void GetSharedMemoryStatistics(SharedMemoryStatistics* statistics);
-
- private:
-  V8();
-
-  enum BuildConfigurationFeatures {
-    kPointerCompression = 1 << 0,
-    k31BitSmis = 1 << 1,
-    kSandboxedExternalPointers = 1 << 2,
-    kSandbox = 1 << 3,
-  };
-
-  /**
-   * Checks that the embedder build configuration is compatible with
-   * the V8 binary and if so initializes V8.
-   */
-  static bool Initialize(int build_config);
-
-  friend class Context;
-  template <class K, class V, class T>
-  friend class PersistentValueMapBase;
-};
-
-}  // namespace v8
-
-#endif  // INCLUDE_V8_INITIALIZATION_H_

package/src-native/pods/Headers/include/v8-inspector-protocol.h

@@ -1,13 +0,0 @@
-// 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_V8_INSPECTOR_PROTOCOL_H_
-#define V8_V8_INSPECTOR_PROTOCOL_H_
-
-#include "inspector/Debugger.h"  // NOLINT(build/include_directory)
-#include "inspector/Runtime.h"   // NOLINT(build/include_directory)
-#include "inspector/Schema.h"    // NOLINT(build/include_directory)
-#include "v8-inspector.h"        // NOLINT(build/include_directory)
-
-#endif  // V8_V8_INSPECTOR_PROTOCOL_H_

package/src-native/pods/Headers/include/v8-inspector.h

@@ -1,376 +0,0 @@
-// 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_V8_INSPECTOR_H_
-#define V8_V8_INSPECTOR_H_
-
-#include <stdint.h>
-
-#include <cctype>
-#include <memory>
-
-#include "v8-isolate.h"       // NOLINT(build/include_directory)
-#include "v8-local-handle.h"  // NOLINT(build/include_directory)
-
-namespace v8 {
-class Context;
-class Name;
-class Object;
-class StackTrace;
-class Value;
-}  // namespace v8
-
-namespace v8_inspector {
-
-namespace internal {
-class V8DebuggerId;
-}  // namespace internal
-
-namespace protocol {
-namespace Debugger {
-namespace API {
-class SearchMatch;
-}
-}
-namespace Runtime {
-namespace API {
-class RemoteObject;
-class StackTrace;
-class StackTraceId;
-}
-}
-namespace Schema {
-namespace API {
-class Domain;
-}
-}
-}  // namespace protocol
-
-class V8_EXPORT StringView {
- public:
-  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
-
-  StringView(const uint8_t* characters, size_t length)
-      : m_is8Bit(true), m_length(length), m_characters8(characters) {}
-
-  StringView(const uint16_t* characters, size_t length)
-      : m_is8Bit(false), m_length(length), m_characters16(characters) {}
-
-  bool is8Bit() const { return m_is8Bit; }
-  size_t length() const { return m_length; }
-
-  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
-  // here.
-  const uint8_t* characters8() const { return m_characters8; }
-  const uint16_t* characters16() const { return m_characters16; }
-
- private:
-  bool m_is8Bit;
-  size_t m_length;
-  union {
-    const uint8_t* m_characters8;
-    const uint16_t* m_characters16;
-  };
-};
-
-class V8_EXPORT StringBuffer {
- public:
-  virtual ~StringBuffer() = default;
-  virtual StringView string() const = 0;
-  // This method copies contents.
-  static std::unique_ptr<StringBuffer> create(StringView);
-};
-
-class V8_EXPORT V8ContextInfo {
- public:
-  V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
-                StringView humanReadableName)
-      : context(context),
-        contextGroupId(contextGroupId),
-        humanReadableName(humanReadableName),
-        hasMemoryOnConsole(false) {}
-
-  v8::Local<v8::Context> context;
-  // Each v8::Context is a part of a group. The group id must be non-zero.
-  int contextGroupId;
-  StringView humanReadableName;
-  StringView origin;
-  StringView auxData;
-  bool hasMemoryOnConsole;
-
-  static int executionContextId(v8::Local<v8::Context> context);
-
-  // Disallow copying and allocating this one.
-  enum NotNullTagEnum { NotNullLiteral };
-  void* operator new(size_t) = delete;
-  void* operator new(size_t, NotNullTagEnum, void*) = delete;
-  void* operator new(size_t, void*) = delete;
-  V8ContextInfo(const V8ContextInfo&) = delete;
-  V8ContextInfo& operator=(const V8ContextInfo&) = delete;
-};
-
-// This debugger id tries to be unique by generating two random
-// numbers, which should most likely avoid collisions.
-// Debugger id has a 1:1 mapping to context group. It is used to
-// attribute stack traces to a particular debugging, when doing any
-// cross-debugger operations (e.g. async step in).
-// See also Runtime.UniqueDebuggerId in the protocol.
-class V8_EXPORT V8DebuggerId {
- public:
-  V8DebuggerId() = default;
-  V8DebuggerId(const V8DebuggerId&) = default;
-  V8DebuggerId& operator=(const V8DebuggerId&) = default;
-
-  std::unique_ptr<StringBuffer> toString() const;
-  bool isValid() const;
-  std::pair<int64_t, int64_t> pair() const;
-
- private:
-  friend class internal::V8DebuggerId;
-  explicit V8DebuggerId(std::pair<int64_t, int64_t>);
-
-  int64_t m_first = 0;
-  int64_t m_second = 0;
-};
-
-class V8_EXPORT V8StackTrace {
- public:
-  virtual StringView firstNonEmptySourceURL() const = 0;
-  virtual bool isEmpty() const = 0;
-  virtual StringView topSourceURL() const = 0;
-  virtual int topLineNumber() const = 0;
-  virtual int topColumnNumber() const = 0;
-  virtual int topScriptId() const = 0;
-  virtual StringView topFunctionName() const = 0;
-
-  virtual ~V8StackTrace() = default;
-  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
-  buildInspectorObject(int maxAsyncDepth) const = 0;
-  virtual std::unique_ptr<StringBuffer> toString() const = 0;
-
-  // Safe to pass between threads, drops async chain.
-  virtual std::unique_ptr<V8StackTrace> clone() = 0;
-};
-
-class V8_EXPORT V8InspectorSession {
- public:
-  virtual ~V8InspectorSession() = default;
-
-  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
-  class V8_EXPORT Inspectable {
-   public:
-    virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
-    virtual ~Inspectable() = default;
-  };
-  class V8_EXPORT CommandLineAPIScope {
-   public:
-    virtual ~CommandLineAPIScope() = default;
-  };
-  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
-
-  // Dispatching protocol messages.
-  static bool canDispatchMethod(StringView method);
-  virtual void dispatchProtocolMessage(StringView message) = 0;
-  virtual std::vector<uint8_t> state() = 0;
-  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
-  supportedDomains() = 0;
-
-  virtual std::unique_ptr<V8InspectorSession::CommandLineAPIScope>
-  initializeCommandLineAPIScope(int executionContextId) = 0;
-
-  // Debugger actions.
-  virtual void schedulePauseOnNextStatement(StringView breakReason,
-                                            StringView breakDetails) = 0;
-  virtual void cancelPauseOnNextStatement() = 0;
-  virtual void breakProgram(StringView breakReason,
-                            StringView breakDetails) = 0;
-  virtual void setSkipAllPauses(bool) = 0;
-  virtual void resume(bool setTerminateOnResume = false) = 0;
-  virtual void stepOver() = 0;
-  virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
-  searchInTextByLines(StringView text, StringView query, bool caseSensitive,
-                      bool isRegex) = 0;
-
-  // Remote objects.
-  virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
-      v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
-      bool generatePreview) = 0;
-
-  virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
-                            StringView objectId, v8::Local<v8::Value>*,
-                            v8::Local<v8::Context>*,
-                            std::unique_ptr<StringBuffer>* objectGroup) = 0;
-  virtual void releaseObjectGroup(StringView) = 0;
-  virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
-};
-
-class V8_EXPORT WebDriverValue {
- public:
-  explicit WebDriverValue(StringView type, v8::MaybeLocal<v8::Value> value = {})
-      : type(type), value(value) {}
-
-  StringView type;
-  v8::MaybeLocal<v8::Value> value;
-};
-
-class V8_EXPORT V8InspectorClient {
- public:
-  virtual ~V8InspectorClient() = default;
-
-  virtual void runMessageLoopOnPause(int contextGroupId) {}
-  virtual void quitMessageLoopOnPause() {}
-  virtual void runIfWaitingForDebugger(int contextGroupId) {}
-
-  virtual void muteMetrics(int contextGroupId) {}
-  virtual void unmuteMetrics(int contextGroupId) {}
-
-  virtual void beginUserGesture() {}
-  virtual void endUserGesture() {}
-
-  virtual std::unique_ptr<WebDriverValue> serializeToWebDriverValue(
-      v8::Local<v8::Value> v8_value, int max_depth) {
-    return nullptr;
-  }
-  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
-    return nullptr;
-  }
-  virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
-      v8::Local<v8::Context>, v8::Local<v8::Value>) {
-    return nullptr;
-  }
-  virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
-
-  virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
-      int contextGroupId) {
-    return v8::Local<v8::Context>();
-  }
-  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
-  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
-
-  virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
-                                               v8::Local<v8::Object>) {}
-  virtual void consoleAPIMessage(int contextGroupId,
-                                 v8::Isolate::MessageErrorLevel level,
-                                 const StringView& message,
-                                 const StringView& url, unsigned lineNumber,
-                                 unsigned columnNumber, V8StackTrace*) {}
-  virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
-                                               v8::Local<v8::Context>) {
-    return v8::MaybeLocal<v8::Value>();
-  }
-
-  virtual void consoleTime(const StringView& title) {}
-  virtual void consoleTimeEnd(const StringView& title) {}
-  virtual void consoleTimeStamp(const StringView& title) {}
-  virtual void consoleClear(int contextGroupId) {}
-  virtual double currentTimeMS() { return 0; }
-  typedef void (*TimerCallback)(void*);
-  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
-  virtual void cancelTimer(void* data) {}
-
-  // TODO(dgozman): this was added to support service worker shadow page. We
-  // should not connect at all.
-  virtual bool canExecuteScripts(int contextGroupId) { return true; }
-
-  virtual void maxAsyncCallStackDepthChanged(int depth) {}
-
-  virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
-      const StringView& resourceName) {
-    return nullptr;
-  }
-
-  // The caller would defer to generating a random 64 bit integer if
-  // this method returns 0.
-  virtual int64_t generateUniqueId() { return 0; }
-
-  virtual void dispatchError(v8::Local<v8::Context>, v8::Local<v8::Message>,
-                             v8::Local<v8::Value>) {}
-};
-
-// These stack trace ids are intended to be passed between debuggers and be
-// resolved later. This allows to track cross-debugger calls and step between
-// them if a single client connects to multiple debuggers.
-struct V8_EXPORT V8StackTraceId {
-  uintptr_t id;
-  std::pair<int64_t, int64_t> debugger_id;
-  bool should_pause = false;
-
-  V8StackTraceId();
-  V8StackTraceId(const V8StackTraceId&) = default;
-  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
-  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
-                 bool should_pause);
-  explicit V8StackTraceId(StringView);
-  V8StackTraceId& operator=(const V8StackTraceId&) = default;
-  V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
-  ~V8StackTraceId() = default;
-
-  bool IsInvalid() const;
-  std::unique_ptr<StringBuffer> ToString();
-};
-
-class V8_EXPORT V8Inspector {
- public:
-  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
-  virtual ~V8Inspector() = default;
-
-  // Contexts instrumentation.
-  virtual void contextCreated(const V8ContextInfo&) = 0;
-  virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
-  virtual void resetContextGroup(int contextGroupId) = 0;
-  virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
-  virtual V8DebuggerId uniqueDebuggerId(int contextId) = 0;
-
-  // Various instrumentation.
-  virtual void idleStarted() = 0;
-  virtual void idleFinished() = 0;
-
-  // Async stack traces instrumentation.
-  virtual void asyncTaskScheduled(StringView taskName, void* task,
-                                  bool recurring) = 0;
-  virtual void asyncTaskCanceled(void* task) = 0;
-  virtual void asyncTaskStarted(void* task) = 0;
-  virtual void asyncTaskFinished(void* task) = 0;
-  virtual void allAsyncTasksCanceled() = 0;
-
-  virtual V8StackTraceId storeCurrentStackTrace(StringView description) = 0;
-  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
-  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
-
-  // Exceptions instrumentation.
-  virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
-                                   v8::Local<v8::Value> exception,
-                                   StringView detailedMessage, StringView url,
-                                   unsigned lineNumber, unsigned columnNumber,
-                                   std::unique_ptr<V8StackTrace>,
-                                   int scriptId) = 0;
-  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
-                                StringView message) = 0;
-  virtual bool associateExceptionData(v8::Local<v8::Context>,
-                                      v8::Local<v8::Value> exception,
-                                      v8::Local<v8::Name> key,
-                                      v8::Local<v8::Value> value) = 0;
-
-  // Connection.
-  class V8_EXPORT Channel {
-   public:
-    virtual ~Channel() = default;
-    virtual void sendResponse(int callId,
-                              std::unique_ptr<StringBuffer> message) = 0;
-    virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
-    virtual void flushProtocolNotifications() = 0;
-  };
-  virtual std::unique_ptr<V8InspectorSession> connect(int contextGroupId,
-                                                      Channel*,
-                                                      StringView state) = 0;
-
-  // API methods.
-  virtual std::unique_ptr<V8StackTrace> createStackTrace(
-      v8::Local<v8::StackTrace>) = 0;
-  virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
-};
-
-}  // namespace v8_inspector
-
-#endif  // V8_V8_INSPECTOR_H_