Prefer stdlib to libuv (fixes #688)

8 files changed, 49 insertions, 49 deletions

diff --git a/src/map/map.cpp b/src/map/map.cpp
index a33200fe0b..822a98d63f 100644
--- a/src/map/map.cpp
+++ b/src/map/map.cpp
@@ -89,7 +89,7 @@ Map::Map(View& view_, FileSource& fileSource_)
     : loop(util::make_unique<uv::loop>()),
       view(view_),
 #ifndef NDEBUG
-      mainThread(uv_thread_self()),
+      mainThread(std::this_thread::get_id()),
 #endif
       transform(view_),
       fileSource(fileSource_),
@@ -129,7 +129,7 @@ uv::worker &Map::getWorker() {
 }
 
 void Map::start() {
-    assert(uv_thread_self() == mainThread);
+    assert(std::this_thread::get_id() == mainThread);
     assert(!async);
 
     // When starting map rendering in another thread, we perform async/continuously
@@ -141,7 +141,7 @@ void Map::start() {
 
     // Setup async notifications
     asyncTerminate = util::make_unique<uv::async>(**loop, [this]() {
-        assert(uv_thread_self() == mapThread);
+        assert(std::this_thread::get_id() == mapThread);
 
         // Remove all of these to make sure they are destructed in the correct thread.
         glyphStore.reset();
@@ -156,7 +156,7 @@ void Map::start() {
     });
 
     asyncRender = util::make_unique<uv::async>(**loop, [this]() {
-        assert(uv_thread_self() == mapThread);
+        assert(std::this_thread::get_id() == mapThread);
 
         if (state.hasSize()) {
             if (isRendered.test_and_set() == false) {
@@ -178,9 +178,9 @@ void Map::start() {
         painter.cleanup();
     });
 
-    thread = util::make_unique<uv::thread>([this]() {
+    thread = std::thread([this]() {
 #ifndef NDEBUG
-        mapThread = uv_thread_self();
+        mapThread = std::this_thread::get_id();
 #endif
 
 #ifdef __APPLE__
@@ -190,7 +190,7 @@ void Map::start() {
         run();
 
 #ifndef NDEBUG
-        mapThread = -1;
+        mapThread = std::thread::id();
 #endif
 
         // Make sure that the stop() function knows when to stop invoking the callback function.
@@ -200,7 +200,7 @@ void Map::start() {
 }
 
 void Map::stop(stop_callback cb, void *data) {
-    assert(uv_thread_self() == mainThread);
+    assert(std::this_thread::get_id() == mainThread);
     assert(mainThread != mapThread);
     assert(async);
 
@@ -220,7 +220,7 @@ void Map::stop(stop_callback cb, void *data) {
 
     // If a callback function was provided, this should return immediately because the thread has
     // already finished executing.
-    thread->join();
+    thread.join();
 
     async = false;
 }
@@ -231,7 +231,7 @@ void Map::run() {
         mapThread = mainThread;
     }
 #endif
-    assert(uv_thread_self() == mapThread);
+    assert(std::this_thread::get_id() == mapThread);
 
     setup();
     prepare();
@@ -245,7 +245,7 @@ void Map::run() {
     if (!async) {
         render();
 #ifndef NDEBUG
-        mapThread = -1;
+        mapThread = std::thread::id();
 #endif
     }
 }
@@ -294,7 +294,7 @@ void Map::setReachability(bool reachable) {
 #pragma mark - Setup
 
 void Map::setup() {
-    assert(uv_thread_self() == mapThread);
+    assert(std::this_thread::get_id() == mapThread);
     view.make_active();
     painter.setup();
     view.make_inactive();
@@ -536,7 +536,7 @@ void Map::setDefaultTransitionDuration(uint64_t milliseconds) {
 }
 
 void Map::updateSources() {
-    assert(uv_thread_self() == mapThread);
+    assert(std::this_thread::get_id() == mapThread);
 
     // First, disable all existing sources.
     for (const auto& source : activeSources) {
diff --git a/src/storage/base_request.cpp b/src/storage/base_request.cpp
index 9819dc89f1..5ce206996c 100644
--- a/src/storage/base_request.cpp
+++ b/src/storage/base_request.cpp
@@ -19,13 +19,13 @@ void invoke(const std::forward_list<std::unique_ptr<Callback>> &list, Args&& ...
     }
 }
 
-BaseRequest::BaseRequest(const std::string &path_) : thread_id(uv_thread_self()), path(path_) {
+BaseRequest::BaseRequest(const std::string &path_) : thread_id(std::this_thread::get_id()), path(path_) {
 }
 
 // A base request can only be "canceled" by destroying the object. In that case, we'll have to
 // notify all cancel callbacks.
 BaseRequest::~BaseRequest() {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     notify();
 }
 
@@ -34,7 +34,7 @@ void BaseRequest::retryImmediately() {
 }
 
 void BaseRequest::notify() {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
 
     // The parameter exists solely so that any calls to ->remove()
     // are not going to cause deallocation of this object while this call is in progress.
@@ -55,7 +55,7 @@ void BaseRequest::notify() {
 }
 
 Callback *BaseRequest::add(Callback &&callback, const util::ptr<BaseRequest> &request) {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     assert(this == request.get());
 
     if (response) {
@@ -75,7 +75,7 @@ Callback *BaseRequest::add(Callback &&callback, const util::ptr<BaseRequest> &re
 }
 
 void BaseRequest::remove(Callback *callback) {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     callbacks.remove_if([=](const std::unique_ptr<Callback> &cb) {
         return cb.get() == callback;
     });
diff --git a/src/storage/file_request.cpp b/src/storage/file_request.cpp
index 33398d5ef1..9f74c7b414 100644
--- a/src/storage/file_request.cpp
+++ b/src/storage/file_request.cpp
@@ -15,7 +15,7 @@ FileRequest::FileRequest(const std::string &path_, uv_loop_t *loop)
 }
 
 void FileRequest::cancel() {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
 
     if (ptr) {
         ptr->cancel();
@@ -30,7 +30,7 @@ void FileRequest::cancel() {
 }
 
 FileRequest::~FileRequest() {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     cancel();
 }
 
diff --git a/src/storage/file_request_baton.cpp b/src/storage/file_request_baton.cpp
index 75ea95df41..0a9c5f6f55 100644
--- a/src/storage/file_request_baton.cpp
+++ b/src/storage/file_request_baton.cpp
@@ -8,7 +8,7 @@
 namespace mbgl {
 
 FileRequestBaton::FileRequestBaton(FileRequest *request_, const std::string &path, uv_loop_t *loop)
-    : thread_id(uv_thread_self()), request(request_) {
+    : thread_id(std::this_thread::get_id()), request(request_) {
     req.data = this;
     uv_fs_open(loop, &req, path.c_str(), O_RDONLY, S_IRUSR, file_opened);
 }
@@ -27,7 +27,7 @@ void FileRequestBaton::cancel() {
 
 void FileRequestBaton::notify_error(uv_fs_t *req) {
     FileRequestBaton *ptr = (FileRequestBaton *)req->data;
-    assert(ptr->thread_id == uv_thread_self());
+    assert(ptr->thread_id == std::this_thread::get_id());
 
     if (ptr->request && req->result < 0 && !ptr->canceled && req->result != UV_ECANCELED) {
         ptr->request->response = util::make_unique<Response>();
@@ -43,7 +43,7 @@ void FileRequestBaton::notify_error(uv_fs_t *req) {
 
 void FileRequestBaton::file_opened(uv_fs_t *req) {
     FileRequestBaton *ptr = (FileRequestBaton *)req->data;
-    assert(ptr->thread_id == uv_thread_self());
+    assert(ptr->thread_id == std::this_thread::get_id());
 
     if (req->result < 0) {
         // Opening failed or was canceled. There isn't much left we can do.
@@ -68,7 +68,7 @@ void FileRequestBaton::file_opened(uv_fs_t *req) {
 
 void FileRequestBaton::file_stated(uv_fs_t *req) {
     FileRequestBaton *ptr = (FileRequestBaton *)req->data;
-    assert(ptr->thread_id == uv_thread_self());
+    assert(ptr->thread_id == std::this_thread::get_id());
 
     if (req->result != 0 || ptr->canceled || !ptr->request) {
         // Stating failed or was canceled. We already have an open file handle
@@ -115,7 +115,7 @@ void FileRequestBaton::file_stated(uv_fs_t *req) {
 
 void FileRequestBaton::file_read(uv_fs_t *req) {
     FileRequestBaton *ptr = (FileRequestBaton *)req->data;
-    assert(ptr->thread_id == uv_thread_self());
+    assert(ptr->thread_id == std::this_thread::get_id());
 
     if (req->result < 0 || ptr->canceled || !ptr->request) {
         // Stating failed or was canceled. We already have an open file handle
@@ -136,7 +136,7 @@ void FileRequestBaton::file_read(uv_fs_t *req) {
 }
 
 void FileRequestBaton::file_closed(uv_fs_t *req) {
-    assert(((FileRequestBaton *)req->data)->thread_id == uv_thread_self());
+    assert(((FileRequestBaton *)req->data)->thread_id == std::this_thread::get_id());
 
     if (req->result < 0) {
         // Closing the file failed. But there isn't anything we can do.
@@ -147,7 +147,7 @@ void FileRequestBaton::file_closed(uv_fs_t *req) {
 
 void FileRequestBaton::cleanup(uv_fs_t *req) {
     FileRequestBaton *ptr = (FileRequestBaton *)req->data;
-    assert(ptr->thread_id == uv_thread_self());
+    assert(ptr->thread_id == std::this_thread::get_id());
 
     if (ptr->request) {
         ptr->request->ptr = nullptr;
diff --git a/src/storage/http_request.cpp b/src/storage/http_request.cpp
index c87a92e123..ebb9a84823 100644
--- a/src/storage/http_request.cpp
+++ b/src/storage/http_request.cpp
@@ -21,7 +21,7 @@ struct CacheRequestBaton {
 };
 
 HTTPRequest::HTTPRequest(ResourceType type_, const std::string &path_, uv_loop_t *loop_, util::ptr<SQLiteStore> store_)
-    : BaseRequest(path_), thread_id(uv_thread_self()), loop(loop_), store(store_), type(type_) {
+    : BaseRequest(path_), thread_id(std::this_thread::get_id()), loop(loop_), store(store_), type(type_) {
     if (store) {
         startCacheRequest();
     } else {
@@ -30,7 +30,7 @@ HTTPRequest::HTTPRequest(ResourceType type_, const std::string &path_, uv_loop_t
 }
 
 void HTTPRequest::startCacheRequest() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
 
     cache_baton = new CacheRequestBaton;
     cache_baton->request = this;
@@ -47,7 +47,7 @@ void HTTPRequest::startCacheRequest() {
 }
 
 void HTTPRequest::handleCacheResponse(std::unique_ptr<Response> &&res) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
 
     if (res) {
         // This entry was stored in the cache. Now determine if we need to revalidate.
@@ -68,7 +68,7 @@ void HTTPRequest::handleCacheResponse(std::unique_ptr<Response> &&res) {
 }
 
 void HTTPRequest::startHTTPRequest(std::unique_ptr<Response> &&res) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     assert(!http_baton);
 
     http_baton = std::make_shared<HTTPRequestBaton>(path);
@@ -104,7 +104,7 @@ void HTTPRequest::startHTTPRequest(std::unique_ptr<Response> &&res) {
 
 
 void HTTPRequest::handleHTTPResponse(HTTPResponseType responseType, std::unique_ptr<Response> &&res) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     assert(!http_baton);
     assert(!response);
 
@@ -192,7 +192,7 @@ void HTTPRequest::handleHTTPResponse(HTTPResponseType responseType, std::unique_
 using RetryBaton = std::pair<HTTPRequest *, std::unique_ptr<Response>>;
 
 void HTTPRequest::retryHTTPRequest(std::unique_ptr<Response> &&res, uint64_t timeout) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     assert(!backoff_timer);
     backoff_timer = new uv_timer_t();
     uv_timer_init(loop, backoff_timer);
@@ -212,7 +212,7 @@ void HTTPRequest::retryHTTPRequest(std::unique_ptr<Response> &&res, uint64_t tim
 }
 
 void HTTPRequest::removeHTTPBaton() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (http_baton) {
         http_baton->request = nullptr;
         HTTPRequestBaton::stop(http_baton);
@@ -221,7 +221,7 @@ void HTTPRequest::removeHTTPBaton() {
 }
 
 void HTTPRequest::removeCacheBaton() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (cache_baton) {
         // Make sre that this object doesn't accidentally get accessed when it is destructed before
         // the callback returned. They are being run in the same thread, so just setting it to
@@ -234,7 +234,7 @@ void HTTPRequest::removeCacheBaton() {
 }
 
 void HTTPRequest::removeBackoffTimer() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (backoff_timer) {
         delete static_cast<RetryBaton *>(backoff_timer->data);
         uv_timer_stop(backoff_timer);
@@ -244,7 +244,7 @@ void HTTPRequest::removeBackoffTimer() {
 }
 
 void HTTPRequest::retryImmediately() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (!cache_baton && !http_baton) {
         if (backoff_timer) {
             // Retry immediately.
@@ -261,7 +261,7 @@ void HTTPRequest::retryImmediately() {
 }
 
 void HTTPRequest::cancel() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     removeCacheBaton();
     removeHTTPBaton();
     removeBackoffTimer();
@@ -270,7 +270,7 @@ void HTTPRequest::cancel() {
 
 
 HTTPRequest::~HTTPRequest() {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     cancel();
 }
 
diff --git a/src/storage/http_request_baton.cpp b/src/storage/http_request_baton.cpp
index 02edae748f..315708f4e0 100644
--- a/src/storage/http_request_baton.cpp
+++ b/src/storage/http_request_baton.cpp
@@ -3,7 +3,7 @@
 
 namespace mbgl {
 
-HTTPRequestBaton::HTTPRequestBaton(const std::string &path_) : thread_id(uv_thread_self()), path(path_) {
+HTTPRequestBaton::HTTPRequestBaton(const std::string &path_) : thread_id(std::this_thread::get_id()), path(path_) {
 }
 
 HTTPRequestBaton::~HTTPRequestBaton() {
diff --git a/src/storage/request.cpp b/src/storage/request.cpp
index 42bf87a849..39fbd36789 100644
--- a/src/storage/request.cpp
+++ b/src/storage/request.cpp
@@ -8,15 +8,15 @@
 namespace mbgl {
 
 Request::Request(const util::ptr<BaseRequest> &base_)
-    : thread_id(uv_thread_self()), base(base_) {
+    : thread_id(std::this_thread::get_id()), base(base_) {
 }
 
 Request::~Request() {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
 }
 
 void Request::onload(CompletedCallback cb) {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     if (base) {
         Callback *callback = base->add(std::move(cb), base);
         if (callback) {
@@ -26,7 +26,7 @@ void Request::onload(CompletedCallback cb) {
 }
 
 void Request::oncancel(AbortedCallback cb) {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     if (base) {
         Callback *callback = base->add(std::move(cb), base);
         if (callback) {
@@ -36,7 +36,7 @@ void Request::oncancel(AbortedCallback cb) {
 }
 
 void Request::cancel() {
-    assert(thread_id == uv_thread_self());
+    assert(thread_id == std::this_thread::get_id());
     if (base) {
         for (Callback *callback : callbacks) {
             base->remove(callback);
diff --git a/src/storage/sqlite_store.cpp b/src/storage/sqlite_store.cpp
index bc262e386a..d382921dec 100644
--- a/src/storage/sqlite_store.cpp
+++ b/src/storage/sqlite_store.cpp
@@ -58,7 +58,7 @@ std::string unifyMapboxURLs(const std::string &url) {
 namespace mbgl {
 
 SQLiteStore::SQLiteStore(uv_loop_t *loop, const std::string &path)
-    : thread_id(uv_thread_self()),
+    : thread_id(std::this_thread::get_id()),
       db(std::make_shared<Database>(path.c_str(), ReadWrite | Create)) {
     createSchema();
     worker = new uv_worker_t;
@@ -103,7 +103,7 @@ struct GetBaton {
 };
 
 void SQLiteStore::get(const std::string &path, GetCallback callback, void *ptr) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (!db || !*db) {
         if (callback) {
             callback(nullptr, ptr);
@@ -160,7 +160,7 @@ struct PutBaton {
 };
 
 void SQLiteStore::put(const std::string &path, ResourceType type, const Response &response) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (!db) return;
 
     PutBaton *put_baton = new PutBaton;
@@ -204,7 +204,7 @@ struct ExpirationBaton {
 };
 
 void SQLiteStore::updateExpiration(const std::string &path, int64_t expires) {
-    assert(uv_thread_self() == thread_id);
+    assert(std::this_thread::get_id() == thread_id);
     if (!db || !*db) return;
 
     ExpirationBaton *expiration_baton = new ExpirationBaton;