libv8-node 20.12.1.0-aarch64-linux → 22.5.1.0-aarch64-linux

data/vendor/v8/include/v8-handle-base.h

@@ -0,0 +1,137 @@
+// Copyright 2023 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_HANDLE_BASE_H_
+#define INCLUDE_V8_HANDLE_BASE_H_
+
+#include "v8-internal.h"  // NOLINT(build/include_directory)
+
+namespace v8::api_internal {
+
+template <bool check_statically_enabled>
+class StackAllocated {
+ public:
+  V8_INLINE StackAllocated() = default;
+
+ protected:
+  struct no_checking_tag {};
+  static constexpr no_checking_tag do_not_check{};
+
+  V8_INLINE explicit StackAllocated(no_checking_tag) {}
+  V8_INLINE explicit StackAllocated(const StackAllocated& other,
+                                    no_checking_tag) {}
+
+  V8_INLINE void VerifyOnStack() const {}
+};
+
+template <>
+class V8_TRIVIAL_ABI StackAllocated<true> : public StackAllocated<false> {
+ public:
+  V8_INLINE StackAllocated() { VerifyOnStack(); }
+
+#if V8_HAS_ATTRIBUTE_TRIVIAL_ABI
+  // In this case, StackAllocated becomes not trivially copyable.
+  V8_INLINE StackAllocated(const StackAllocated& other) { VerifyOnStack(); }
+  StackAllocated& operator=(const StackAllocated&) = default;
+#endif
+
+ protected:
+  V8_INLINE explicit StackAllocated(no_checking_tag tag)
+      : StackAllocated<false>(tag) {}
+  V8_INLINE explicit StackAllocated(const StackAllocated& other,
+                                    no_checking_tag tag)
+      : StackAllocated<false>(other, tag) {}
+
+  V8_EXPORT void VerifyOnStack() const;
+};
+
+/**
+ * A base class for abstract handles containing indirect pointers.
+ * These are useful regardless of whether direct local support is enabled.
+ */
+class IndirectHandleBase {
+ public:
+  // Returns true if the handle is empty.
+  V8_INLINE bool IsEmpty() const { return location_ == nullptr; }
+
+  // Sets the handle to be empty. IsEmpty() will then return true.
+  V8_INLINE void Clear() { location_ = nullptr; }
+
+ protected:
+  friend class internal::ValueHelper;
+  friend class internal::HandleHelper;
+
+  V8_INLINE IndirectHandleBase() = default;
+  V8_INLINE IndirectHandleBase(const IndirectHandleBase& other) = default;
+  V8_INLINE IndirectHandleBase& operator=(const IndirectHandleBase& that) =
+      default;
+
+  V8_INLINE explicit IndirectHandleBase(internal::Address* location)
+      : location_(location) {}
+
+  // Returns the address of the actual heap object (tagged).
+  // This method must be called only if the handle is not empty, otherwise it
+  // will crash.
+  V8_INLINE internal::Address ptr() const { return *location_; }
+
+  // Returns a reference to the slot (indirect pointer).
+  V8_INLINE internal::Address* const& slot() const { return location_; }
+  V8_INLINE internal::Address*& slot() { return location_; }
+
+  // Returns the handler's "value" (direct or indirect pointer, depending on
+  // whether direct local support is enabled).
+  template <typename T, bool check_null = false>
+  V8_INLINE T* value() const {
+    return internal::ValueHelper::SlotAsValue<T, check_null>(slot());
+  }
+
+ private:
+  internal::Address* location_ = nullptr;
+};
+
+#ifdef V8_ENABLE_DIRECT_LOCAL
+
+/**
+ * A base class for abstract handles containing direct pointers.
+ * These are only possible when conservative stack scanning is enabled.
+ */
+class DirectHandleBase {
+ public:
+  // Returns true if the handle is empty.
+  V8_INLINE bool IsEmpty() const {
+    return ptr_ == internal::ValueHelper::kEmpty;
+  }
+
+  // Sets the handle to be empty. IsEmpty() will then return true.
+  V8_INLINE void Clear() { ptr_ = internal::ValueHelper::kEmpty; }
+
+ protected:
+  friend class internal::ValueHelper;
+  friend class internal::HandleHelper;
+
+  V8_INLINE DirectHandleBase() = default;
+  V8_INLINE DirectHandleBase(const DirectHandleBase& other) = default;
+  V8_INLINE DirectHandleBase& operator=(const DirectHandleBase& that) = default;
+
+  V8_INLINE explicit DirectHandleBase(internal::Address ptr) : ptr_(ptr) {}
+
+  // Returns the address of the referenced object.
+  V8_INLINE internal::Address ptr() const { return ptr_; }
+
+  // Returns the handler's "value" (direct pointer, as direct local support
+  // is guaranteed to be enabled here).
+  template <typename T, bool check_null = false>
+  V8_INLINE T* value() const {
+    return reinterpret_cast<T*>(ptr_);
+  }
+
+ private:
+  internal::Address ptr_ = internal::ValueHelper::kEmpty;
+};
+
+#endif  // V8_ENABLE_DIRECT_LOCAL
+
+}  // namespace v8::api_internal
+
+#endif  // INCLUDE_V8_HANDLE_BASE_H_

