@encharm/cws 4.1.0 → 4.2.0

package/src/headers/{13 → 18}/node_file-inl.h

@@ -28,7 +28,7 @@ void FSContinuationData::MaybeSetFirstPath(const std::string& path) {
 }
 
 std::string FSContinuationData::PopPath() {
-  CHECK_GT(paths_.size(), 0);
+  CHECK(!paths_.empty());
   std::string path = std::move(paths_.back());
   paths_.pop_back();
   return path;
@@ -39,11 +39,13 @@ void FSContinuationData::Done(int result) {
   done_cb_(req_);
 }
 
-FSReqBase::FSReqBase(Environment* env,
-          v8::Local<v8::Object> req,
-          AsyncWrap::ProviderType type,
-          bool use_bigint)
-  : ReqWrap(env, req, type), use_bigint_(use_bigint) {
+FSReqBase::FSReqBase(BindingData* binding_data,
+                     v8::Local<v8::Object> req,
+                     AsyncWrap::ProviderType type,
+                     bool use_bigint)
+  : ReqWrap(binding_data->env(), req, type),
+    use_bigint_(use_bigint),
+    binding_data_(binding_data) {
 }
 
 void FSReqBase::Init(const char* syscall,
@@ -72,9 +74,13 @@ FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
   return buffer_;
 }
 
-FSReqCallback::FSReqCallback(Environment* env,
-                             v8::Local<v8::Object> req, bool use_bigint)
-  : FSReqBase(env, req, AsyncWrap::PROVIDER_FSREQCALLBACK, use_bigint) {}
+FSReqCallback::FSReqCallback(BindingData* binding_data,
+                             v8::Local<v8::Object> req,
+                             bool use_bigint)
+  : FSReqBase(binding_data,
+              req,
+              AsyncWrap::PROVIDER_FSREQCALLBACK,
+              use_bigint) {}
 
 template <typename NativeT, typename V8T>
 void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
@@ -112,18 +118,18 @@ void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
 #undef SET_FIELD_WITH_STAT
 }
 
-v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
+v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
                                           const bool use_bigint,
                                           const uv_stat_t* s,
                                           const bool second) {
   const ptrdiff_t offset =
       second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
   if (use_bigint) {
-    auto* const arr = env->fs_stats_field_bigint_array();
+    auto* const arr = &binding_data->stats_field_bigint_array;
     FillStatsArray(arr, s, offset);
     return arr->GetJSArray();
   } else {
-    auto* const arr = env->fs_stats_field_array();
+    auto* const arr = &binding_data->stats_field_array;
     FillStatsArray(arr, s, offset);
     return arr->GetJSArray();
   }
@@ -131,7 +137,9 @@ v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>*
-FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
+FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
+                                  bool use_bigint) {
+  Environment* env = binding_data->env();
   v8::Local<v8::Object> obj;
   if (!env->fsreqpromise_constructor_template()
            ->NewInstance(env->context())
@@ -143,7 +151,7 @@ FSReqPromise<AliasedBufferT>::New(Environment* env, bool use_bigint) {
       obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
     return nullptr;
   }
-  return new FSReqPromise(env, obj, use_bigint);
+  return new FSReqPromise(binding_data, obj, use_bigint);
 }
 
 template <typename AliasedBufferT>
@@ -154,12 +162,15 @@ FSReqPromise<AliasedBufferT>::~FSReqPromise() {
 
 template <typename AliasedBufferT>
 FSReqPromise<AliasedBufferT>::FSReqPromise(
-    Environment* env,
+    BindingData* binding_data,
     v8::Local<v8::Object> obj,
     bool use_bigint)
-  : FSReqBase(env, obj, AsyncWrap::PROVIDER_FSREQPROMISE, use_bigint),
+  : FSReqBase(binding_data,
+              obj,
+              AsyncWrap::PROVIDER_FSREQPROMISE,
+              use_bigint),
     stats_field_array_(
-        env->isolate(),
+        env()->isolate(),
         static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
 
 template <typename AliasedBufferT>
@@ -208,15 +219,21 @@ void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackField("stats_field_array", stats_field_array_);
 }
 
-FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
+FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
+                      int index,
                       bool use_bigint) {
+  v8::Local<v8::Value> value = args[index];
   if (value->IsObject()) {
     return Unwrap<FSReqBase>(value.As<v8::Object>());
-  } else if (value->StrictEquals(env->fs_use_promises_symbol())) {
+  }
+
+  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
+  Environment* env = binding_data->env();
+  if (value->StrictEquals(env->fs_use_promises_symbol())) {
     if (use_bigint) {
-      return FSReqPromise<AliasedBigUint64Array>::New(env, use_bigint);
+      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
     } else {
-      return FSReqPromise<AliasedFloat64Array>::New(env, use_bigint);
+      return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
     }
   }
   return nullptr;

package/src/headers/{12 → 18}/node_file.h

@@ -3,14 +3,36 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "node.h"
 #include "aliased_buffer.h"
+#include "node_messaging.h"
+#include "node_snapshotable.h"
 #include "stream_base.h"
-#include <iostream>
 
 namespace node {
 namespace fs {
 
+class FileHandleReadWrap;
+
+class BindingData : public SnapshotableObject {
+ public:
+  explicit BindingData(Environment* env, v8::Local<v8::Object> wrap);
+
+  AliasedFloat64Array stats_field_array;
+  AliasedBigUint64Array stats_field_bigint_array;
+
+  std::vector<BaseObjectPtr<FileHandleReadWrap>>
+      file_handle_read_wrap_freelist;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  static constexpr FastStringKey type_name{"node::fs::BindingData"};
+  static constexpr EmbedderObjectType type_int =
+      EmbedderObjectType::k_fs_binding_data;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+};
+
 // structure used to store state during a complex operation, e.g., mkdirp.
 class FSContinuationData : public MemoryRetainer {
  public:
@@ -43,7 +65,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
  public:
   typedef MaybeStackBuffer<char, 64> FSReqBuffer;
 
-  inline FSReqBase(Environment* env,
+  inline FSReqBase(BindingData* binding_data,
                    v8::Local<v8::Object> req,
                    AsyncWrap::ProviderType type,
                    bool use_bigint);
@@ -66,6 +88,9 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
   const char* data() const { return has_data_ ? *buffer_ : nullptr; }
   enum encoding encoding() const { return encoding_; }
   bool use_bigint() const { return use_bigint_; }
+  bool is_plain_open() const { return is_plain_open_; }
+
+  void set_is_plain_open(bool value) { is_plain_open_ = value; }
 
   FSContinuationData* continuation_data() const {
     return continuation_data_.get();
@@ -83,12 +108,17 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
 
   void MemoryInfo(MemoryTracker* tracker) const override;
 
+  BindingData* binding_data();
+
  private:
   std::unique_ptr<FSContinuationData> continuation_data_;
   enum encoding encoding_ = UTF8;
   bool has_data_ = false;
-  const char* syscall_ = nullptr;
   bool use_bigint_ = false;
+  bool is_plain_open_ = false;
+  const char* syscall_ = nullptr;
+
+  BaseObjectPtr<BindingData> binding_data_;
 
   // Typically, the content of buffer_ is something like a file name, so
   // something around 64 bytes should be enough.
@@ -97,7 +127,7 @@ class FSReqBase : public ReqWrap<uv_fs_t> {
 
 class FSReqCallback final : public FSReqBase {
  public:
-  inline FSReqCallback(Environment* env,
+  inline FSReqCallback(BindingData* binding_data,
                        v8::Local<v8::Object> req,
                        bool use_bigint);
 
@@ -118,7 +148,7 @@ void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
                     const uv_stat_t* s,
                     const size_t offset = 0);
 
-inline v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
+inline v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
                                                  const bool use_bigint,
                                                  const uv_stat_t* s,
                                                  const bool second = false);
@@ -126,7 +156,8 @@ inline v8::Local<v8::Value> FillGlobalStatsArray(Environment* env,
 template <typename AliasedBufferT>
 class FSReqPromise final : public FSReqBase {
  public:
-  static inline FSReqPromise* New(Environment* env, bool use_bigint);
+  static inline FSReqPromise* New(BindingData* binding_data,
+                                  bool use_bigint);
   inline ~FSReqPromise() override;
 
   inline void Reject(v8::Local<v8::Value> reject) override;
@@ -145,7 +176,7 @@ class FSReqPromise final : public FSReqBase {
   FSReqPromise& operator=(const FSReqPromise&&) = delete;
 
  private:
-  inline FSReqPromise(Environment* env,
+  inline FSReqPromise(BindingData* binding_data,
                       v8::Local<v8::Object> obj,
                       bool use_bigint);
 
@@ -203,7 +234,13 @@ class FileHandleReadWrap final : public ReqWrap<uv_fs_t> {
 // the object is garbage collected
 class FileHandle final : public AsyncWrap, public StreamBase {
  public:
-  static FileHandle* New(Environment* env,
+  enum InternalFields {
+    kFileHandleBaseField = StreamBase::kInternalFieldCount,
+    kClosingPromiseSlot,
+    kInternalFieldCount
+  };
+
+  static FileHandle* New(BindingData* binding_data,
                          int fd,
                          v8::Local<v8::Object> obj = v8::Local<v8::Object>());
   ~FileHandle() override;
@@ -246,8 +283,29 @@ class FileHandle final : public AsyncWrap, public StreamBase {
   FileHandle(const FileHandle&&) = delete;
   FileHandle& operator=(const FileHandle&&) = delete;
 
+  TransferMode GetTransferMode() const override;
+  std::unique_ptr<worker::TransferData> TransferForMessaging() override;
+
  private:
-  FileHandle(Environment* env, v8::Local<v8::Object> obj, int fd);
+  class TransferData : public worker::TransferData {
+   public:
+    explicit TransferData(int fd);
+    ~TransferData();
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<worker::TransferData> self) override;
+
+    SET_NO_MEMORY_INFO()
+    SET_MEMORY_INFO_NAME(FileHandleTransferData)
+    SET_SELF_SIZE(TransferData)
+
+   private:
+    int fd_;
+  };
+
+  FileHandle(BindingData* binding_data, v8::Local<v8::Object> obj, int fd);
 
   // Synchronous close that emits a warning
   void Close();
@@ -292,11 +350,13 @@ class FileHandle final : public AsyncWrap, public StreamBase {
   int fd_;
   bool closing_ = false;
   bool closed_ = false;
+  bool reading_ = false;
   int64_t read_offset_ = -1;
   int64_t read_length_ = -1;
 
-  bool reading_ = false;
-  std::unique_ptr<FileHandleReadWrap> current_read_ = nullptr;
+  BaseObjectPtr<FileHandleReadWrap> current_read_;
+
+  BaseObjectPtr<BindingData> binding_data_;
 };
 
 int MKDirpSync(uv_loop_t* loop,
@@ -328,7 +388,8 @@ class FSReqWrapSync {
 // TODO(addaleax): Currently, callers check the return value and assume
 // that nullptr indicates a synchronous call, rather than a failure.
 // Failure conditions should be disambiguated and handled appropriately.
-inline FSReqBase* GetReqWrap(Environment* env, v8::Local<v8::Value> value,
+inline FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
+                             int index,
                              bool use_bigint = false);
 
 // Returns nullptr if the operation fails from the start.