Merge remote-tracking branch 'origin/master' into new-labelling

Conflicts:
	src/mbgl/map/source.cpp
	src/mbgl/map/source.hpp
	src/mbgl/map/tile_data.cpp
	src/mbgl/map/tile_parser.cpp
	src/mbgl/map/vector_tile_data.cpp
	src/mbgl/renderer/painter.cpp
	src/mbgl/renderer/symbol_bucket.cpp
	src/mbgl/text/glyph.hpp
	src/mbgl/text/glyph_store.cpp
	src/mbgl/text/placement.cpp
	test/suite

3 files changed, 103 insertions, 3 deletions

diff --git a/test/miscellaneous/bilinear.cpp b/test/miscellaneous/bilinear.cpp
index 9808e20fef..bdfb9d9117 100644
--- a/test/miscellaneous/bilinear.cpp
+++ b/test/miscellaneous/bilinear.cpp
@@ -3,7 +3,6 @@
 #include <mbgl/util/scaling.hpp>
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/io.hpp>
-#include <mbgl/util/std.hpp>
 
 #include <algorithm>
 #include <cstring>
@@ -24,7 +23,7 @@ TEST(Bilinear, Scaling) {
     const uint32_t *srcData = reinterpret_cast<const uint32_t *>(src + 8);
     const vec2<uint32_t> srcSize { width, height };
     const vec2<uint32_t> dstSize { 128, 128 };
-    auto dst = util::make_unique<uint32_t[]>(dstSize.x * dstSize.y);
+    auto dst = std::make_unique<uint32_t[]>(dstSize.x * dstSize.y);
     uint32_t *dstData = dst.get();
     std::fill(dstData, dstData + dstSize.x * dstSize.y, 0xFFFF00FF);
 
diff --git a/test/miscellaneous/clip_ids.cpp b/test/miscellaneous/clip_ids.cpp
index e168ab5e01..4ecd1797e6 100644
--- a/test/miscellaneous/clip_ids.cpp
+++ b/test/miscellaneous/clip_ids.cpp
@@ -5,7 +5,6 @@
 
 #include <mbgl/util/clip_id.hpp>
 #include <mbgl/map/tile.hpp>
-#include <mbgl/util/std.hpp>
 
 using namespace mbgl;
 
diff --git a/test/miscellaneous/thread.cpp b/test/miscellaneous/thread.cpp
new file mode 100644
index 0000000000..b0dd2210e9
--- /dev/null
+++ b/test/miscellaneous/thread.cpp
@@ -0,0 +1,102 @@
+#include <mbgl/util/thread.hpp>
+#include <mbgl/util/run_loop.hpp>
+
+#include "../fixtures/util.hpp"
+
+using namespace mbgl::util;
+
+class TestObject {
+public:
+    TestObject(uv_loop_t*, std::thread::id otherTid)
+        : tid(std::this_thread::get_id()) {
+        EXPECT_NE(tid, otherTid);
+    }
+
+    void fn1(int val) {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        EXPECT_EQ(val, 1);
+    }
+
+    int fn2() {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        return 1;
+    }
+
+    void transferIn(std::unique_ptr<int> val) {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        EXPECT_EQ(*val, 1);
+    }
+
+    std::unique_ptr<int> transferOut() {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        return std::make_unique<int>(1);
+    }
+
+    std::unique_ptr<int> transferInOut(std::unique_ptr<int> val) {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        EXPECT_EQ(*val, 1);
+        return std::move(val);
+    }
+
+    void transferInShared(std::shared_ptr<int> val) {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        EXPECT_EQ(*val, 1);
+    }
+
+    std::shared_ptr<int> transferOutShared() {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        return std::make_shared<int>(1);
+    }
+
+    std::string transferString(const std::string& string) {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        EXPECT_EQ(string, "test");
+        return string;
+    }
+
+    const std::thread::id tid;
+};
+
+TEST(Thread, invoke) {
+    const std::thread::id tid = std::this_thread::get_id();
+
+    RunLoop loop(uv_default_loop());
+
+    loop.invoke([&] {
+        EXPECT_EQ(tid, std::this_thread::get_id());
+        Thread<TestObject> thread("Test", ThreadPriority::Regular, tid);
+
+        thread.invoke(&TestObject::fn1, 1);
+        thread.invokeWithResult<int>(&TestObject::fn2, [&] (int result) {
+            EXPECT_EQ(tid, std::this_thread::get_id());
+            EXPECT_EQ(result, 1);
+        });
+
+        thread.invoke(&TestObject::transferIn, std::make_unique<int>(1));
+        thread.invokeWithResult<std::unique_ptr<int>>(&TestObject::transferOut, [&] (std::unique_ptr<int> result) {
+            EXPECT_EQ(tid, std::this_thread::get_id());
+            EXPECT_EQ(*result, 1);
+        });
+
+        thread.invokeWithResult<std::unique_ptr<int>>(&TestObject::transferInOut, [&] (std::unique_ptr<int> result) {
+            EXPECT_EQ(tid, std::this_thread::get_id());
+            EXPECT_EQ(*result, 1);
+        }, std::make_unique<int>(1));
+
+        thread.invoke(&TestObject::transferInShared, std::make_shared<int>(1));
+        thread.invokeWithResult<std::shared_ptr<int>>(&TestObject::transferOutShared, [&] (std::shared_ptr<int> result) {
+            EXPECT_EQ(tid, std::this_thread::get_id());
+            EXPECT_EQ(*result, 1);
+        });
+
+        std::string test("test");
+        thread.invokeWithResult<std::string>(&TestObject::transferString, [&] (std::string result){
+            EXPECT_EQ(tid, std::this_thread::get_id());
+            EXPECT_EQ(result, "test");
+            loop.stop();
+        }, test);
+        test.clear();
+    });
+
+    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
+}