v8-value-serializer.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_VALUE_SERIALIZER_H_
#define INCLUDE_V8_VALUE_SERIALIZER_H_
 
#include <stddef.h>
#include <stdint.h>
 
#include <memory>
#include <utility>
#include <vector>
 
#include "v8-local-handle.h"  // NOLINT(build/include_directory)
#include "v8-maybe.h"         // NOLINT(build/include_directory)
#include "v8config.h"         // NOLINT(build/include_directory)
 
namespace v8 {
 
class ArrayBuffer;
class BackingStore;
class Isolate;
class Object;
class SharedArrayBuffer;
class String;
class WasmModuleObject;
class Value;
 
namespace internal {
struct ScriptStreamingData;
class SharedObjectConveyorHandles;
class ValueDeserializer;
class ValueSerializer;
}  // namespace internal
 
class V8_EXPORT SharedValueConveyor final {
 public:
  SharedValueConveyor(SharedValueConveyor&&) noexcept;
  ~SharedValueConveyor();
 
  SharedValueConveyor& operator=(SharedValueConveyor&&) noexcept;
 
 private:
  friend class internal::ValueSerializer;
  friend class internal::ValueDeserializer;
 
  explicit SharedValueConveyor(Isolate* isolate);
 
  std::unique_ptr<internal::SharedObjectConveyorHandles> private_;
};
 
class V8_EXPORT ValueSerializer {
 public:
  class V8_EXPORT Delegate {
   public:
    virtual ~Delegate() = default;
 
    virtual void ThrowDataCloneError(Local<String> message) = 0;
 
    virtual bool HasCustomHostObject(Isolate* isolate);
 
    virtual Maybe<bool> IsHostObject(Isolate* isolate, Local<Object> object);
 
    virtual Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object);
 
    virtual Maybe<uint32_t> GetSharedArrayBufferId(
        Isolate* isolate, Local<SharedArrayBuffer> shared_array_buffer);
 
    virtual Maybe<uint32_t> GetWasmModuleTransferId(
        Isolate* isolate, Local<WasmModuleObject> module);
 
    virtual bool AdoptSharedValueConveyor(Isolate* isolate,
                                          SharedValueConveyor&& conveyor);
 
    virtual void* ReallocateBufferMemory(void* old_buffer, size_t size,
                                         size_t* actual_size);
 
    virtual void FreeBufferMemory(void* buffer);
  };
 
  enum class SharedImmutableArrayBufferMode {
    kDisabled,
    kEnabled,
  };
 
  explicit ValueSerializer(
      Isolate* isolate,
      SharedImmutableArrayBufferMode share_immutable_array_buffer =
          SharedImmutableArrayBufferMode::kDisabled);
  ValueSerializer(Isolate* isolate, Delegate* delegate,
                  SharedImmutableArrayBufferMode share_immutable_array_buffer =
                      SharedImmutableArrayBufferMode::kDisabled);
  ~ValueSerializer();
 
  void WriteHeader();
 
  V8_WARN_UNUSED_RESULT Maybe<bool> WriteValue(Local<Context> context,
                                               Local<Value> value);
 
  V8_WARN_UNUSED_RESULT std::pair<uint8_t*, size_t> Release();
 
  void TransferArrayBuffer(uint32_t transfer_id,
                           Local<ArrayBuffer> array_buffer);
 
  void SetTreatArrayBufferViewsAsHostObjects(bool mode);
 
  std::vector<std::shared_ptr<v8::BackingStore>>
  ReleaseSharedImmutableBackingStores();
 
  void WriteUint32(uint32_t value);
  void WriteUint64(uint64_t value);
  void WriteDouble(double value);
  void WriteRawBytes(const void* source, size_t length);
 
  ValueSerializer(const ValueSerializer&) = delete;
  void operator=(const ValueSerializer&) = delete;
 
 private:
  struct PrivateData;
  PrivateData* private_;
};
 
class V8_EXPORT ValueDeserializer {
 public:
  class V8_EXPORT Delegate {
   public:
    virtual ~Delegate() = default;
 
    virtual MaybeLocal<Object> ReadHostObject(Isolate* isolate);
 
    virtual MaybeLocal<WasmModuleObject> GetWasmModuleFromId(
        Isolate* isolate, uint32_t transfer_id);
 
    virtual MaybeLocal<SharedArrayBuffer> GetSharedArrayBufferFromId(
        Isolate* isolate, uint32_t clone_id);
 
    virtual const SharedValueConveyor* GetSharedValueConveyor(Isolate* isolate);
  };
 
  ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size);
  ValueDeserializer(Isolate* isolate, const uint8_t* data, size_t size,
                    Delegate* delegate);
  ~ValueDeserializer();
 
  V8_WARN_UNUSED_RESULT Maybe<bool> ReadHeader(Local<Context> context);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> ReadValue(Local<Context> context);
 
  void TransferArrayBuffer(uint32_t transfer_id,
                           Local<ArrayBuffer> array_buffer);
 
  void TransferSharedArrayBuffer(uint32_t id,
                                 Local<SharedArrayBuffer> shared_array_buffer);
 
  void SetSharedImmutableBackingStores(
      std::vector<std::shared_ptr<v8::BackingStore>> backing_stores);
 
  void SetSupportsLegacyWireFormat(bool supports_legacy_wire_format);
 
  uint32_t GetWireFormatVersion() const;
 
  V8_WARN_UNUSED_RESULT bool ReadUint32(uint32_t* value);
  V8_WARN_UNUSED_RESULT bool ReadUint64(uint64_t* value);
  V8_WARN_UNUSED_RESULT bool ReadDouble(double* value);
  V8_WARN_UNUSED_RESULT bool ReadRawBytes(size_t length, const void** data);
 
  ValueDeserializer(const ValueDeserializer&) = delete;
  void operator=(const ValueDeserializer&) = delete;
 
 private:
  struct PrivateData;
  PrivateData* private_;
};
 
}  // namespace v8
 
#endif  // INCLUDE_V8_VALUE_SERIALIZER_H_