1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
#ifndef SRC_NODE_BLOB_H_
#define SRC_NODE_BLOB_H_
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#include "async_wrap.h"
#include "base_object.h"
#include "env.h"
#include "memory_tracker.h"
#include "node_internals.h"
#include "node_snapshotable.h"
#include "node_worker.h"
#include "v8.h"
#include <string>
#include <unordered_map>
#include <vector>
namespace node {
struct BlobEntry {
std::shared_ptr<v8::BackingStore> store;
size_t length;
size_t offset;
};
class Blob : public BaseObject {
public:
static void RegisterExternalReferences(
ExternalReferenceRegistry* registry);
static void Initialize(
v8::Local<v8::Object> target,
v8::Local<v8::Value> unused,
v8::Local<v8::Context> context,
void* priv);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ToArrayBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ToSlice(const v8::FunctionCallbackInfo<v8::Value>& args);
static void StoreDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
static void GetDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
static void RevokeDataObject(const v8::FunctionCallbackInfo<v8::Value>& args);
static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
Environment* env);
static BaseObjectPtr<Blob> Create(Environment* env,
const std::vector<BlobEntry>& store,
size_t length);
static bool HasInstance(Environment* env, v8::Local<v8::Value> object);
const std::vector<BlobEntry>& entries() const { return store_; }
void MemoryInfo(MemoryTracker* tracker) const override;
SET_MEMORY_INFO_NAME(Blob)
SET_SELF_SIZE(Blob)
// Copies the contents of the Blob into an ArrayBuffer.
v8::MaybeLocal<v8::Value> GetArrayBuffer(Environment* env);
BaseObjectPtr<Blob> Slice(Environment* env, size_t start, size_t end);
inline size_t length() const { return length_; }
class BlobTransferData : public worker::TransferData {
public:
explicit BlobTransferData(
const std::vector<BlobEntry>& store,
size_t length)
: store_(store),
length_(length) {}
BaseObjectPtr<BaseObject> Deserialize(
Environment* env,
v8::Local<v8::Context> context,
std::unique_ptr<worker::TransferData> self) override;
SET_MEMORY_INFO_NAME(BlobTransferData)
SET_SELF_SIZE(BlobTransferData)
SET_NO_MEMORY_INFO()
private:
std::vector<BlobEntry> store_;
size_t length_ = 0;
};
BaseObject::TransferMode GetTransferMode() const override;
std::unique_ptr<worker::TransferData> CloneForMessaging() const override;
Blob(
Environment* env,
v8::Local<v8::Object> obj,
const std::vector<BlobEntry>& store,
size_t length);
private:
std::vector<BlobEntry> store_;
size_t length_ = 0;
};
class FixedSizeBlobCopyJob : public AsyncWrap, public ThreadPoolWork {
public:
enum class Mode {
SYNC,
ASYNC
};
static void RegisterExternalReferences(
ExternalReferenceRegistry* registry);
static void Initialize(Environment* env, v8::Local<v8::Object> target);
static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Run(const v8::FunctionCallbackInfo<v8::Value>& args);
bool IsNotIndicativeOfMemoryLeakAtExit() const override {
return true;
}
void DoThreadPoolWork() override;
void AfterThreadPoolWork(int status) override;
Mode mode() const { return mode_; }
void MemoryInfo(MemoryTracker* tracker) const override;
SET_MEMORY_INFO_NAME(FixedSizeBlobCopyJob)
SET_SELF_SIZE(FixedSizeBlobCopyJob)
private:
FixedSizeBlobCopyJob(
Environment* env,
v8::Local<v8::Object> object,
Blob* blob,
Mode mode = Mode::ASYNC);
Mode mode_;
std::vector<BlobEntry> source_;
std::shared_ptr<v8::BackingStore> destination_;
size_t length_ = 0;
};
class BlobBindingData : public SnapshotableObject {
public:
explicit BlobBindingData(Environment* env, v8::Local<v8::Object> wrap);
using InternalFieldInfo = InternalFieldInfoBase;
SERIALIZABLE_OBJECT_METHODS()
static constexpr FastStringKey type_name{"node::BlobBindingData"};
static constexpr EmbedderObjectType type_int =
EmbedderObjectType::k_blob_binding_data;
void MemoryInfo(MemoryTracker* tracker) const override;
SET_SELF_SIZE(BlobBindingData)
SET_MEMORY_INFO_NAME(BlobBindingData)
struct StoredDataObject : public MemoryRetainer {
BaseObjectPtr<Blob> blob;
size_t length;
std::string type;
StoredDataObject() = default;
StoredDataObject(
const BaseObjectPtr<Blob>& blob_,
size_t length_,
const std::string& type_);
void MemoryInfo(MemoryTracker* tracker) const override;
SET_SELF_SIZE(StoredDataObject)
SET_MEMORY_INFO_NAME(StoredDataObject)
};
void store_data_object(
const std::string& uuid,
const StoredDataObject& object);
void revoke_data_object(const std::string& uuid);
StoredDataObject get_data_object(const std::string& uuid);
private:
std::unordered_map<std::string, StoredDataObject> data_objects_;
};
} // namespace node
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif // SRC_NODE_BLOB_H_
|
