tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Nan 2.0

Browse Source
This commit is contained in:
John Firebaugh
2015-09-03 15:54:18 -07:00
parent aa001f07c3
commit 0531b38367
10 changed files with 239 additions and 242 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
package.json
View File

@@ -18,7 +18,7 @@
}
],
"dependencies": {
"nan": "^1.9.0",
"nan": "^2.0.8",
"node-pre-gyp": "^0.6.9"
},
"bundledDependencies": [

49
platform/node/src/node_file_source.cpp
View File

@@ -11,7 +11,7 @@ struct NodeFileSource::Action {
mbgl::Resource const resource;
};
NodeFileSource::NodeFileSource(v8::Handle<v8::Object> options_) :
NodeFileSource::NodeFileSource(v8::Local<v8::Object> options_) :
queue(new Queue(uv_default_loop(), [this](Action &action) {
if (action.type == Action::Add) {
processAdd(action.resource);
@@ -20,7 +20,7 @@ NodeFileSource::NodeFileSource(v8::Handle<v8::Object> options_) :
}
}))
{
NanAssignPersistent(options, options_->ToObject());
options.Reset(options_);
// Make sure that the queue doesn't block the loop from exiting.
queue->unref();
@@ -30,7 +30,7 @@ NodeFileSource::~NodeFileSource() {
queue->stop();
queue = nullptr;
NanDisposePersistent(options);
options.Reset();
}
mbgl::Request* NodeFileSource::request(const mbgl::Resource& resource, uv_loop_t* loop, Callback callback) {
@@ -68,44 +68,30 @@ void NodeFileSource::cancel(mbgl::Request* req) {
}
void NodeFileSource::processAdd(const mbgl::Resource& resource) {
NanScope();
Nan::HandleScope scope;
// Make sure the loop stays alive as long as request is pending.
if (pending.empty()) {
queue->ref();
}
auto requestHandle = NanNew<v8::Object>(NodeRequest::Create(this, resource));
v8::Persistent<v8::Object> requestPersistent;
NanAssignPersistent(requestPersistent, requestHandle);
pending.emplace(resource, std::move(requestPersistent));
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
auto requestFunction = v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), options)->Get(NanNew("request")).As<v8::Function>();
#else
auto requestFunction = options->Get(NanNew("request")).As<v8::Function>();
#endif
auto requestHandle = Nan::New<v8::Object>(NodeRequest::Create(this, resource));
pending.emplace(resource, requestHandle);
v8::Local<v8::Value> argv[] = { requestHandle };
NanMakeCallback(NanGetCurrentContext()->Global(), requestFunction, 1, argv);
Nan::MakeCallback(Nan::New(options), "request", 1, argv);
}
void NodeFileSource::processCancel(const mbgl::Resource& resource) {
NanScope();
Nan::HandleScope scope;
auto it = pending.find(resource);
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);
v8::Local<v8::Object> requestHandle = Nan::New(it->second);
it->second.Reset();
#else
auto requestHandle = NanNew<v8::Object>(it->second);
NanDisposePersistent(it->second);
#endif
pending.erase(it);
// Make sure the the loop can exit when there are no pending requests.
@@ -113,20 +99,13 @@ void NodeFileSource::processCancel(const mbgl::Resource& resource) {
queue->unref();
}
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
auto optionsObject = v8::Local<v8::Object>::New(v8::Isolate::GetCurrent(), options);
if (optionsObject->Has(NanNew("cancel"))) {
auto cancelFunction = optionsObject->Get(NanNew("cancel")).As<v8::Function>();
#else
if (options->Has(NanNew("cancel"))) {
auto cancelFunction = options->Get(NanNew("cancel")).As<v8::Function>();
#endif
if (Nan::Has(Nan::New(options), Nan::New("cancel").ToLocalChecked()).FromJust()) {
v8::Local<v8::Value> argv[] = { requestHandle };
NanMakeCallback(NanGetCurrentContext()->Global(), cancelFunction, 1, argv);
Nan::MakeCallback(Nan::New(options), "cancel", 1, argv);
}
// Set the request handle in the request wrapper handle to null
node::ObjectWrap::Unwrap<NodeRequest>(requestHandle)->cancel();
Nan::ObjectWrap::Unwrap<NodeRequest>(requestHandle)->cancel();
}
}
@@ -134,11 +113,7 @@ void NodeFileSource::notify(const mbgl::Resource& resource, const std::shared_pt
// First, remove the request, since it might be destructed at any point now.
auto it = pending.find(resource);
if (it != pending.end()) {
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
it->second.Reset();
#else
NanDisposePersistent(it->second);
#endif
pending.erase(it);
// Make sure the the loop can exit when there are no pending requests.

12
platform/node/src/node_file_source.hpp
View File

@@ -5,8 +5,6 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wshadow"
#include <node.h>
#include <node_version.h>
#include <nan.h>
#pragma GCC diagnostic pop
@@ -20,7 +18,7 @@ namespace util { template <typename T> class AsyncQueue; }
class NodeFileSource : public mbgl::FileSource {
public:
NodeFileSource(v8::Handle<v8::Object>);
NodeFileSource(v8::Local<v8::Object>);
~NodeFileSource();
mbgl::Request* request(const mbgl::Resource&, uv_loop_t*, Callback);
@@ -36,14 +34,10 @@ private:
void processAdd(const mbgl::Resource&);
void processCancel(const mbgl::Resource&);
v8::Persistent<v8::Object> options;
Nan::Persistent<v8::Object> options;
private:
#if (NODE_MODULE_VERSION > NODE_0_10_MODULE_VERSION)
std::unordered_map<mbgl::Resource, v8::Persistent<v8::Object, v8::CopyablePersistentTraits<v8::Object>>, mbgl::Resource::Hash> pending;
#else
std::unordered_map<mbgl::Resource, v8::Persistent<v8::Object>, mbgl::Resource::Hash> pending;
#endif
std::unordered_map<mbgl::Resource, Nan::Persistent<v8::Object>, mbgl::Resource::Hash> pending;
// The observers list will hold pointers to all the requests waiting
// for a particular resource. The access must be guarded by a mutex

39
platform/node/src/node_log.cpp
View File

@@ -16,27 +16,35 @@ struct NodeLogObserver::LogMessage {
text(text_) {}
};
NodeLogObserver::NodeLogObserver(v8::Handle<v8::Object> target)
NodeLogObserver::NodeLogObserver(v8::Local<v8::Object> target)
: queue(new Queue(uv_default_loop(), [this](LogMessage &message) {
NanScope();
Nan::HandleScope scope;
auto msg = Nan::New<v8::Object>();
Nan::Set(msg, Nan::New("class").ToLocalChecked(),
Nan::New(mbgl::EventClass(message.event).c_str()).ToLocalChecked());
Nan::Set(msg, Nan::New("severity").ToLocalChecked(),
Nan::New(mbgl::EventSeverityClass(message.severity).c_str()).ToLocalChecked());
auto msg = NanNew<v8::Object>();
msg->Set(NanNew("class"), NanNew(mbgl::EventClass(message.event).c_str()));
msg->Set(NanNew("severity"), NanNew(mbgl::EventSeverityClass(message.severity).c_str()));
if (message.code != -1) {
msg->Set(NanNew("code"), NanNew<v8::Number>(message.code));
}
if (!message.text.empty()) {
msg->Set(NanNew("text"), NanNew(message.text));
Nan::Set(msg, Nan::New("code").ToLocalChecked(),
Nan::New<v8::Number>(message.code));
}
v8::Local<v8::Value> argv[] = { NanNew("message"), msg };
auto handle = NanNew<v8::Object>(module);
auto emit = handle->Get(NanNew("emit"))->ToObject();
emit->CallAsFunction(handle, 2, argv);
if (!message.text.empty()) {
Nan::Set(msg, Nan::New("text").ToLocalChecked(),
Nan::New(message.text).ToLocalChecked());
}
v8::Local<v8::Value> argv[] = { Nan::New("message").ToLocalChecked(), msg };
auto handle = Nan::New<v8::Object>(module);
auto emit = Nan::Get(handle, Nan::New("emit").ToLocalChecked()).ToLocalChecked()->ToObject();
Nan::CallAsFunction(emit, handle, 2, argv);
})) {
NanScope();
NanAssignPersistent(module, target);
Nan::HandleScope scope;
module.Reset(target);
// Don't keep the event loop alive.
queue->unref();
@@ -44,6 +52,7 @@ NodeLogObserver::NodeLogObserver(v8::Handle<v8::Object> target)
NodeLogObserver::~NodeLogObserver() {
queue->stop();
module.Reset();
}
bool NodeLogObserver::onRecord(mbgl::EventSeverity severity, mbgl::Event event, int64_t code, const std::string &text) {

5
platform/node/src/node_log.hpp
View File

@@ -5,7 +5,6 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wshadow"
#include <node.h>
#include <nan.h>
#pragma GCC diagnostic pop
@@ -15,14 +14,14 @@ namespace util { template <typename T> class AsyncQueue; }
class NodeLogObserver : public mbgl::Log::Observer {
public:
NodeLogObserver(v8::Handle<v8::Object> target);
NodeLogObserver(v8::Local<v8::Object> target);
~NodeLogObserver();
// Log::Observer implementation
virtual bool onRecord(mbgl::EventSeverity severity, mbgl::Event event, int64_t code, const std::string &msg) override;
private:
v8::Persistent<v8::Object> module;
Nan::Persistent<v8::Object> module;
struct LogMessage;
using Queue = util::AsyncQueue<LogMessage>;

180
platform/node/src/node_map.cpp
View File

@@ -21,7 +21,7 @@ struct NodeMap::RenderOptions {
////////////////////////////////////////////////////////////////////////////////////////////////
// Static Node Methods
v8::Persistent<v8::FunctionTemplate> NodeMap::constructorTemplate;
Nan::Persistent<v8::Function> NodeMap::constructor;
static std::shared_ptr<mbgl::HeadlessDisplay> sharedDisplay() {
static auto display = std::make_shared<mbgl::HeadlessDisplay>();
@@ -32,127 +32,137 @@ const static char* releasedMessage() {
return "Map resources have already been released";
}
void NodeMap::Init(v8::Handle<v8::Object> target) {
NanScope();
NAN_MODULE_INIT(NodeMap::Init) {
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>(New);
tpl->InstanceTemplate()->SetInternalFieldCount(1);
tpl->SetClassName(Nan::New("Map").ToLocalChecked());
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(NanNew("Map"));
Nan::SetPrototypeMethod(tpl, "load", Load);
Nan::SetPrototypeMethod(tpl, "render", Render);
Nan::SetPrototypeMethod(tpl, "release", Release);
NODE_SET_PROTOTYPE_METHOD(t, "load", Load);
NODE_SET_PROTOTYPE_METHOD(t, "render", Render);
NODE_SET_PROTOTYPE_METHOD(t, "release", Release);
NanAssignPersistent(constructorTemplate, t);
target->Set(NanNew("Map"), t->GetFunction());
constructor.Reset(tpl->GetFunction());
Nan::Set(target, Nan::New("Map").ToLocalChecked(), tpl->GetFunction());
// Initialize display connection on module load.
sharedDisplay();
}
NAN_METHOD(NodeMap::New) {
NanScope();
if (!args.IsConstructCall()) {
return NanThrowTypeError("Use the new operator to create new Map objects");
if (!info.IsConstructCall()) {
return Nan::ThrowTypeError("Use the new operator to create new Map objects");
}
if (args.Length() < 1 || !args[0]->IsObject()) {
return NanThrowTypeError("Requires an options object as first argument");
if (info.Length() < 1 || !info[0]->IsObject()) {
return Nan::ThrowTypeError("Requires an options object as first argument");
}
auto options = args[0]->ToObject();
auto options = info[0]->ToObject();
// Check that 'request', 'cancel' and 'ratio' are defined.
if (!options->Has(NanNew("request")) || !options->Get(NanNew("request"))->IsFunction()) {
return NanThrowError("Options object must have a 'request' method");
}
if (options->Has(NanNew("cancel")) && !options->Get(NanNew("cancel"))->IsFunction()) {
return NanThrowError("Options object 'cancel' property must be a function");
if (!Nan::Has(options, Nan::New("request").ToLocalChecked()).FromJust()
|| !Nan::Get(options, Nan::New("request").ToLocalChecked()).ToLocalChecked()->IsFunction()) {
return Nan::ThrowError("Options object must have a 'request' method");
}
if (!options->Has(NanNew("ratio")) || !options->Get(NanNew("ratio"))->IsNumber()) {
return NanThrowError("Options object must have a numerical 'ratio' property");
if ( Nan::Has(options, Nan::New("cancel").ToLocalChecked()).FromJust()
&& !Nan::Get(options, Nan::New("cancel").ToLocalChecked()).ToLocalChecked()->IsFunction()) {
return Nan::ThrowError("Options object 'cancel' property must be a function");
}
if (!Nan::Has(options, Nan::New("ratio").ToLocalChecked()).FromJust()
|| !Nan::Get(options, Nan::New("ratio").ToLocalChecked()).ToLocalChecked()->IsNumber()) {
return Nan::ThrowError("Options object must have a numerical 'ratio' property");
}
try {
auto nodeMap = new NodeMap(options);
nodeMap->Wrap(args.This());
nodeMap->Wrap(info.This());
} catch(std::exception &ex) {
return NanThrowError(ex.what());
return Nan::ThrowError(ex.what());
}
NanReturnValue(args.This());
info.GetReturnValue().Set(info.This());
}
const std::string StringifyStyle(v8::Handle<v8::Value> styleHandle) {
NanScope();
const std::string StringifyStyle(v8::Local<v8::Value> styleHandle) {
Nan::HandleScope scope;
auto JSON = NanGetCurrentContext()->Global()->Get(NanNew("JSON"))->ToObject();
auto stringify = v8::Handle<v8::Function>::Cast(JSON->Get(NanNew("stringify")));
v8::Local<v8::Object> JSON = Nan::Get(
Nan::GetCurrentContext()->Global(),
Nan::New("JSON").ToLocalChecked()).ToLocalChecked()->ToObject();
return *NanUtf8String(stringify->Call(JSON, 1, &styleHandle));
return *Nan::Utf8String(Nan::MakeCallback(JSON, "stringify", 1, &styleHandle));
}
NAN_METHOD(NodeMap::Load) {
NanScope();
auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
auto nodeMap = node::ObjectWrap::Unwrap<NodeMap>(args.Holder());
if (!nodeMap->isValid()) return NanThrowError(releasedMessage());
if (!nodeMap->isValid()) return Nan::ThrowError(releasedMessage());
// Reset the flag as this could be the second time
// we are calling this (being the previous successful).
nodeMap->loaded = false;
if (args.Length() < 1) {
return NanThrowError("Requires a map style as first argument");
if (info.Length() < 1) {
return Nan::ThrowError("Requires a map style as first argument");
}
std::string style;
if (args[0]->IsObject()) {
style = StringifyStyle(args[0]);
} else if (args[0]->IsString()) {
style = *NanUtf8String(args[0]);
if (info[0]->IsObject()) {
style = StringifyStyle(info[0]);
} else if (info[0]->IsString()) {
style = *Nan::Utf8String(info[0]);
} else {
return NanThrowTypeError("First argument must be a string or object");
return Nan::ThrowTypeError("First argument must be a string or object");
}
try {
nodeMap->map->setStyleJSON(style, ".");
} catch (const std::exception &ex) {
return NanThrowError(ex.what());
return Nan::ThrowError(ex.what());
}
nodeMap->loaded = true;
NanReturnUndefined();
info.GetReturnValue().SetUndefined();
}
std::unique_ptr<NodeMap::RenderOptions> NodeMap::ParseOptions(v8::Local<v8::Object> obj) {
NanScope();
Nan::HandleScope scope;
auto options = std::make_unique<RenderOptions>();
if (obj->Has(NanNew("zoom"))) { options->zoom = obj->Get(NanNew("zoom"))->NumberValue(); }
if (obj->Has(NanNew("bearing"))) { options->bearing = obj->Get(NanNew("bearing"))->NumberValue(); }
if (obj->Has(NanNew("center"))) {
auto center = obj->Get(NanNew("center")).As<v8::Array>();
if (center->Length() > 0) { options->latitude = center->Get(0)->NumberValue(); }
if (center->Length() > 1) { options->longitude = center->Get(1)->NumberValue(); }
if (Nan::Has(obj, Nan::New("zoom").ToLocalChecked()).FromJust()) {
options->zoom = Nan::Get(obj, Nan::New("zoom").ToLocalChecked()).ToLocalChecked()->NumberValue();
}
if (obj->Has(NanNew("width"))) { options->width = obj->Get(NanNew("width"))->IntegerValue(); }
if (obj->Has(NanNew("height"))) { options->height = obj->Get(NanNew("height"))->IntegerValue(); }
if (obj->Has(NanNew("classes"))) {
auto classes = obj->Get(NanNew("classes"))->ToObject().As<v8::Array>();
if (Nan::Has(obj, Nan::New("bearing").ToLocalChecked()).FromJust()) {
options->bearing = Nan::Get(obj, Nan::New("bearing").ToLocalChecked()).ToLocalChecked()->NumberValue();
}
if (Nan::Has(obj, Nan::New("center").ToLocalChecked()).FromJust()) {
auto center = Nan::Get(obj, Nan::New("center").ToLocalChecked()).ToLocalChecked().As<v8::Array>();
if (center->Length() > 0) { options->latitude = Nan::Get(center, 0).ToLocalChecked()->NumberValue(); }
if (center->Length() > 1) { options->longitude = Nan::Get(center, 1).ToLocalChecked()->NumberValue(); }
}
if (Nan::Has(obj, Nan::New("width").ToLocalChecked()).FromJust()) {
options->width = Nan::Get(obj, Nan::New("width").ToLocalChecked()).ToLocalChecked()->IntegerValue();
}
if (Nan::Has(obj, Nan::New("height").ToLocalChecked()).FromJust()) {
options->height = Nan::Get(obj, Nan::New("height").ToLocalChecked()).ToLocalChecked()->IntegerValue();
}
if (Nan::Has(obj, Nan::New("classes").ToLocalChecked()).FromJust()) {
auto classes = Nan::Get(obj, Nan::New("classes").ToLocalChecked()).ToLocalChecked()->ToObject().As<v8::Array>();
const int length = classes->Length();
options->classes.reserve(length);
for (int i = 0; i < length; i++) {
options->classes.push_back(std::string { *NanUtf8String(classes->Get(i)->ToString()) });
options->classes.push_back(std::string { *Nan::Utf8String(Nan::Get(classes, i).ToLocalChecked()->ToString()) });
}
}
@@ -160,37 +170,35 @@ std::unique_ptr<NodeMap::RenderOptions> NodeMap::ParseOptions(v8::Local<v8::Obje
}
NAN_METHOD(NodeMap::Render) {
NanScope();
auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
auto nodeMap = node::ObjectWrap::Unwrap<NodeMap>(args.Holder());
if (!nodeMap->isValid()) return Nan::ThrowError(releasedMessage());
if (!nodeMap->isValid()) return NanThrowError(releasedMessage());
if (args.Length() <= 0 || !args[0]->IsObject()) {
return NanThrowTypeError("First argument must be an options object");
if (info.Length() <= 0 || !info[0]->IsObject()) {
return Nan::ThrowTypeError("First argument must be an options object");
}
if (args.Length() <= 1 || !args[1]->IsFunction()) {
return NanThrowTypeError("Second argument must be a callback function");
if (info.Length() <= 1 || !info[1]->IsFunction()) {
return Nan::ThrowTypeError("Second argument must be a callback function");
}
if (!nodeMap->isLoaded()) {
return NanThrowTypeError("Style is not loaded");
return Nan::ThrowTypeError("Style is not loaded");
}
auto options = ParseOptions(args[0]->ToObject());
auto options = ParseOptions(info[0]->ToObject());
assert(!nodeMap->callback);
assert(!nodeMap->image);
nodeMap->callback = std::unique_ptr<NanCallback>(new NanCallback(args[1].As<v8::Function>()));
nodeMap->callback = std::make_unique<Nan::Callback>(info[1].As<v8::Function>());
try {
nodeMap->startRender(std::move(options));
} catch (mbgl::util::Exception &ex) {
return NanThrowError(ex.what());
return Nan::ThrowError(ex.what());
}
NanReturnUndefined();
info.GetReturnValue().SetUndefined();
}
void NodeMap::startRender(std::unique_ptr<NodeMap::RenderOptions> options) {
@@ -221,7 +229,7 @@ void NodeMap::startRender(std::unique_ptr<NodeMap::RenderOptions> options) {
}
void NodeMap::renderFinished() {
NanScope();
Nan::HandleScope scope;
// We're done with this render call, so we're unrefing so that the loop could close.
uv_unref(reinterpret_cast<uv_handle_t *>(async));
@@ -249,7 +257,7 @@ void NodeMap::renderFinished() {
}
v8::Local<v8::Value> argv[] = {
NanError(errorMessage.c_str())
Nan::Error(errorMessage.c_str())
};
// This must be empty to be prepared for the next render call.
@@ -258,7 +266,7 @@ void NodeMap::renderFinished() {
cb->Call(1, argv);
} else if (img) {
v8::Local<v8::Object> pixels = NanNewBufferHandle(
v8::Local<v8::Object> pixels = Nan::NewBuffer(
reinterpret_cast<char *>(img->pixels.get()),
size_t(img->width) * size_t(img->height) * sizeof(mbgl::StillImage::Pixel),
@@ -267,36 +275,34 @@ void NodeMap::renderFinished() {
delete reinterpret_cast<const mbgl::StillImage *>(hint);
},
const_cast<mbgl::StillImage *>(img.get())
);
).ToLocalChecked();
img.release();
v8::Local<v8::Value> argv[] = {
NanNull(),
Nan::Null(),
pixels,
};
cb->Call(2, argv);
} else {
v8::Local<v8::Value> argv[] = {
NanError("Didn't get an image")
Nan::Error("Didn't get an image")
};
cb->Call(1, argv);
}
}
NAN_METHOD(NodeMap::Release) {
NanScope();
auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder());
auto nodeMap = node::ObjectWrap::Unwrap<NodeMap>(args.Holder());
if (!nodeMap->isValid()) return NanThrowError(releasedMessage());
if (!nodeMap->isValid()) return Nan::ThrowError(releasedMessage());
try {
nodeMap->release();
} catch (const std::exception &ex) {
return NanThrowError(ex.what());
return Nan::ThrowError(ex.what());
}
NanReturnUndefined();
info.GetReturnValue().SetUndefined();
}
void NodeMap::release() {
@@ -315,8 +321,8 @@ void NodeMap::release() {
////////////////////////////////////////////////////////////////////////////////////////////////
// Instance
NodeMap::NodeMap(v8::Handle<v8::Object> options) :
view(sharedDisplay(), options->Get(NanNew("ratio"))->NumberValue()),
NodeMap::NodeMap(v8::Local<v8::Object> options) :
view(sharedDisplay(), Nan::Get(options, Nan::New("ratio").ToLocalChecked()).ToLocalChecked()->NumberValue()),
fs(options),
map(std::make_unique<mbgl::Map>(view, fs, mbgl::MapMode::Still)),
async(new uv_async_t) {

22
platform/node/src/node_map.hpp
View File

@@ -8,7 +8,6 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wshadow"
#include <node.h>
#include <nan.h>
#pragma GCC diagnostic pop
@@ -16,14 +15,13 @@
namespace node_mbgl {
class NodeMap : public node::ObjectWrap {
class NodeMap : public Nan::ObjectWrap {
public:
struct RenderOptions;
class RenderWorker;
////////////////////////////////////////////////////////////////////////////////////////////////
// Static Node Methods
public:
static void Init(v8::Handle<v8::Object> target);
static NAN_MODULE_INIT(Init);
static NAN_METHOD(New);
static NAN_METHOD(Load);
static NAN_METHOD(Render);
@@ -37,24 +35,20 @@ public:
inline bool isLoaded() { return loaded; }
inline bool isValid() { return valid; }
static std::unique_ptr<NodeMap::RenderOptions> ParseOptions(v8::Local<v8::Object> obj);
static std::unique_ptr<NodeMap::RenderOptions> ParseOptions(v8::Local<v8::Object>);
static Nan::Persistent<v8::Function> constructor;
static v8::Persistent<v8::FunctionTemplate> constructorTemplate;
////////////////////////////////////////////////////////////////////////////////////////////////
// Instance
private:
NodeMap(v8::Handle<v8::Object>);
NodeMap(v8::Local<v8::Object>);
~NodeMap();
private:
mbgl::HeadlessView view;
NodeFileSource fs;
std::unique_ptr<mbgl::Map> map;
std::exception_ptr error;
std::unique_ptr<const mbgl::StillImage> image;
std::unique_ptr<NanCallback> callback;
std::unique_ptr<Nan::Callback> callback;
// Async for delivering the notifications of render completion.
uv_async_t *async;

67
platform/node/src/node_mapbox_gl_native.cpp
View File

@@ -9,30 +9,57 @@
#include "node_log.hpp"
#include "node_request.hpp"
void RegisterModule(v8::Handle<v8::Object> exports) {
NanScope();
node_mbgl::NodeMap::Init(exports);
node_mbgl::NodeRequest::Init(exports);
NAN_MODULE_INIT(RegisterModule) {
node_mbgl::NodeMap::Init(target);
node_mbgl::NodeRequest::Init(target);
// Exports Resource constants.
auto ConstantProperty = static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
auto resource = NanNew<v8::Object>();
resource->ForceSet(NanNew("Unknown"), NanNew(mbgl::Resource::Unknown), ConstantProperty);
resource->ForceSet(NanNew("Style"), NanNew(mbgl::Resource::Style), ConstantProperty);
resource->ForceSet(NanNew("Source"), NanNew(mbgl::Resource::Source), ConstantProperty);
resource->ForceSet(NanNew("Tile"), NanNew(mbgl::Resource::Tile), ConstantProperty);
resource->ForceSet(NanNew("Glyphs"), NanNew(mbgl::Resource::Glyphs), ConstantProperty);
resource->ForceSet(NanNew("SpriteImage"), NanNew(mbgl::Resource::SpriteImage), ConstantProperty);
resource->ForceSet(NanNew("SpriteJSON"), NanNew(mbgl::Resource::SpriteJSON), ConstantProperty);
exports->ForceSet(NanNew("Resource"), resource, ConstantProperty);
v8::Local<v8::Object> resource = Nan::New<v8::Object>();
// Make the exported object inerhit from process.EventEmitter
auto process = NanGetCurrentContext()->Global()->Get(NanNew("process"))->ToObject();
auto EventEmitter = process->Get(NanNew("EventEmitter"))->ToObject();
exports->SetPrototype(EventEmitter->Get(NanNew("prototype")));
Nan::Set(resource,
Nan::New("Unknown").ToLocalChecked(),
Nan::New(mbgl::Resource::Unknown));
mbgl::Log::setObserver(std::make_unique<node_mbgl::NodeLogObserver>(exports));
Nan::Set(resource,
Nan::New("Style").ToLocalChecked(),
Nan::New(mbgl::Resource::Style));
Nan::Set(resource,
Nan::New("Source").ToLocalChecked(),
Nan::New(mbgl::Resource::Source));
Nan::Set(resource,
Nan::New("Tile").ToLocalChecked(),
Nan::New(mbgl::Resource::Tile));
Nan::Set(resource,
Nan::New("Glyphs").ToLocalChecked(),
Nan::New(mbgl::Resource::Glyphs));
Nan::Set(resource,
Nan::New("SpriteImage").ToLocalChecked(),
Nan::New(mbgl::Resource::SpriteImage));
Nan::Set(resource,
Nan::New("SpriteJSON").ToLocalChecked(),
Nan::New(mbgl::Resource::SpriteJSON));
Nan::Set(target,
Nan::New("Resource").ToLocalChecked(),
resource);
// Make the exported object inherit from process.EventEmitter
v8::Local<v8::Object> process = Nan::Get(
Nan::GetCurrentContext()->Global(),
Nan::New("process").ToLocalChecked()).ToLocalChecked()->ToObject();
v8::Local<v8::Object> EventEmitter = Nan::Get(process,
Nan::New("EventEmitter").ToLocalChecked()).ToLocalChecked()->ToObject();
Nan::SetPrototype(target,
Nan::Get(EventEmitter, Nan::New("prototype").ToLocalChecked()).ToLocalChecked());
mbgl::Log::setObserver(std::make_unique<node_mbgl::NodeLogObserver>(Nan::New(target)));
}
NODE_MODULE(mapbox_gl_native, RegisterModule)

91
platform/node/src/node_request.cpp
View File

@@ -11,112 +11,111 @@ namespace node_mbgl {
////////////////////////////////////////////////////////////////////////////////////////////////
// Static Node Methods
v8::Persistent<v8::FunctionTemplate> NodeRequest::constructorTemplate;
Nan::Persistent<v8::Function> NodeRequest::constructor;
void NodeRequest::Init(v8::Handle<v8::Object> target) {
NanScope();
NAN_MODULE_INIT(NodeRequest::Init) {
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
v8::Local<v8::FunctionTemplate> t = NanNew<v8::FunctionTemplate>(New);
tpl->InstanceTemplate()->SetInternalFieldCount(1);
tpl->SetClassName(Nan::New("Request").ToLocalChecked());
t->InstanceTemplate()->SetInternalFieldCount(1);
t->SetClassName(NanNew("Request"));
Nan::SetPrototypeMethod(tpl, "respond", Respond);
NODE_SET_PROTOTYPE_METHOD(t, "respond", Respond);
NanAssignPersistent(constructorTemplate, t);
target->Set(NanNew("Request"), t->GetFunction());
constructor.Reset(tpl->GetFunction());
Nan::Set(target, Nan::New("Request").ToLocalChecked(), tpl->GetFunction());
}
NAN_METHOD(NodeRequest::New) {
NanScope();
// Extract the pointer from the first argument
if (args.Length() < 2 || !args[0]->IsExternal() || !args[1]->IsExternal()) {
return NanThrowTypeError("Cannot create Request objects explicitly");
if (info.Length() < 2 || !info[0]->IsExternal() || !info[1]->IsExternal()) {
return Nan::ThrowTypeError("Cannot create Request objects explicitly");
}
auto source = reinterpret_cast<NodeFileSource*>(args[0].As<v8::External>()->Value());
auto resource = reinterpret_cast<mbgl::Resource*>(args[1].As<v8::External>()->Value());
auto source = reinterpret_cast<NodeFileSource*>(info[0].As<v8::External>()->Value());
auto resource = reinterpret_cast<mbgl::Resource*>(info[1].As<v8::External>()->Value());
auto req = new NodeRequest(source, *resource);
req->Wrap(args.This());
req->Wrap(info.This());
NanReturnValue(args.This());
info.GetReturnValue().Set(info.This());
}
v8::Handle<v8::Object> NodeRequest::Create(NodeFileSource* source, const mbgl::Resource& resource) {
NanEscapableScope();
Nan::EscapableHandleScope scope;
v8::Local<v8::Value> argv[] = { NanNew<v8::External>(const_cast<NodeFileSource*>(source)),
NanNew<v8::External>(const_cast<mbgl::Resource*>(&resource)) };
auto instance = NanNew<v8::FunctionTemplate>(constructorTemplate)->GetFunction()->NewInstance(2, argv);
v8::Local<v8::Value> argv[] = {
Nan::New<v8::External>(const_cast<NodeFileSource*>(source)),
Nan::New<v8::External>(const_cast<mbgl::Resource*>(&resource))
};
auto instance = Nan::New(constructor)->NewInstance(2, argv);
instance->ForceSet(NanNew("url"), NanNew(resource.url), v8::ReadOnly);
instance->ForceSet(NanNew("kind"), NanNew<v8::Integer>(int(resource.kind)), v8::ReadOnly);
Nan::Set(instance, Nan::New("url").ToLocalChecked(), Nan::New(resource.url).ToLocalChecked());
Nan::Set(instance, Nan::New("kind").ToLocalChecked(), Nan::New<v8::Integer>(int(resource.kind)));
return NanEscapeScope(instance);
return scope.Escape(instance);
}
NAN_METHOD(NodeRequest::Respond) {
auto nodeRequest = ObjectWrap::Unwrap<NodeRequest>(args.Holder());
auto nodeRequest = Nan::ObjectWrap::Unwrap<NodeRequest>(info.Holder());
// Request has already been responded to, or was canceled, fail silently.
if (!nodeRequest->resource) NanReturnUndefined();
if (!nodeRequest->resource) {
return info.GetReturnValue().SetUndefined();
}
auto source = nodeRequest->source;
auto resource = std::move(nodeRequest->resource);
if (args.Length() < 1) {
return NanThrowTypeError("First argument must be an error object");
} else if (args[0]->BooleanValue()) {
if (info.Length() < 1) {
return Nan::ThrowTypeError("First argument must be an error object");
} else if (info[0]->BooleanValue()) {
auto response = std::make_shared<mbgl::Response>();
response->status = mbgl::Response::Error;
// Store the error string.
const NanUtf8String message { args[0]->ToString() };
const Nan::Utf8String message { info[0]->ToString() };
response->message = std::string { *message, size_t(message.length()) };
source->notify(*resource, response);
} else if (args.Length() < 2 || !args[1]->IsObject()) {
return NanThrowTypeError("Second argument must be a response object");
} else if (info.Length() < 2 || !info[1]->IsObject()) {
return Nan::ThrowTypeError("Second argument must be a response object");
} else {
auto response = std::make_shared<mbgl::Response>();
auto res = args[1]->ToObject();
auto res = info[1]->ToObject();
response->status = mbgl::Response::Successful;
if (res->Has(NanNew("modified"))) {
const double modified = res->Get(NanNew("modified"))->ToNumber()->Value();
if (Nan::Has(res, Nan::New("modified").ToLocalChecked()).FromJust()) {
const double modified = Nan::Get(res, Nan::New("modified").ToLocalChecked()).ToLocalChecked()->ToNumber()->Value();
if (!std::isnan(modified)) {
response->modified = modified / 1000; // JS timestamps are milliseconds
}
}
if (res->Has(NanNew("expires"))) {
const double expires = res->Get(NanNew("expires"))->ToNumber()->Value();
if (Nan::Has(res, Nan::New("expires").ToLocalChecked()).FromJust()) {
const double expires = Nan::Get(res, Nan::New("expires").ToLocalChecked()).ToLocalChecked()->ToNumber()->Value();
if (!std::isnan(expires)) {
response->expires = expires / 1000; // JS timestamps are milliseconds
}
}
if (res->Has(NanNew("etag"))) {
auto etagHandle = res->Get(NanNew("etag"));
if (Nan::Has(res, Nan::New("etag").ToLocalChecked()).FromJust()) {
auto etagHandle = Nan::Get(res, Nan::New("etag").ToLocalChecked()).ToLocalChecked();
if (etagHandle->BooleanValue()) {
const NanUtf8String etag { etagHandle->ToString() };
const Nan::Utf8String etag { etagHandle->ToString() };
response->etag = std::string { *etag, size_t(etag.length()) };
}
}
if (res->Has(NanNew("data"))) {
auto dataHandle = res->Get(NanNew("data"));
if (Nan::Has(res, Nan::New("data").ToLocalChecked()).FromJust()) {
auto dataHandle = Nan::Get(res, Nan::New("data").ToLocalChecked()).ToLocalChecked();
if (node::Buffer::HasInstance(dataHandle)) {
response->data = std::string {
node::Buffer::Data(dataHandle),
node::Buffer::Length(dataHandle)
};
} else {
return NanThrowTypeError("Response data must be a Buffer");
return Nan::ThrowTypeError("Response data must be a Buffer");
}
}
@@ -124,7 +123,7 @@ NAN_METHOD(NodeRequest::Respond) {
source->notify(*resource, response);
}
NanReturnUndefined();
info.GetReturnValue().SetUndefined();
}
////////////////////////////////////////////////////////////////////////////////////////////////

14
platform/node/src/node_request.hpp
View File

@@ -3,7 +3,6 @@
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wshadow"
#include <node.h>
#include <nan.h>
#pragma GCC diagnostic pop
@@ -15,21 +14,16 @@ namespace node_mbgl {
class NodeFileSource;
class NodeRequest : public node::ObjectWrap {
////////////////////////////////////////////////////////////////////////////////////////////////
// Static Node Methods
class NodeRequest : public Nan::ObjectWrap {
public:
static void Init(v8::Handle<v8::Object> target);
static NAN_MODULE_INIT(Init);
static NAN_METHOD(New);
static NAN_METHOD(Respond);
static v8::Handle<v8::Object> Create(NodeFileSource*, const mbgl::Resource&);
static Nan::Persistent<v8::Function> constructor;
static v8::Persistent<v8::FunctionTemplate> constructorTemplate;
////////////////////////////////////////////////////////////////////////////////////////////////
// Instance
public:
NodeRequest(NodeFileSource* source, const mbgl::Resource& resource);
~NodeRequest();