v8-snapshot.h

Go to the documentation of this file.

// 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-isolate.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;
 
namespace internal {
class SnapshotCreatorImpl;
}  // namespace internal
 
class V8_EXPORT StartupData {
 public:
  bool CanBeRehashed() const;
  bool IsValid() const;
 
  const char* data;
  int raw_size;
};
 
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;
};
 
struct SerializeContextDataCallback {
  using CallbackFunction = StartupData (*)(Local<Context> holder, int index,
                                           void* data);
  SerializeContextDataCallback(CallbackFunction function = nullptr,
                               void* data_arg = nullptr)
      : callback(function), data(data_arg) {}
  CallbackFunction callback;
  void* data;
};
 
struct SerializeAPIWrapperCallback {
  using CallbackFunction = StartupData (*)(Local<Object> holder,
                                           void* cpp_heap_pointer, void* data);
  explicit SerializeAPIWrapperCallback(CallbackFunction function = nullptr,
                                       void* data = nullptr)
      : callback(function), data(data) {}
 
  CallbackFunction callback;
  void* data;
};
 
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) {}
 
  CallbackFunction callback;
  void* data;
};
 
struct DeserializeContextDataCallback {
  using CallbackFunction = void (*)(Local<Context> holder, int index,
                                    StartupData payload, void* data);
  DeserializeContextDataCallback(CallbackFunction function = nullptr,
                                 void* data_arg = nullptr)
      : callback(function), data(data_arg) {}
  CallbackFunction callback;
  void* data;
};
 
struct DeserializeAPIWrapperCallback {
  using CallbackFunction = void (*)(Local<Object> holder, StartupData payload,
                                    void* data);
  explicit DeserializeAPIWrapperCallback(CallbackFunction function = nullptr,
                                         void* data = nullptr)
      : callback(function), data(data) {}
 
  CallbackFunction callback;
  void* data;
};
 
class V8_EXPORT SnapshotCreator {
 public:
  enum class FunctionCodeHandling { kClear, kKeep };
 
  V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.")
  explicit SnapshotCreator(Isolate* isolate,
                           const intptr_t* external_references = nullptr,
                           const StartupData* existing_blob = nullptr,
                           bool owns_isolate = true);
 
  V8_DEPRECATE_SOON("Use the version that passes CreateParams instead.")
  explicit SnapshotCreator(const intptr_t* external_references = nullptr,
                           const StartupData* existing_blob = nullptr);
 
  explicit SnapshotCreator(const v8::Isolate::CreateParams& params);
 
  SnapshotCreator(v8::Isolate* isolate,
                  const v8::Isolate::CreateParams& params);
 
  ~SnapshotCreator();
 
  Isolate* GetIsolate();
 
  void SetDefaultContext(
      Local<Context> context,
      SerializeInternalFieldsCallback internal_fields_serializer =
          SerializeInternalFieldsCallback(),
      SerializeContextDataCallback context_data_serializer =
          SerializeContextDataCallback(),
      SerializeAPIWrapperCallback api_wrapper_serializer =
          SerializeAPIWrapperCallback());
 
  size_t AddContext(Local<Context> context,
                    SerializeInternalFieldsCallback internal_fields_serializer =
                        SerializeInternalFieldsCallback(),
                    SerializeContextDataCallback context_data_serializer =
                        SerializeContextDataCallback(),
                    SerializeAPIWrapperCallback api_wrapper_serializer =
                        SerializeAPIWrapperCallback());
 
  template <class T>
  V8_INLINE size_t AddData(Local<Context> context, Local<T> object);
 
  template <class T>
  V8_INLINE size_t AddData(Local<T> object);
 
  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);
 
  internal::SnapshotCreatorImpl* impl_;
  friend class internal::SnapshotCreatorImpl;
};
 
template <class T>
size_t SnapshotCreator::AddData(Local<Context> context, Local<T> object) {
  return AddData(context, internal::ValueHelper::ValueAsAddress(*object));
}
 
template <class T>
size_t SnapshotCreator::AddData(Local<T> object) {
  return AddData(internal::ValueHelper::ValueAsAddress(*object));
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_SNAPSHOT_H_