diff options
author | John Firebaugh <john.firebaugh@gmail.com> | 2015-09-03 15:54:18 -0700 |
---|---|---|
committer | John Firebaugh <john.firebaugh@gmail.com> | 2015-09-09 14:55:14 -0700 |
commit | 0531b38367eb23b787276b9b6ef1f6992b4b3bc2 (patch) | |
tree | 85e4f6c4092f0cc52e53372bb7eea0e3ea4b1e43 /platform | |
parent | aa001f07c315d89a43ef1c894ca11af236d607a5 (diff) | |
download | qtlocation-mapboxgl-0531b38367eb23b787276b9b6ef1f6992b4b3bc2.tar.gz |
Nan 2.0
Diffstat (limited to 'platform')
-rw-r--r-- | platform/node/src/node_file_source.cpp | 49 | ||||
-rw-r--r-- | platform/node/src/node_file_source.hpp | 12 | ||||
-rw-r--r-- | platform/node/src/node_log.cpp | 35 | ||||
-rw-r--r-- | platform/node/src/node_log.hpp | 5 | ||||
-rw-r--r-- | platform/node/src/node_map.cpp | 178 | ||||
-rw-r--r-- | platform/node/src/node_map.hpp | 22 | ||||
-rw-r--r-- | platform/node/src/node_mapbox_gl_native.cpp | 71 | ||||
-rw-r--r-- | platform/node/src/node_request.cpp | 91 | ||||
-rw-r--r-- | platform/node/src/node_request.hpp | 14 |
9 files changed, 237 insertions, 240 deletions
diff --git a/platform/node/src/node_file_source.cpp b/platform/node/src/node_file_source.cpp index 204e85a126..29a4748c53 100644 --- a/platform/node/src/node_file_source.cpp +++ b/platform/node/src/node_file_source.cpp @@ -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. diff --git a/platform/node/src/node_file_source.hpp b/platform/node/src/node_file_source.hpp index f412bdee16..038765cb20 100644 --- a/platform/node/src/node_file_source.hpp +++ b/platform/node/src/node_file_source.hpp @@ -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 diff --git a/platform/node/src/node_log.cpp b/platform/node/src/node_log.cpp index 6375348070..8230bb36ce 100644 --- a/platform/node/src/node_log.cpp +++ b/platform/node/src/node_log.cpp @@ -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)); + Nan::Set(msg, Nan::New("code").ToLocalChecked(), + Nan::New<v8::Number>(message.code)); } + if (!message.text.empty()) { - msg->Set(NanNew("text"), NanNew(message.text)); + Nan::Set(msg, Nan::New("text").ToLocalChecked(), + Nan::New(message.text).ToLocalChecked()); } - 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); + 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) { diff --git a/platform/node/src/node_log.hpp b/platform/node/src/node_log.hpp index 5c0048d261..d29e4e28e0 100644 --- a/platform/node/src/node_log.hpp +++ b/platform/node/src/node_log.hpp @@ -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>; diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp index b624e32e66..0133babc04 100644 --- a/platform/node/src/node_map.cpp +++ b/platform/node/src/node_map.cpp @@ -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 (!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("cancel")) && !options->Get(NanNew("cancel"))->IsFunction()) { - return NanThrowError("Options object 'cancel' property must be a function"); + + 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 (!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("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 (Nan::Has(obj, Nan::New("bearing").ToLocalChecked()).FromJust()) { + options->bearing = Nan::Get(obj, Nan::New("bearing").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("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 = node::ObjectWrap::Unwrap<NodeMap>(args.Holder()); + auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.Holder()); - if (!nodeMap->isValid()) return NanThrowError(releasedMessage()); + if (!nodeMap->isValid()) return Nan::ThrowError(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 = node::ObjectWrap::Unwrap<NodeMap>(args.Holder()); + auto nodeMap = Nan::ObjectWrap::Unwrap<NodeMap>(info.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) { diff --git a/platform/node/src/node_map.hpp b/platform/node/src/node_map.hpp index 2c87900d4d..90edf44f73 100644 --- a/platform/node/src/node_map.hpp +++ b/platform/node/src/node_map.hpp @@ -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; diff --git a/platform/node/src/node_mapbox_gl_native.cpp b/platform/node/src/node_mapbox_gl_native.cpp index 14a0c9ad26..b631b32c54 100644 --- a/platform/node/src/node_mapbox_gl_native.cpp +++ b/platform/node/src/node_mapbox_gl_native.cpp @@ -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); - - // 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"))); - - mbgl::Log::setObserver(std::make_unique<node_mbgl::NodeLogObserver>(exports)); + v8::Local<v8::Object> resource = Nan::New<v8::Object>(); + + Nan::Set(resource, + Nan::New("Unknown").ToLocalChecked(), + Nan::New(mbgl::Resource::Unknown)); + + 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) diff --git a/platform/node/src/node_request.cpp b/platform/node/src/node_request.cpp index ea9fc4d732..09d7bf7984 100644 --- a/platform/node/src/node_request.cpp +++ b/platform/node/src/node_request.cpp @@ -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(); } //////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/platform/node/src/node_request.hpp b/platform/node/src/node_request.hpp index a690904ef2..35bb8e5205 100644 --- a/platform/node/src/node_request.hpp +++ b/platform/node/src/node_request.hpp @@ -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(); |