static
void
DNSSD_API
OnServiceChanged(DNSServiceRef sdRef, DNSServiceFlags flags,
uint32_t interfaceIndex, DNSServiceErrorType errorCode,
const char * serviceName, const char * serviceType,
const char * replyDomain, void * context)
{
NanScope();
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
const size_t argc(8);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Uint32>(interfaceIndex);
args[3] = NanNew<Integer>(errorCode);
args[4] = stringOrUndefined(serviceName);
args[5] = stringOrUndefined(serviceType);
args[6] = stringOrUndefined(replyDomain);
if (serviceRef->GetContext().IsEmpty()) {
args[7] = NanUndefined();
} else {
args[7] = NanNew<Value>(serviceRef->GetContext());
}
NanMakeCallback(this_, callback, argc, args);
}
void
DNSSD_API
OnResolve(DNSServiceRef sdRef, DNSServiceFlags flags,
uint32_t interfaceIndex, DNSServiceErrorType errorCode,
const char * fullname, const char * hosttarget, uint16_t port,
uint16_t txtLen, const unsigned char * txtRecord, void * context)
{
NanScope();
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
const size_t argc(9);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Uint32>(interfaceIndex);
args[3] = NanNew<Integer>(errorCode);
args[4] = stringOrUndefined(fullname);
args[5] = stringOrUndefined(hosttarget);
args[6] = NanNew<Integer>( ntohs(port) );
Local<Object> buffer = NanNewBufferHandle(txtLen);
memcpy(Buffer::Data(buffer), txtRecord, txtLen);
args[7] = buffer;
if (serviceRef->GetContext().IsEmpty()) {
args[8] = NanUndefined();
} else {
args[8] = NanNew<Value>(serviceRef->GetContext());
}
NanMakeCallback(this_, callback, argc, args);
}
static
void
DNSSD_API
OnServiceRegistered(DNSServiceRef sdRef, DNSServiceFlags flags,
DNSServiceErrorType errorCode, const char * name,
const char * serviceType, const char * domain, void * context)
{
if ( ! context) return;
NanScope();
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
if ( ! callback.IsEmpty() && ! this_.IsEmpty()) {
const size_t argc(7);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Integer>(errorCode);
args[3] = stringOrUndefined(name);
args[4] = stringOrUndefined(serviceType);
args[5] = stringOrUndefined(domain);
if (serviceRef->GetContext().IsEmpty()) {
args[6] = NanUndefined();
} else {
args[6] = NanNew<Value>(serviceRef->GetContext());
}
NanMakeCallback(this_, callback, argc, args);
}
}
Image::~Image() {
Local<Value> internalField = NanObjectWrapHandle(this)->GetInternalField(0);
if (internalField->IsNull()) return;
FIBITMAP *dib = static_cast<FIBITMAP*>(Local<External>::Cast(internalField)->Value());
FreeImage_Unload(dib);
}
Local<Function> Cache::exitCallback() {
NanEscapableScope();
Local<Function> unboundExitCallback(NanNew<FunctionTemplate>(Cache::Close)->GetFunction());
static const int argc = 1;
Handle<Value> argv[argc] = { NanObjectWrapHandle(this) };
Local<Function> boundExitCallback(
NanMakeCallback(unboundExitCallback, "bind", argc, argv).As<Function>());
return NanEscapeScope(boundExitCallback);
}
static NAUV_WORK_CB(EmitMessage)
{
NanScope();
NodeMidiInput *input = static_cast<NodeMidiInput*>(async->data);
uv_mutex_lock(&input->message_mutex);
v8::Local<v8::Function> emitFunction = NanObjectWrapHandle(input)->Get(NanNew<v8::String>(symbol_emit)).As<v8::Function>();
while (!input->message_queue.empty())
{
MidiMessage* message = input->message_queue.front();
v8::Local<v8::Value> args[3];
args[0] = NanNew<v8::String>(symbol_message);
args[1] = NanNew<v8::Number>(message->deltaTime);
int32_t count = (int32_t)message->message.size();
v8::Local<v8::Array> data = NanNew<v8::Array>(count);
for (int32_t i = 0; i < count; ++i) {
data->Set(NanNew<v8::Number>(i), NanNew<v8::Integer>(message->message[i]));
}
args[2] = data;
NanMakeCallback(NanObjectWrapHandle(input), emitFunction, 3, args);
input->message_queue.pop();
delete message;
}
uv_mutex_unlock(&input->message_mutex);
}
void
DNSSD_API
OnEnumeration(DNSServiceRef sdRef, DNSServiceFlags flags, uint32_t interfaceIndex,
DNSServiceErrorType errorCode, const char * replyDomain, void * context)
{
Nan::HandleScope scope;
ServiceRef * serviceRef = static_cast<ServiceRef*>(context);
Handle<Function> callback = serviceRef->GetCallback();
Handle<Object> this_ = serviceRef->GetThis();
const size_t argc(6);
Local<Value> args[argc];
args[0] = NanObjectWrapHandle(serviceRef);
args[1] = NanNew<Integer>(flags);
args[2] = NanNew<Uint32>(interfaceIndex);
args[3] = NanNew<Integer>(errorCode);
args[4] = stringOrUndefined(replyDomain);
args[5] = NanNew<Value>(serviceRef->GetContext());
NanMakeCallback(this_, callback, argc, args);
}
void NodeFileSource::processAdd(mbgl::Request *req) {
NanScope();
// Make sure the loop stays alive as long as request is pending.
if (pending.empty()) {
queue->ref();
}
auto handle = NanObjectWrapHandle(this);
auto requestHandle = NanNew<v8::Object>(NodeRequest::Create(handle, req));
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
const v8::UniquePersistent<v8::Object> requestPersistent(v8::Isolate::GetCurrent(), requestHandle);
#else
v8::Persistent<v8::Object> requestPersistent;
NanAssignPersistent(requestPersistent, requestHandle);
#endif
pending.emplace(req, std::move(requestPersistent));
v8::Local<v8::Value> argv[] = { requestHandle };
NanMakeCallback(handle, NanNew("request"), 1, argv);
}
void NodeFileSource::processCancel(mbgl::Request *req) {
NanScope();
auto it = pending.find(req);
if (it == pending.end()) {
// The response callback was already fired. There is no point in calling the cancelation
// callback because the request is already completed.
} else {
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
auto requestHandle = v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), it->second);
#else
auto requestHandle = NanNew<v8::Object>(it->second);
#endif
// Dispose and remove the persistent handle
#if (NODE_MODULE_VERSION <= NODE_0_10_MODULE_VERSION)
NanDisposePersistent(it->second);
#endif
pending.erase(it);
// Make sure the the loop can exit when there are no pending requests.
if (pending.empty()) {
queue->unref();
}
auto handle = NanObjectWrapHandle(this);
if (handle->Has(NanNew("cancel"))) {
v8::Local<v8::Value> argv[] = { requestHandle };
NanMakeCallback(handle, NanNew("cancel"), 1, argv);
}
// Set the request handle in the request wrapper handle to null
ObjectWrap::Unwrap<NodeRequest>(requestHandle)->cancel();
}
// Finally, destruct the request object
req->destruct();
}
void Grid::EIO_AfterClear(uv_work_t* req)
{
NanScope();
clear_grid_baton_t *closure = static_cast<clear_grid_baton_t *>(req->data);
if (closure->error)
{
// There seems to be no possible way for the exception to be thrown in the previous
// process and therefore not possible to have an error here so removing it from code
// coverage
/* LCOV_EXCL_START */
Local<Value> argv[1] = { NanError(closure->error_name.c_str()) };
NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 1, argv);
/* LCOV_EXCL_END */
}
else
{
Local<Value> argv[2] = { NanNull(), NanObjectWrapHandle(closure->g) };
NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(closure->cb), 2, argv);
}
closure->g->Unref();
NanDisposePersistent(closure->cb);
delete closure;
}
static NAN_METHOD(GetHandle) {
NanScope();
MyObject* obj = node::ObjectWrap::Unwrap<MyObject>(args.This());
NanReturnValue(NanObjectWrapHandle(obj));
}
