[node] move from node_mbgl to mbgl namespace

10 files changed, 74 insertions, 70 deletions

diff --git a/platform/node/src/node_file_source.cpp b/platform/node/src/node_file_source.cpp
index 5a5a34f0ce..965e49bc66 100644
--- a/platform/node/src/node_file_source.cpp
+++ b/platform/node/src/node_file_source.cpp
@@ -4,11 +4,11 @@
 
 #include <mbgl/storage/request.hpp>
 
-namespace node_mbgl {
+namespace mbgl {
 
 struct NodeFileSource::Action {
     const enum : bool { Add, Cancel } type;
-    mbgl::Resource const resource;
+    Resource const resource;
 };
 
 NodeFileSource::NodeFileSource(v8::Local<v8::Object> options_) :
@@ -33,8 +33,8 @@ NodeFileSource::~NodeFileSource() {
     options.Reset();
 }
 
-mbgl::Request* NodeFileSource::request(const mbgl::Resource& resource, uv_loop_t* loop, Callback callback) {
-    auto req = new mbgl::Request(resource, loop, std::move(callback));
+Request* NodeFileSource::request(const Resource& resource, uv_loop_t* loop, Callback callback) {
+    auto req = new Request(resource, loop, std::move(callback));
 
     std::lock_guard<std::mutex> lock(observersMutex);
 
@@ -48,7 +48,7 @@ mbgl::Request* NodeFileSource::request(const mbgl::Resource& resource, uv_loop_t
     return req;
 }
 
-void NodeFileSource::cancel(mbgl::Request* req) {
+void NodeFileSource::cancel(Request* req) {
     req->cancel();
 
     std::lock_guard<std::mutex> lock(observersMutex);
@@ -67,7 +67,7 @@ void NodeFileSource::cancel(mbgl::Request* req) {
     req->destruct();
 }
 
-void NodeFileSource::processAdd(const mbgl::Resource& resource) {
+void NodeFileSource::processAdd(const Resource& resource) {
     Nan::HandleScope scope;
 
     // Make sure the loop stays alive as long as request is pending.
@@ -85,7 +85,7 @@ void NodeFileSource::processAdd(const mbgl::Resource& resource) {
     Nan::MakeCallback(Nan::New(options), "request", 2, argv);
 }
 
-void NodeFileSource::processCancel(const mbgl::Resource& resource) {
+void NodeFileSource::processCancel(const Resource& resource) {
     Nan::HandleScope scope;
 
     auto it = pending.find(resource);
@@ -112,7 +112,7 @@ void NodeFileSource::processCancel(const mbgl::Resource& resource) {
     }
 }
 
-void NodeFileSource::notify(const mbgl::Resource& resource, const std::shared_ptr<const mbgl::Response>& response) {
+void NodeFileSource::notify(const Resource& resource, const std::shared_ptr<const Response>& response) {
     // First, remove the request, since it might be destructed at any point now.
     auto it = pending.find(resource);
     if (it != pending.end()) {
diff --git a/platform/node/src/node_file_source.hpp b/platform/node/src/node_file_source.hpp
index 0ebdb541c9..5929b96d02 100644
--- a/platform/node/src/node_file_source.hpp
+++ b/platform/node/src/node_file_source.hpp
@@ -13,40 +13,40 @@
 #include <mutex>
 #include <unordered_map>
 
-namespace node_mbgl {
+namespace mbgl {
 
 namespace util { template <typename T> class AsyncQueue; }
 
-class NodeFileSource : public mbgl::FileSource {
+class NodeFileSource : public FileSource {
 public:
     NodeFileSource(v8::Local<v8::Object>);
     ~NodeFileSource();
 
-    mbgl::Request* request(const mbgl::Resource&, uv_loop_t*, Callback);
-    void cancel(mbgl::Request*);
+    Request* request(const Resource&, uv_loop_t*, Callback);
+    void cancel(Request*);
 
     // visiblity?
-    void notify(const mbgl::Resource&, const std::shared_ptr<const mbgl::Response>&);
+    void notify(const Resource&, const std::shared_ptr<const Response>&);
 
 private:
     struct Action;
     using Queue = util::AsyncQueue<Action>;
 
-    void processAdd(const mbgl::Resource&);
-    void processCancel(const mbgl::Resource&);
+    void processAdd(const Resource&);
+    void processCancel(const Resource&);
 
     Nan::Persistent<v8::Object> options;
 
 private:
-    std::unordered_map<mbgl::Resource, Nan::Persistent<v8::Object>, mbgl::Resource::Hash> pending;
+    std::unordered_map<Resource, Nan::Persistent<v8::Object>, 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
-    // because the list is also accessed by a thread from the mbgl::Map
+    // because the list is also accessed by a thread from the Map
     // object and from the main thread when notifying requests of
     // completion. Concurrent access is specially needed when
     // canceling a request to avoid a deadlock (see #129).
-    std::unordered_map<mbgl::Resource, mbgl::Request*, mbgl::Resource::Hash> observers;
+    std::unordered_map<Resource, Request*, Resource::Hash> observers;
     std::mutex observersMutex;
 
     Queue *queue = nullptr;
diff --git a/platform/node/src/node_log.cpp b/platform/node/src/node_log.cpp
index 8230bb36ce..ec1d8b9ccc 100644
--- a/platform/node/src/node_log.cpp
+++ b/platform/node/src/node_log.cpp
@@ -1,15 +1,15 @@
 #include "node_log.hpp"
 #include "util/async_queue.hpp"
 
-namespace node_mbgl {
+namespace mbgl {
 
 struct NodeLogObserver::LogMessage {
-    mbgl::EventSeverity severity;
-    mbgl::Event event;
+    EventSeverity severity;
+    Event event;
     int64_t code;
     std::string text;
 
-    LogMessage(mbgl::EventSeverity severity_, mbgl::Event event_, int64_t code_, std::string text_)
+    LogMessage(EventSeverity severity_, Event event_, int64_t code_, std::string text_)
         : severity(severity_),
         event(event_),
         code(code_),
@@ -23,10 +23,10 @@ NodeLogObserver::NodeLogObserver(v8::Local<v8::Object> target)
           auto msg = Nan::New<v8::Object>();
 
           Nan::Set(msg, Nan::New("class").ToLocalChecked(),
-              Nan::New(mbgl::EventClass(message.event).c_str()).ToLocalChecked());
+              Nan::New(EventClass(message.event).c_str()).ToLocalChecked());
 
           Nan::Set(msg, Nan::New("severity").ToLocalChecked(),
-              Nan::New(mbgl::EventSeverityClass(message.severity).c_str()).ToLocalChecked());
+              Nan::New(EventSeverityClass(message.severity).c_str()).ToLocalChecked());
 
           if (message.code != -1) {
               Nan::Set(msg, Nan::New("code").ToLocalChecked(),
@@ -55,7 +55,7 @@ NodeLogObserver::~NodeLogObserver() {
     module.Reset();
 }
 
-bool NodeLogObserver::onRecord(mbgl::EventSeverity severity, mbgl::Event event, int64_t code, const std::string &text) {
+bool NodeLogObserver::onRecord(EventSeverity severity, Event event, int64_t code, const std::string &text) {
     queue->send({ severity, event, code, text });
     return true;
 }
diff --git a/platform/node/src/node_log.hpp b/platform/node/src/node_log.hpp
index 8798016d7a..207412f6ef 100644
--- a/platform/node/src/node_log.hpp
+++ b/platform/node/src/node_log.hpp
@@ -9,17 +9,17 @@
 #include <nan.h>
 #pragma GCC diagnostic pop
 
-namespace node_mbgl {
+namespace mbgl {
 
 namespace util { template <typename T> class AsyncQueue; }
 
-class NodeLogObserver : public mbgl::Log::Observer {
+class NodeLogObserver : public Log::Observer {
 public:
     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;
+    virtual bool onRecord(EventSeverity severity, Event event, int64_t code, const std::string &msg) override;
 
 private:
     Nan::Persistent<v8::Object> module;
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index 6e9230287e..6e65e4a5bd 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -12,7 +12,7 @@
 #define UV_ASYNC_PARAMS(handle) uv_async_t *handle
 #endif
 
-namespace node_mbgl {
+namespace mbgl {
 
 struct NodeMap::RenderOptions {
     double zoom = 0;
@@ -30,8 +30,8 @@ struct NodeMap::RenderOptions {
 
 Nan::Persistent<v8::Function> NodeMap::constructor;
 
-static std::shared_ptr<mbgl::HeadlessDisplay> sharedDisplay() {
-    static auto display = std::make_shared<mbgl::HeadlessDisplay>();
+static std::shared_ptr<HeadlessDisplay> sharedDisplay() {
+    static auto display = std::make_shared<HeadlessDisplay>();
     return display;
 }
 
@@ -281,7 +281,7 @@ NAN_METHOD(NodeMap::Render) {
 
     try {
         nodeMap->startRender(std::move(options));
-    } catch (mbgl::util::Exception &ex) {
+    } catch (util::Exception &ex) {
         return Nan::ThrowError(ex.what());
     }
 
@@ -290,13 +290,13 @@ NAN_METHOD(NodeMap::Render) {
 
 void NodeMap::startRender(std::unique_ptr<NodeMap::RenderOptions> options) {
     view.resize(options->width, options->height);
-    map->update(mbgl::Update::Dimensions);
+    map->update(Update::Dimensions);
     map->setClasses(options->classes);
-    map->setLatLngZoom(mbgl::LatLng(options->latitude, options->longitude), options->zoom);
+    map->setLatLngZoom(LatLng(options->latitude, options->longitude), options->zoom);
     map->setBearing(options->bearing);
     map->setPitch(options->pitch);
 
-    map->renderStill([this](const std::exception_ptr eptr, std::unique_ptr<const mbgl::StillImage> result) {
+    map->renderStill([this](const std::exception_ptr eptr, std::unique_ptr<const StillImage> result) {
         if (eptr) {
             error = std::move(eptr);
             uv_async_send(async);
@@ -356,13 +356,13 @@ void NodeMap::renderFinished() {
     } else if (img) {
         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),
+            size_t(img->width) * size_t(img->height) * sizeof(StillImage::Pixel),
 
             // Retain the StillImage object until the buffer is deleted.
             [](char *, void *hint) {
-                delete reinterpret_cast<const mbgl::StillImage *>(hint);
+                delete reinterpret_cast<const StillImage *>(hint);
             },
-            const_cast<mbgl::StillImage *>(img.get())
+            const_cast<StillImage *>(img.get())
         ).ToLocalChecked();
         img.release();
 
@@ -399,7 +399,7 @@ NAN_METHOD(NodeMap::Release) {
 }
 
 void NodeMap::release() {
-    if (!isValid()) throw mbgl::util::Exception(releasedMessage());
+    if (!isValid()) throw util::Exception(releasedMessage());
 
     valid = false;
 
@@ -428,7 +428,7 @@ NodeMap::NodeMap(v8::Local<v8::Object> options) :
         return Nan::Has(options, Nan::New("ratio").ToLocalChecked()).FromJust() ? Nan::Get(options, Nan::New("ratio").ToLocalChecked()).ToLocalChecked()->NumberValue() : 1.0;
     }()),
     fs(options),
-    map(std::make_unique<mbgl::Map>(view, fs, mbgl::MapMode::Still)),
+    map(std::make_unique<Map>(view, fs, MapMode::Still)),
     async(new uv_async_t) {
 
     async->data = this;
diff --git a/platform/node/src/node_map.hpp b/platform/node/src/node_map.hpp
index 91cada17d1..0c4ef1d80b 100644
--- a/platform/node/src/node_map.hpp
+++ b/platform/node/src/node_map.hpp
@@ -14,7 +14,7 @@
 
 #include <queue>
 
-namespace node_mbgl {
+namespace mbgl {
 
 class NodeMap : public Nan::ObjectWrap {
 public:
@@ -43,12 +43,12 @@ public:
     NodeMap(v8::Local<v8::Object>);
     ~NodeMap();
 
-    mbgl::HeadlessView view;
+    HeadlessView view;
     NodeFileSource fs;
-    std::unique_ptr<mbgl::Map> map;
+    std::unique_ptr<Map> map;
 
     std::exception_ptr error;
-    std::unique_ptr<const mbgl::StillImage> image;
+    std::unique_ptr<const StillImage> image;
     std::unique_ptr<Nan::Callback> callback;
 
     // Async for delivering the notifications of render completion.
diff --git a/platform/node/src/node_mapbox_gl_native.cpp b/platform/node/src/node_mapbox_gl_native.cpp
index 5bf03594e5..24a2436839 100644
--- a/platform/node/src/node_mapbox_gl_native.cpp
+++ b/platform/node/src/node_mapbox_gl_native.cpp
@@ -10,40 +10,42 @@
 #include "node_log.hpp"
 #include "node_request.hpp"
 
+namespace mbgl {
+
 NAN_MODULE_INIT(RegisterModule) {
-    node_mbgl::NodeMap::Init(target);
-    node_mbgl::NodeRequest::Init(target);
+    NodeMap::Init(target);
+    NodeRequest::Init(target);
 
     // Exports Resource constants.
     v8::Local<v8::Object> resource = Nan::New<v8::Object>();
 
     Nan::Set(resource,
         Nan::New("Unknown").ToLocalChecked(),
-        Nan::New(mbgl::Resource::Unknown));
+        Nan::New(Resource::Unknown));
 
     Nan::Set(resource,
         Nan::New("Style").ToLocalChecked(),
-        Nan::New(mbgl::Resource::Style));
+        Nan::New(Resource::Style));
 
     Nan::Set(resource,
         Nan::New("Source").ToLocalChecked(),
-        Nan::New(mbgl::Resource::Source));
+        Nan::New(Resource::Source));
 
     Nan::Set(resource,
         Nan::New("Tile").ToLocalChecked(),
-        Nan::New(mbgl::Resource::Tile));
+        Nan::New(Resource::Tile));
 
     Nan::Set(resource,
         Nan::New("Glyphs").ToLocalChecked(),
-        Nan::New(mbgl::Resource::Glyphs));
+        Nan::New(Resource::Glyphs));
 
     Nan::Set(resource,
         Nan::New("SpriteImage").ToLocalChecked(),
-        Nan::New(mbgl::Resource::SpriteImage));
+        Nan::New(Resource::SpriteImage));
 
     Nan::Set(resource,
         Nan::New("SpriteJSON").ToLocalChecked(),
-        Nan::New(mbgl::Resource::SpriteJSON));
+        Nan::New(Resource::SpriteJSON));
 
     Nan::Set(target,
         Nan::New("Resource").ToLocalChecked(),
@@ -60,7 +62,9 @@ NAN_MODULE_INIT(RegisterModule) {
     Nan::SetPrototype(target,
         Nan::Get(EventEmitter, Nan::New("prototype").ToLocalChecked()).ToLocalChecked());
 
-    mbgl::Log::setObserver(std::make_unique<node_mbgl::NodeLogObserver>(target->ToObject()));
+    Log::setObserver(std::make_unique<NodeLogObserver>(target->ToObject()));
 }
 
 NODE_MODULE(mapbox_gl_native, RegisterModule)
+
+}
diff --git a/platform/node/src/node_request.cpp b/platform/node/src/node_request.cpp
index 14af3ad5eb..ee00d46216 100644
--- a/platform/node/src/node_request.cpp
+++ b/platform/node/src/node_request.cpp
@@ -6,7 +6,7 @@
 #include <cmath>
 #include <iostream>
 
-namespace node_mbgl {
+namespace mbgl {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // Static Node Methods
@@ -30,19 +30,19 @@ NAN_METHOD(NodeRequest::New) {
     }
 
     auto source = reinterpret_cast<NodeFileSource*>(info[0].As<v8::External>()->Value());
-    auto resource = reinterpret_cast<mbgl::Resource*>(info[1].As<v8::External>()->Value());
+    auto resource = reinterpret_cast<Resource*>(info[1].As<v8::External>()->Value());
     auto req = new NodeRequest(source, *resource);
     req->Wrap(info.This());
 
     info.GetReturnValue().Set(info.This());
 }
 
-v8::Handle<v8::Object> NodeRequest::Create(NodeFileSource* source, const mbgl::Resource& resource) {
+v8::Handle<v8::Object> NodeRequest::Create(NodeFileSource* source, const Resource& resource) {
     Nan::EscapableHandleScope scope;
 
     v8::Local<v8::Value> argv[] = {
         Nan::New<v8::External>(const_cast<NodeFileSource*>(source)),
-        Nan::New<v8::External>(const_cast<mbgl::Resource*>(&resource))
+        Nan::New<v8::External>(const_cast<Resource*>(&resource))
     };
     auto instance = Nan::New(constructor)->NewInstance(2, argv);
 
@@ -64,16 +64,16 @@ NAN_METHOD(NodeRequest::Respond) {
     auto resource = std::move(nodeRequest->resource);
 
     if (info.Length() < 1) {
-        auto response = std::make_shared<mbgl::Response>();
-        using Error = mbgl::Response::Error;
+        auto response = std::make_shared<Response>();
+        using Error = Response::Error;
         response->error = std::make_unique<Error>(Error::Reason::NotFound);
         source->notify(*resource, response);
     } else if (info[0]->BooleanValue()) {
-        auto response = std::make_shared<mbgl::Response>();
+        auto response = std::make_shared<Response>();
 
         // Store the error string.
         const Nan::Utf8String message { info[0]->ToString() };
-        using Error = mbgl::Response::Error;
+        using Error = Response::Error;
         response->error = std::make_unique<Error>(
             Error::Reason::Other, std::string{ *message, size_t(message.length()) });
 
@@ -81,7 +81,7 @@ NAN_METHOD(NodeRequest::Respond) {
     } 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 response = std::make_shared<Response>();
         auto res = info[1]->ToObject();
 
         if (Nan::Has(res, Nan::New("modified").ToLocalChecked()).FromJust()) {
@@ -128,9 +128,9 @@ NAN_METHOD(NodeRequest::Respond) {
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // Instance
 
-NodeRequest::NodeRequest(NodeFileSource* source_, const mbgl::Resource& resource_)
+NodeRequest::NodeRequest(NodeFileSource* source_, const Resource& resource_)
     : source(source_),
-    resource(std::make_unique<mbgl::Resource>(resource_)) {}
+    resource(std::make_unique<Resource>(resource_)) {}
 
 NodeRequest::~NodeRequest() {
 }
diff --git a/platform/node/src/node_request.hpp b/platform/node/src/node_request.hpp
index 8e01c544eb..d1eea716f2 100644
--- a/platform/node/src/node_request.hpp
+++ b/platform/node/src/node_request.hpp
@@ -11,7 +11,7 @@
 
 #include <memory>
 
-namespace node_mbgl {
+namespace mbgl {
 
 class NodeFileSource;
 
@@ -22,17 +22,17 @@ public:
     static NAN_METHOD(New);
     static NAN_METHOD(Respond);
 
-    static v8::Handle<v8::Object> Create(NodeFileSource*, const mbgl::Resource&);
+    static v8::Handle<v8::Object> Create(NodeFileSource*, const Resource&);
     static Nan::Persistent<v8::Function> constructor;
 
-    NodeRequest(NodeFileSource* source, const mbgl::Resource& resource);
+    NodeRequest(NodeFileSource* source, const Resource& resource);
     ~NodeRequest();
 
     void cancel();
 
 private:
     NodeFileSource* source;
-    std::unique_ptr<mbgl::Resource> resource;
+    std::unique_ptr<Resource> resource;
 };
 
 }
diff --git a/platform/node/src/util/async_queue.hpp b/platform/node/src/util/async_queue.hpp
index b9081b3aeb..13595039e6 100644
--- a/platform/node/src/util/async_queue.hpp
+++ b/platform/node/src/util/async_queue.hpp
@@ -14,7 +14,7 @@
 #define UV_ASYNC_PARAMS(handle) uv_async_t *handle
 #endif
 
-namespace node_mbgl {
+namespace mbgl {
 namespace util {
 
 template <typename T>