libv8-node 18.13.0.0-x86_64-linux-musl → 19.9.0.0-x86_64-linux-musl

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

@@ -100,9 +100,6 @@ class V8_EXPORT V8 {
     const int kBuildConfiguration =
         (internal::PointerCompressionIsEnabled() ? kPointerCompression : 0) |
         (internal::SmiValuesAre31Bits() ? k31BitSmis : 0) |
-        (internal::SandboxedExternalPointersAreEnabled()
-             ? kSandboxedExternalPointers
-             : 0) |
         (internal::SandboxIsEnabled() ? kSandbox : 0);
     return Initialize(kBuildConfiguration);
   }
@@ -184,30 +181,19 @@ class V8_EXPORT V8 {
    * 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.
-  //
 
+#if defined(V8_ENABLE_SANDBOX)
   /**
-   * 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.
+   * Returns true if the sandbox is configured securely.
    *
-   * 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.
+   * If V8 cannot create a regular sandbox during initialization, for example
+   * because not enough virtual address space can be reserved, it will instead
+   * create a fallback sandbox that still allows it to function normally but
+   * does not have the same security properties as a regular sandbox. This API
+   * can be used to determine if such a fallback sandbox is being used, in
+   * which case it will return false.
    */
-  static bool InitializeSandbox();
-  V8_DEPRECATE_SOON("Use InitializeSandbox()")
-  static bool InitializeVirtualMemoryCage() { return InitializeSandbox(); }
+  static bool IsSandboxConfiguredSecurely();
 
   /**
    * Provides access to the virtual address subspace backing the sandbox.
@@ -220,39 +206,29 @@ class V8_EXPORT V8 {
    * 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.
+   * This represents the size of the address space that V8 can directly address
+   * and in which it allocates its objects.
    */
   static size_t GetSandboxSizeInBytes();
-  V8_DEPRECATE_SOON("Use GetSandboxSizeInBytes()")
-  static size_t GetVirtualMemoryCageSizeInBytes() {
-    return GetSandboxSizeInBytes();
-  }
 
   /**
-   * Returns whether the sandbox is configured securely.
+   * Returns the size of the address space reservation backing the sandbox.
    *
-   * 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.
+   * This may be larger than the sandbox (i.e. |GetSandboxSizeInBytes()|) due
+   * to surrounding guard regions, or may be smaller than the sandbox in case a
+   * fallback sandbox is being used, which will use a smaller virtual address
+   * space reservation. In the latter case this will also be different from
+   * |GetSandboxAddressSpace()->size()| as that will cover a larger part of the
+   * address space than what has actually been reserved.
    */
-  static bool IsSandboxConfiguredSecurely();
-  V8_DEPRECATE_SOON("Use IsSandboxConfiguredSecurely()")
-  static bool IsUsingSecureVirtualMemoryCage() {
-    return IsSandboxConfiguredSecurely();
-  }
-#endif
+  static size_t GetSandboxReservationSizeInBytes();
+#endif  // V8_ENABLE_SANDBOX
 
   /**
    * Activate trap-based bounds checking for WebAssembly.
@@ -273,7 +249,7 @@ class V8_EXPORT V8 {
    * exceptions in V8-generated code.
    */
   static void SetUnhandledExceptionCallback(
-      UnhandledExceptionCallback unhandled_exception_callback);
+      UnhandledExceptionCallback callback);
 #endif
 
   /**
@@ -281,8 +257,7 @@ class V8_EXPORT V8 {
    * v8 has encountered a fatal failure to allocate memory and is about to
    * terminate.
    */
-
-  static void SetFatalMemoryErrorCallback(OOMErrorCallback oom_error_callback);
+  static void SetFatalMemoryErrorCallback(OOMErrorCallback callback);
 
   /**
    * Get statistics about the shared memory usage.
@@ -295,8 +270,7 @@ class V8_EXPORT V8 {
   enum BuildConfigurationFeatures {
     kPointerCompression = 1 << 0,
     k31BitSmis = 1 << 1,
-    kSandboxedExternalPointers = 1 << 2,
-    kSandbox = 1 << 3,
+    kSandbox = 1 << 2,
   };
 
   /**

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

@@ -207,10 +207,10 @@ class V8_EXPORT V8InspectorSession {
 
 class V8_EXPORT WebDriverValue {
  public:
-  explicit WebDriverValue(StringView type, v8::MaybeLocal<v8::Value> value = {})
-      : type(type), value(value) {}
-
-  StringView type;
+  explicit WebDriverValue(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;
 };
 
@@ -219,6 +219,9 @@ class V8_EXPORT V8InspectorClient {
   virtual ~V8InspectorClient() = default;
 
   virtual void runMessageLoopOnPause(int contextGroupId) {}
+  virtual void runMessageLoopOnInstrumentationPause(int contextGroupId) {
+    runMessageLoopOnPause(contextGroupId);
+  }
   virtual void quitMessageLoopOnPause() {}
   virtual void runIfWaitingForDebugger(int contextGroupId) {}
 
@@ -361,9 +364,12 @@ class V8_EXPORT V8Inspector {
     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;
+  enum ClientTrustLevel { kUntrusted, kFullyTrusted };
+  virtual std::unique_ptr<V8InspectorSession> connect(
+      int contextGroupId, Channel*, StringView state,
+      ClientTrustLevel client_trust_level) {
+    return nullptr;
+  }
 
   // API methods.
   virtual std::unique_ptr<V8StackTrace> createStackTrace(