@nativescript/canvas 2.0.0-alpha.10 → 2.0.0-alpha.11

package/pods/Headers/include/v8-snapshot.h

@@ -1,196 +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_SNAPSHOT_H_
-#define INCLUDE_V8_SNAPSHOT_H_
-
-#include "v8-internal.h"      // NOLINT(build/include_directory)
-#include "v8-local-handle.h"  // NOLINT(build/include_directory)
-#include "v8config.h"         // NOLINT(build/include_directory)
-
-namespace v8 {
-
-class Object;
-
-class V8_EXPORT StartupData {
- public:
-  /**
-   * Whether the data created can be rehashed and and the hash seed can be
-   * recomputed when deserialized.
-   * Only valid for StartupData returned by SnapshotCreator::CreateBlob().
-   */
-  bool CanBeRehashed() const;
-  /**
-   * Allows embedders to verify whether the data is valid for the current
-   * V8 instance.
-   */
-  bool IsValid() const;
-
-  const char* data;
-  int raw_size;
-};
-
-/**
- * Callback and supporting data used in SnapshotCreator to implement embedder
- * logic to serialize internal fields.
- * Internal fields that directly reference V8 objects are serialized without
- * calling this callback. Internal fields that contain aligned pointers are
- * serialized by this callback if it returns non-zero result. Otherwise it is
- * serialized verbatim.
- */
-struct SerializeInternalFieldsCallback {
-  using CallbackFunction = StartupData (*)(Local<Object> holder, int index,
-                                           void* data);
-  SerializeInternalFieldsCallback(CallbackFunction function = nullptr,
-                                  void* data_arg = nullptr)
-      : callback(function), data(data_arg) {}
-  CallbackFunction callback;
-  void* data;
-};
-// Note that these fields are called "internal fields" in the API and called
-// "embedder fields" within V8.
-using SerializeEmbedderFieldsCallback = SerializeInternalFieldsCallback;
-
-/**
- * Callback and supporting data used to implement embedder logic to deserialize
- * internal fields.
- */
-struct DeserializeInternalFieldsCallback {
-  using CallbackFunction = void (*)(Local<Object> holder, int index,
-                                    StartupData payload, void* data);
-  DeserializeInternalFieldsCallback(CallbackFunction function = nullptr,
-                                    void* data_arg = nullptr)
-      : callback(function), data(data_arg) {}
-  void (*callback)(Local<Object> holder, int index, StartupData payload,
-                   void* data);
-  void* data;
-};
-
-using DeserializeEmbedderFieldsCallback = DeserializeInternalFieldsCallback;
-
-/**
- * Helper class to create a snapshot data blob.
- *
- * The Isolate used by a SnapshotCreator is owned by it, and will be entered
- * and exited by the constructor and destructor, respectively; The destructor
- * will also destroy the Isolate. Experimental language features, including
- * those available by default, are not available while creating a snapshot.
- */
-class V8_EXPORT SnapshotCreator {
- public:
-  enum class FunctionCodeHandling { kClear, kKeep };
-
-  /**
-   * Initialize and enter an isolate, and set it up for serialization.
-   * The isolate is either created from scratch or from an existing snapshot.
-   * The caller keeps ownership of the argument snapshot.
-   * \param existing_blob existing snapshot from which to create this one.
-   * \param external_references a null-terminated array of external references
-   *        that must be equivalent to CreateParams::external_references.
-   */
-  SnapshotCreator(Isolate* isolate,
-                  const intptr_t* external_references = nullptr,
-                  StartupData* existing_blob = nullptr);
-
-  /**
-   * Create and enter an isolate, and set it up for serialization.
-   * The isolate is either created from scratch or from an existing snapshot.
-   * The caller keeps ownership of the argument snapshot.
-   * \param existing_blob existing snapshot from which to create this one.
-   * \param external_references a null-terminated array of external references
-   *        that must be equivalent to CreateParams::external_references.
-   */
-  SnapshotCreator(const intptr_t* external_references = nullptr,
-                  StartupData* existing_blob = nullptr);
-
-  /**
-   * Destroy the snapshot creator, and exit and dispose of the Isolate
-   * associated with it.
-   */
-  ~SnapshotCreator();
-
-  /**
-   * \returns the isolate prepared by the snapshot creator.
-   */
-  Isolate* GetIsolate();
-
-  /**
-   * Set the default context to be included in the snapshot blob.
-   * The snapshot will not contain the global proxy, and we expect one or a
-   * global object template to create one, to be provided upon deserialization.
-   *
-   * \param callback optional callback to serialize internal fields.
-   */
-  void SetDefaultContext(Local<Context> context,
-                         SerializeInternalFieldsCallback callback =
-                             SerializeInternalFieldsCallback());
-
-  /**
-   * Add additional context to be included in the snapshot blob.
-   * The snapshot will include the global proxy.
-   *
-   * \param callback optional callback to serialize internal fields.
-   *
-   * \returns the index of the context in the snapshot blob.
-   */
-  size_t AddContext(Local<Context> context,
-                    SerializeInternalFieldsCallback callback =
-                        SerializeInternalFieldsCallback());
-
-  /**
-   * Attach arbitrary V8::Data to the context snapshot, which can be retrieved
-   * via Context::GetDataFromSnapshotOnce after deserialization. This data does
-   * not survive when a new snapshot is created from an existing snapshot.
-   * \returns the index for retrieval.
-   */
-  template <class T>
-  V8_INLINE size_t AddData(Local<Context> context, Local<T> object);
-
-  /**
-   * Attach arbitrary V8::Data to the isolate snapshot, which can be retrieved
-   * via Isolate::GetDataFromSnapshotOnce after deserialization. This data does
-   * not survive when a new snapshot is created from an existing snapshot.
-   * \returns the index for retrieval.
-   */
-  template <class T>
-  V8_INLINE size_t AddData(Local<T> object);
-
-  /**
-   * Created a snapshot data blob.
-   * This must not be called from within a handle scope.
-   * \param function_code_handling whether to include compiled function code
-   *        in the snapshot.
-   * \returns { nullptr, 0 } on failure, and a startup snapshot on success. The
-   *        caller acquires ownership of the data array in the return value.
-   */
-  StartupData CreateBlob(FunctionCodeHandling function_code_handling);
-
-  // Disallow copying and assigning.
-  SnapshotCreator(const SnapshotCreator&) = delete;
-  void operator=(const SnapshotCreator&) = delete;
-
- private:
-  size_t AddData(Local<Context> context, internal::Address object);
-  size_t AddData(internal::Address object);
-
-  void* data_;
-};
-
-template <class T>
-size_t SnapshotCreator::AddData(Local<Context> context, Local<T> object) {
-  T* object_ptr = *object;
-  internal::Address* p = reinterpret_cast<internal::Address*>(object_ptr);
-  return AddData(context, *p);
-}
-
-template <class T>
-size_t SnapshotCreator::AddData(Local<T> object) {
-  T* object_ptr = *object;
-  internal::Address* p = reinterpret_cast<internal::Address*>(object_ptr);
-  return AddData(*p);
-}
-
-}  // namespace v8
-
-#endif  // INCLUDE_V8_SNAPSHOT_H_

