Fix build

include/mbgl/util/run_loop.hpp

@@ -61,7 +61,7 @@ class RunLoop : private util::noncopyable {
 
     // Post the cancellable work fn(args...) to this RunLoop.
     template <class Fn, class... Args>
-    std::unique_ptr<AsyncRequest>
+    std::unique_ptr<WorkRequest>
     invokeCancellable(Fn&& fn, Args&&... args) {
         auto flag = std::make_shared<std::atomic<bool>>();
         *flag = false;
@@ -79,7 +79,7 @@ class RunLoop : private util::noncopyable {
 
     // Invoke fn(args...) on this RunLoop, then invoke callback(results...) on the current RunLoop.
     template <class Fn, class Cb, class... Args>
-    std::unique_ptr<AsyncRequest>
+    std::unique_ptr<WorkRequest>
     invokeWithCallback(Fn&& fn, Cb&& callback, Args&&... args) {
         auto flag = std::make_shared<std::atomic<bool>>();
         *flag = false;

src/mbgl/source/source.cpp

@@ -254,15 +254,15 @@ TileData::State Source::addTile(const TileID& tileID, const StyleUpdateParameter
 
         // If we don't find working tile data, we're just going to load it.
         if (type == SourceType::Raster) {
-            newTile->data = std::make_shared<RasterTileData>(new RasterTileData{
+            newTile->data = std::shared_ptr<RasterTileData>(new RasterTileData(
                 normalizedID,
                 parameters.pixelRatio,
                 info->tiles.at(0),
                 parameters.texturePool,
                 parameters.worker,
                 parameters.fileSource,
                 callback
-            }, [this](TileData* data) { tileDataDeleter.add(data); });
+            ), [this](TileData* data) { tileDataDeleter.add(data); });
         } else {
             std::unique_ptr<GeometryTileMonitor> monitor;
 

src/mbgl/tile/raster_tile_data.hpp

@@ -8,6 +8,7 @@ namespace mbgl {
 
 class FileSource;
 class AsyncRequest;
+class WorkRequest;
 class StyleLayer;
 namespace gl { class TexturePool; }
 
@@ -31,7 +32,7 @@ class RasterTileData : public TileData {
     Worker& worker;
     std::unique_ptr<AsyncRequest> req;
     std::unique_ptr<Bucket> bucket;
-    std::unique_ptr<AsyncRequest> workRequest;
+    std::unique_ptr<WorkRequest> workRequest;
 };
 
 } // namespace mbgl

src/mbgl/tile/vector_tile_data.hpp

@@ -13,6 +13,7 @@ namespace mbgl {
 
 class Style;
 class AsyncRequest;
+class WorkRequest;
 class GeometryTileMonitor;
 
 class VectorTileData : public TileData {
@@ -44,7 +45,7 @@ class VectorTileData : public TileData {
 
     std::unique_ptr<GeometryTileMonitor> monitor;
     std::unique_ptr<AsyncRequest> tileRequest;
-    std::unique_ptr<AsyncRequest> workRequest;
+    std::unique_ptr<WorkRequest> workRequest;
 
     // Contains all the Bucket objects for the tile. Buckets are render
     // objects and they get added by tile parsing operations.

src/mbgl/util/thread.hpp

@@ -39,7 +39,7 @@ class Thread {
 
     // Invoke object->fn(args...) in the runloop thread, then invoke callback(result) in the current thread.
     template <typename Fn, class Cb, class... Args>
-    std::unique_ptr<AsyncRequest>
+    std::unique_ptr<WorkRequest>
     invokeWithCallback(Fn fn, Cb&& callback, Args&&... args) {
         return loop->invokeWithCallback(bind(fn), callback, std::forward<Args>(args)...);
     }

src/mbgl/util/worker.cpp

@@ -68,7 +68,7 @@ Worker::Worker(std::size_t count) {
 
 Worker::~Worker() = default;
 
-std::unique_ptr<AsyncRequest>
+std::unique_ptr<WorkRequest>
 Worker::parseRasterTile(std::unique_ptr<RasterBucket> bucket,
                         const std::shared_ptr<const std::string> data,
                         std::function<void(RasterTileParseResult)> callback) {
@@ -77,7 +77,7 @@ Worker::parseRasterTile(std::unique_ptr<RasterBucket> bucket,
                                                 data);
 }
 
-std::unique_ptr<AsyncRequest>
+std::unique_ptr<WorkRequest>
 Worker::parseGeometryTile(TileWorker& worker,
                           std::vector<std::unique_ptr<StyleLayer>> layers,
                           std::unique_ptr<GeometryTile> tile,
@@ -88,7 +88,7 @@ Worker::parseGeometryTile(TileWorker& worker,
                                                 std::move(layers), std::move(tile), config);
 }
 
-std::unique_ptr<AsyncRequest>
+std::unique_ptr<WorkRequest>
 Worker::parsePendingGeometryTileLayers(TileWorker& worker,
                                        PlacementConfig config,
                                        std::function<void(TileParseResult)> callback) {
@@ -97,7 +97,7 @@ Worker::parsePendingGeometryTileLayers(TileWorker& worker,
                                                 callback, &worker, config);
 }
 
-std::unique_ptr<AsyncRequest>
+std::unique_ptr<WorkRequest>
 Worker::redoPlacement(TileWorker& worker,
                       const std::unordered_map<std::string, std::unique_ptr<Bucket>>& buckets,
                       PlacementConfig config,

src/mbgl/util/worker.hpp

@@ -10,7 +10,7 @@
 
 namespace mbgl {
 
-class AsyncRequest;
+class WorkRequest;
 class RasterBucket;
 class GeometryTileLoader;
 
@@ -33,7 +33,7 @@ class Worker : public mbgl::util::noncopyable {
     // bind references to itself, and if and when those lambdas execute, the references
     // will still be valid.
 
-    using Request = std::unique_ptr<AsyncRequest>;
+    using Request = std::unique_ptr<WorkRequest>;
 
     Request parseRasterTile(std::unique_ptr<RasterBucket> bucket,
                             std::shared_ptr<const std::string> data,