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
|
#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_worker.h"
#include "v8.h"
#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(Environment* env, v8::Local<v8::Object> target);
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 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;
};
} // namespace node
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif // SRC_NODE_BLOB_H_
|
