node/src/node_blob.h at shared_handle · isker/node · GitHub

History

137 lines (105 loc) · 3.53 KB

Raw

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_

node/src/node_blob.h at shared_handle · isker/node · GitHub

Expand file tree

Breadcrumbs

node_blob.h

Latest commit

History

Breadcrumbs

node_blob.h

File metadata and controls