package/pods/Headers/include/v8-statistics.h

@@ -1,217 +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_STATISTICS_H_
-#define INCLUDE_V8_STATISTICS_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "v8-local-handle.h"  // NOLINT(build/include_directory)
-#include "v8-promise.h"       // NOLINT(build/include_directory)
-#include "v8config.h"         // NOLINT(build/include_directory)
-
-namespace v8 {
-
-class Context;
-class Isolate;
-
-namespace internal {
-class ReadOnlyHeap;
-}  // namespace internal
-
-/**
- * Controls how the default MeasureMemoryDelegate reports the result of
- * the memory measurement to JS. With kSummary only the total size is reported.
- * With kDetailed the result includes the size of each native context.
- */
-enum class MeasureMemoryMode { kSummary, kDetailed };
-
-/**
- * Controls how promptly a memory measurement request is executed.
- * By default the measurement is folded with the next scheduled GC which may
- * happen after a while and is forced after some timeout.
- * The kEager mode starts incremental GC right away and is useful for testing.
- * The kLazy mode does not force GC.
- */
-enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
-
-/**
- * The delegate is used in Isolate::MeasureMemory API.
- *
- * It specifies the contexts that need to be measured and gets called when
- * the measurement is completed to report the results.
- */
-class V8_EXPORT MeasureMemoryDelegate {
- public:
-  virtual ~MeasureMemoryDelegate() = default;
-
-  /**
-   * Returns true if the size of the given context needs to be measured.
-   */
-  virtual bool ShouldMeasure(Local<Context> context) = 0;
-
-  /**
-   * This function is called when memory measurement finishes.
-   *
-   * \param context_sizes_in_bytes a vector of (context, size) pairs that
-   *   includes each context for which ShouldMeasure returned true and that
-   *   was not garbage collected while the memory measurement was in progress.
-   *
-   * \param unattributed_size_in_bytes total size of objects that were not
-   *   attributed to any context (i.e. are likely shared objects).
-   */
-  virtual void MeasurementComplete(
-      const std::vector<std::pair<Local<Context>, size_t>>&
-          context_sizes_in_bytes,
-      size_t unattributed_size_in_bytes) = 0;
-
-  /**
-   * Returns a default delegate that resolves the given promise when
-   * the memory measurement completes.
-   *
-   * \param isolate the current isolate
-   * \param context the current context
-   * \param promise_resolver the promise resolver that is given the
-   *   result of the memory measurement.
-   * \param mode the detail level of the result.
-   */
-  static std::unique_ptr<MeasureMemoryDelegate> Default(
-      Isolate* isolate, Local<Context> context,
-      Local<Promise::Resolver> promise_resolver, MeasureMemoryMode mode);
-};
-
-/**
- * Collection of shared per-process V8 memory information.
- *
- * Instances of this class can be passed to
- * v8::V8::GetSharedMemoryStatistics to get shared memory statistics from V8.
- */
-class V8_EXPORT SharedMemoryStatistics {
- public:
-  SharedMemoryStatistics();
-  size_t read_only_space_size() { return read_only_space_size_; }
-  size_t read_only_space_used_size() { return read_only_space_used_size_; }
-  size_t read_only_space_physical_size() {
-    return read_only_space_physical_size_;
-  }
-
- private:
-  size_t read_only_space_size_;
-  size_t read_only_space_used_size_;
-  size_t read_only_space_physical_size_;
-
-  friend class V8;
-  friend class internal::ReadOnlyHeap;
-};
-
-/**
- * Collection of V8 heap information.
- *
- * Instances of this class can be passed to v8::Isolate::GetHeapStatistics to
- * get heap statistics from V8.
- */
-class V8_EXPORT HeapStatistics {
- public:
-  HeapStatistics();
-  size_t total_heap_size() { return total_heap_size_; }
-  size_t total_heap_size_executable() { return total_heap_size_executable_; }
-  size_t total_physical_size() { return total_physical_size_; }
-  size_t total_available_size() { return total_available_size_; }
-  size_t total_global_handles_size() { return total_global_handles_size_; }
-  size_t used_global_handles_size() { return used_global_handles_size_; }
-  size_t used_heap_size() { return used_heap_size_; }
-  size_t heap_size_limit() { return heap_size_limit_; }
-  size_t malloced_memory() { return malloced_memory_; }
-  size_t external_memory() { return external_memory_; }
-  size_t peak_malloced_memory() { return peak_malloced_memory_; }
-  size_t number_of_native_contexts() { return number_of_native_contexts_; }
-  size_t number_of_detached_contexts() { return number_of_detached_contexts_; }
-
-  /**
-   * Returns a 0/1 boolean, which signifies whether the V8 overwrite heap
-   * garbage with a bit pattern.
-   */
-  size_t does_zap_garbage() { return does_zap_garbage_; }
-
- private:
-  size_t total_heap_size_;
-  size_t total_heap_size_executable_;
-  size_t total_physical_size_;
-  size_t total_available_size_;
-  size_t used_heap_size_;
-  size_t heap_size_limit_;
-  size_t malloced_memory_;
-  size_t external_memory_;
-  size_t peak_malloced_memory_;
-  bool does_zap_garbage_;
-  size_t number_of_native_contexts_;
-  size_t number_of_detached_contexts_;
-  size_t total_global_handles_size_;
-  size_t used_global_handles_size_;
-
-  friend class V8;
-  friend class Isolate;
-};
-
-class V8_EXPORT HeapSpaceStatistics {
- public:
-  HeapSpaceStatistics();
-  const char* space_name() { return space_name_; }
-  size_t space_size() { return space_size_; }
-  size_t space_used_size() { return space_used_size_; }
-  size_t space_available_size() { return space_available_size_; }
-  size_t physical_space_size() { return physical_space_size_; }
-
- private:
-  const char* space_name_;
-  size_t space_size_;
-  size_t space_used_size_;
-  size_t space_available_size_;
-  size_t physical_space_size_;
-
-  friend class Isolate;
-};
-
-class V8_EXPORT HeapObjectStatistics {
- public:
-  HeapObjectStatistics();
-  const char* object_type() { return object_type_; }
-  const char* object_sub_type() { return object_sub_type_; }
-  size_t object_count() { return object_count_; }
-  size_t object_size() { return object_size_; }
-
- private:
-  const char* object_type_;
-  const char* object_sub_type_;
-  size_t object_count_;
-  size_t object_size_;
-
-  friend class Isolate;
-};
-
-class V8_EXPORT HeapCodeStatistics {
- public:
-  HeapCodeStatistics();
-  size_t code_and_metadata_size() { return code_and_metadata_size_; }
-  size_t bytecode_and_metadata_size() { return bytecode_and_metadata_size_; }
-  size_t external_script_source_size() { return external_script_source_size_; }
-  size_t cpu_profiler_metadata_size() { return cpu_profiler_metadata_size_; }
-
- private:
-  size_t code_and_metadata_size_;
-  size_t bytecode_and_metadata_size_;
-  size_t external_script_source_size_;
-  size_t cpu_profiler_metadata_size_;
-
-  friend class Isolate;
-};
-
-}  // namespace v8
-
-#endif  // INCLUDE_V8_STATISTICS_H_