data/vendor/v8/include/v8-inspector.h

@@ -172,10 +172,6 @@ class V8_EXPORT V8InspectorSession {
     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.
@@ -185,9 +181,6 @@ class V8_EXPORT V8InspectorSession {
   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;
@@ -213,19 +206,47 @@ class V8_EXPORT V8InspectorSession {
   virtual void releaseObjectGroup(StringView) = 0;
   virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
 
+  struct V8_EXPORT EvaluateResult {
+    enum class ResultType {
+      kNotRun,
+      kSuccess,
+      kException,
+    };
+
+    ResultType type;
+    v8::Local<v8::Value> value;
+  };
+  // Evalaute 'expression' in the provided context. Does the same as
+  // Runtime#evaluate under-the-hood but exposed on the C++ side.
+  virtual EvaluateResult evaluate(v8::Local<v8::Context> context,
+                                  StringView expression,
+                                  bool includeCommandLineAPI = false) = 0;
+
   // Prepare for shutdown (disables debugger pausing, etc.).
   virtual void stop() = 0;
 };
 
-class V8_EXPORT WebDriverValue {
- public:
-  explicit WebDriverValue(std::unique_ptr<StringBuffer> type,
-                          v8::MaybeLocal<v8::Value> value = {})
+struct V8_EXPORT DeepSerializedValue {
+  explicit DeepSerializedValue(std::unique_ptr<StringBuffer> type,
+                               v8::MaybeLocal<v8::Value> value = {})
       : type(std::move(type)), value(value) {}
   std::unique_ptr<StringBuffer> type;
   v8::MaybeLocal<v8::Value> value;
 };
 
+struct V8_EXPORT DeepSerializationResult {
+  explicit DeepSerializationResult(
+      std::unique_ptr<DeepSerializedValue> serializedValue)
+      : serializedValue(std::move(serializedValue)), isSuccess(true) {}
+  explicit DeepSerializationResult(std::unique_ptr<StringBuffer> errorMessage)
+      : errorMessage(std::move(errorMessage)), isSuccess(false) {}
+
+  // Use std::variant when available.
+  std::unique_ptr<DeepSerializedValue> serializedValue;
+  std::unique_ptr<StringBuffer> errorMessage;
+  bool isSuccess;
+};
+
 class V8_EXPORT V8InspectorClient {
  public:
   virtual ~V8InspectorClient() = default;
@@ -243,8 +264,9 @@ class V8_EXPORT V8InspectorClient {
   virtual void beginUserGesture() {}
   virtual void endUserGesture() {}
 
-  virtual std::unique_ptr<WebDriverValue> serializeToWebDriverValue(
-      v8::Local<v8::Value> v8_value, int max_depth) {
+  virtual std::unique_ptr<DeepSerializationResult> deepSerialize(
+      v8::Local<v8::Value> v8Value, int maxDepth,
+      v8::Local<v8::Object> additionalParameters) {
     return nullptr;
   }
   virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {