Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsArray());

Local<Array> array = args[0].As<Array>();

struct View {

std::shared_ptr<BackingStore> store;

size_t length;

size_t offset = 0;

};

std::vector<View> views;

size_t total = 0;

for (uint32_t n = 0; n < array->Length(); n++) {

Local<Value> val;

if (!array->Get(env->context(), n).ToLocal(&val)) return;

if (val->IsArrayBuffer()) {

auto ab = val.As<ArrayBuffer>();

views.push_back(View{ab->GetBackingStore(), ab->ByteLength(), 0});

total += ab->ByteLength();

} else {

CHECK(val->IsArrayBufferView());

auto view = val.As<ArrayBufferView>();

views.push_back(View{view->Buffer()->GetBackingStore(),

view->ByteLength(),

view->ByteOffset()});

total += view->ByteLength();

}

}

std::shared_ptr<BackingStore> store =

ArrayBuffer::NewBackingStore(env->isolate(), total);

uint8_t* ptr = static_cast<uint8_t*>(store->Data());

for (size_t n = 0; n < views.size(); n++) {

uint8_t* from =

static_cast<uint8_t*>(views[n].store->Data()) + views[n].offset;

std::copy(from, from + views[n].length, ptr);

ptr += views[n].length;

}

args.GetReturnValue().Set(ArrayBuffer::New(env->isolate(), std::move(store)));

Environment* env = Environment::GetCurrent(args);

BufferValue path(env->isolate(), args[0]);

CHECK_NOT_NULL(*path);

THROW_IF_INSUFFICIENT_PERMISSIONS(

env, permission::PermissionScope::kFileSystemRead, path.ToStringView());

auto entry = DataQueue::CreateFdEntry(env, args[0]);

if (entry == nullptr) {

return THROW_ERR_INVALID_ARG_VALUE(env, "Unabled to open file as blob");

}

std::vector<std::unique_ptr<DataQueue::Entry>> entries;

entries.push_back(std::move(entry));

auto blob =

Blob::Create(env, DataQueue::CreateIdempotent(std::move(entries)));

if (blob) {

auto array = Array::New(env->isolate(), 2);

USE(array->Set(env->context(), 0, blob->object()));

USE(array->Set(env->context(),

1,

Uint32::NewFromUnsigned(env->isolate(), blob->length())));

args.GetReturnValue().Set(array);

}

Local<ObjectTemplate> target) {

Isolate* isolate = isolate_data->isolate();

SetMethod(isolate, target, "createBlob", New);

SetMethod(isolate, target, "storeDataObject", StoreDataObject);

SetMethod(isolate, target, "getDataObject", GetDataObject);

SetMethod(isolate, target, "revokeObjectURL", RevokeObjectURL);

SetMethod(isolate, target, "concat", Concat);

SetMethod(isolate, target, "createBlobFromFilePath", BlobFromFilePath);

Local<Value> unused,

Local<Context> context,

void* priv) {

Realm* realm = Realm::GetCurrent(context);

realm->AddBindingData<BlobBindingData>(target);

Local<FunctionTemplate> tmpl = env->blob_constructor_template();

if (tmpl.IsEmpty()) {

Isolate* isolate = env->isolate();

tmpl = NewFunctionTemplate(isolate, nullptr);

tmpl->InstanceTemplate()->SetInternalFieldCount(

BaseObject::kInternalFieldCount);

tmpl->SetClassName(

FIXED_ONE_BYTE_STRING(env->isolate(), "Blob"));

SetProtoMethod(isolate, tmpl, "getReader", GetReader);

SetProtoMethod(isolate, tmpl, "slice", ToSlice);

env->set_blob_constructor_template(tmpl);

}

return tmpl;

std::shared_ptr<DataQueue> data_queue) {

HandleScope scope(env->isolate());

Local<Function> ctor;

if (!GetConstructorTemplate(env)->GetFunction(env->context()).ToLocal(&ctor))

return BaseObjectPtr<Blob>();

Local<Object> obj;

if (!ctor->NewInstance(env->context()).ToLocal(&obj))

return BaseObjectPtr<Blob>();

return MakeBaseObject<Blob>(env, obj, data_queue);

Environment* env = Environment::GetCurrent(args);

CHECK(args[0]->IsArray()); // sources

Local<Array> array = args[0].As<Array>();

std::vector<std::unique_ptr<DataQueue::Entry>> entries(array->Length());

for (size_t i = 0; i < array->Length(); i++) {

Local<Value> entry;

if (!array->Get(env->context(), i).ToLocal(&entry)) {

return;

}

const auto entryFromArrayBuffer = [env](v8::Local<v8::ArrayBuffer> buf,

size_t byte_length,

size_t byte_offset = 0) {

if (buf->IsDetachable()) {

std::shared_ptr<BackingStore> store = buf->GetBackingStore();

USE(buf->Detach(Local<Value>()));

return DataQueue::CreateInMemoryEntryFromBackingStore(

store, byte_offset, byte_length);

}

// If the ArrayBuffer is not detachable, we will copy from it instead.

std::shared_ptr<BackingStore> store =

ArrayBuffer::NewBackingStore(env->isolate(), byte_length);

uint8_t* ptr = static_cast<uint8_t*>(buf->Data()) + byte_offset;

std::copy(ptr, ptr + byte_length, static_cast<uint8_t*>(store->Data()));

return DataQueue::CreateInMemoryEntryFromBackingStore(

store, 0, byte_length);

};

// Every entry should be either an ArrayBuffer, ArrayBufferView, or Blob.

// If the input to the Blob constructor in JavaScript was a string, then

// it will be decoded into an ArrayBufferView there before being passed

// in.

//

// Importantly, here we also assume that the ArrayBuffer/ArrayBufferView

// is not going to be modified here so we will detach them. It is up to

// the JavaScript side to do the right thing with regards to copying and

// ensuring appropriate spec compliance.

if (entry->IsArrayBuffer()) {

Local<ArrayBuffer> buf = entry.As<ArrayBuffer>();

entries[i] = entryFromArrayBuffer(buf, buf->ByteLength());

} else if (entry->IsArrayBufferView()) {

Local<ArrayBufferView> view = entry.As<ArrayBufferView>();

entries[i] = entryFromArrayBuffer(

view->Buffer(), view->ByteLength(), view->ByteOffset());

} else if (Blob::HasInstance(env, entry)) {

Blob* blob;

ASSIGN_OR_RETURN_UNWRAP(&blob, entry);

entries[i] = DataQueue::CreateDataQueueEntry(blob->data_queue_);

} else {

UNREACHABLE("Incorrect Blob initialization type");

}

}

auto blob = Create(env, DataQueue::CreateIdempotent(std::move(entries)));

if (blob)

args.GetReturnValue().Set(blob->object());

Environment* env = Environment::GetCurrent(args);

Blob* blob;

ASSIGN_OR_RETURN_UNWRAP(&blob, args.Holder());

BaseObjectPtr<Blob::Reader> reader =

Blob::Reader::Create(env, BaseObjectPtr<Blob>(blob));

if (reader) args.GetReturnValue().Set(reader->object());

Environment* env = Environment::GetCurrent(args);

Blob* blob;

ASSIGN_OR_RETURN_UNWRAP(&blob, args.Holder());

CHECK(args[0]->IsUint32());

CHECK(args[1]->IsUint32());

size_t start = args[0].As<Uint32>()->Value();

size_t end = args[1].As<Uint32>()->Value();

BaseObjectPtr<Blob> slice = blob->Slice(env, start, end);

if (slice)

args.GetReturnValue().Set(slice->object());

v8::Local<v8::Object> obj,

std::shared_ptr<DataQueue> data_queue)

: BaseObject(env, obj), data_queue_(data_queue) {

MakeWeak();

BaseObjectPtr<Blob::Reader> reader;

Global<Function> callback;

Environment* env;

Realm* realm = Realm::GetCurrent(args);

CHECK(args[0]->IsString()); // ID key

CHECK(Blob::HasInstance(realm->env(), args[1])); // Blob

CHECK(args[2]->IsUint32()); // Length

CHECK(args[3]->IsString()); // Type

BlobBindingData* binding_data = realm->GetBindingData<BlobBindingData>();

Isolate* isolate = realm->isolate();

Utf8Value key(isolate, args[0]);

Blob* blob;

ASSIGN_OR_RETURN_UNWRAP(&blob, args[1]);

size_t length = args[2].As<Uint32>()->Value();

Utf8Value type(isolate, args[3]);

binding_data->store_data_object(

std::string(*key, key.length()),

BlobBindingData::StoredDataObject(

BaseObjectPtr<Blob>(blob),

length,

std::string(*type, type.length())));

CHECK_GE(args.Length(), 1);

CHECK(args[0]->IsString());

Realm* realm = Realm::GetCurrent(args);

BlobBindingData* binding_data = realm->GetBindingData<BlobBindingData>();

Isolate* isolate = realm->isolate();

Utf8Value input(isolate, args[0].As<String>());

auto out = ada::parse<ada::url_aggregator>(input.ToStringView());

if (!out) {

return;

}

auto pathname = out->get_pathname();

auto start_index = pathname.find(':');

if (start_index != std::string_view::npos && start_index != pathname.size()) {

auto end_index = pathname.find(':', start_index + 1);

if (end_index == std::string_view::npos) {

auto id = std::string(pathname.substr(start_index + 1));

binding_data->revoke_data_object(id);

}

}

CHECK(args[0]->IsString());

Realm* realm = Realm::GetCurrent(args);

BlobBindingData* binding_data = realm->GetBindingData<BlobBindingData>();

Isolate* isolate = realm->isolate();

Utf8Value key(isolate, args[0]);

BlobBindingData::StoredDataObject stored =

binding_data->get_data_object(std::string(*key, key.length()));

if (stored.blob) {

Local<Value> type;

if (!String::NewFromUtf8(isolate,

stored.type.c_str(),

v8::NewStringType::kNormal,

static_cast<int>(stored.type.length()))

.ToLocal(&type)) {

return;

}

Local<Value> values[] = {stored.blob->object(),

Uint32::NewFromUnsigned(isolate, stored.length),

type};

args.GetReturnValue().Set(Array::New(isolate, values, arraysize(values)));

}

tracker->TrackField("data_objects_",

data_objects_,

"std::unordered_map<std::string, StoredDataObject>");

const std::string& uuid,

const BlobBindingData::StoredDataObject& object) {

data_objects_[uuid] = object;

if (data_objects_.find(uuid) == data_objects_.end()) {

return;

}

data_objects_.erase(uuid);

CHECK_EQ(data_objects_.find(uuid), data_objects_.end());

const std::string& uuid) {

auto entry = data_objects_.find(uuid);

if (entry == data_objects_.end())

return BlobBindingData::StoredDataObject {};

return entry->second;

Local<Object> holder,

int index,

InternalFieldInfoBase* info) {

DCHECK_IS_SNAPSHOT_SLOT(index);

HandleScope scope(context->GetIsolate());

Realm* realm = Realm::GetCurrent(context);

BlobBindingData* binding = realm->AddBindingData<BlobBindingData>(holder);

CHECK_NOT_NULL(binding);

v8::SnapshotCreator* creator) {

// Stored blob objects are not actually persisted.

// Return true because we need to maintain the reference to the binding from

// JS land.

return true;

registry->Register(Blob::New);

registry->Register(Blob::GetReader);

registry->Register(Blob::ToSlice);

registry->Register(Blob::StoreDataObject);

registry->Register(Blob::GetDataObject);

registry->Register(Blob::RevokeObjectURL);

registry->Register(Blob::Reader::Pull);

registry->Register(Concat);

registry->Register(BlobFromFilePath);