[core] Use std::unique_ptr for FileSource request

17 files changed, 93 insertions, 200 deletions

diff --git a/src/mbgl/annotation/annotation_tile.cpp b/src/mbgl/annotation/annotation_tile.cpp
index 4b0f2a92ec..f9ab79e4f4 100644
--- a/src/mbgl/annotation/annotation_tile.cpp
+++ b/src/mbgl/annotation/annotation_tile.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/annotation/annotation_tile.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/map/map_data.hpp>
+#include <mbgl/storage/file_source.hpp>
 
 namespace mbgl {
 
@@ -35,7 +36,7 @@ AnnotationTileMonitor::~AnnotationTileMonitor() {
     data.getAnnotationManager()->removeTileMonitor(*this);
 }
 
-Request* AnnotationTileMonitor::monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)> callback_) {
+std::unique_ptr<FileRequest> AnnotationTileMonitor::monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)> callback_) {
     callback = callback_;
     data.getAnnotationManager()->addTileMonitor(*this);
     return nullptr;
diff --git a/src/mbgl/annotation/annotation_tile.hpp b/src/mbgl/annotation/annotation_tile.hpp
index dcd843ed09..70c9f7265f 100644
--- a/src/mbgl/annotation/annotation_tile.hpp
+++ b/src/mbgl/annotation/annotation_tile.hpp
@@ -46,7 +46,7 @@ public:
     ~AnnotationTileMonitor();
 
     void update(std::unique_ptr<GeometryTile>);
-    Request* monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)>) override;
+    std::unique_ptr<FileRequest> monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)>) override;
 
     TileID tileID;
 
diff --git a/src/mbgl/map/geometry_tile.hpp b/src/mbgl/map/geometry_tile.hpp
index 93312bcf48..d6717ddc47 100644
--- a/src/mbgl/map/geometry_tile.hpp
+++ b/src/mbgl/map/geometry_tile.hpp
@@ -46,7 +46,7 @@ public:
     virtual util::ptr<GeometryTileLayer> getLayer(const std::string&) const = 0;
 };
 
-class Request;
+class FileRequest;
 
 class GeometryTileMonitor : private util::noncopyable {
 public:
@@ -60,7 +60,7 @@ public:
      *
      * To cease monitoring, release the returned Request.
      */
-    virtual Request* monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)>) = 0;
+    virtual std::unique_ptr<FileRequest> monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)>) = 0;
 };
 
 class GeometryTileFeatureExtractor {
diff --git a/src/mbgl/map/map_context.hpp b/src/mbgl/map/map_context.hpp
index c2e0213dfb..433d5ecea5 100644
--- a/src/mbgl/map/map_context.hpp
+++ b/src/mbgl/map/map_context.hpp
@@ -25,10 +25,10 @@ class Sprite;
 class Worker;
 class StillImage;
 class SpriteImage;
+class FileRequest;
 struct LatLng;
 struct LatLngBounds;
 
-
 struct FrameData {
     std::array<uint16_t, 2> framebufferSize;
 };
@@ -92,7 +92,7 @@ private:
     std::string styleURL;
     std::string styleJSON;
 
-    RequestHolder styleRequest;
+    std::unique_ptr<FileRequest> styleRequest;
 
     Map::StillImageCallback callback;
     size_t sourceCacheSize;
diff --git a/src/mbgl/map/raster_tile_data.hpp b/src/mbgl/map/raster_tile_data.hpp
index d03e3954ba..f19747c441 100644
--- a/src/mbgl/map/raster_tile_data.hpp
+++ b/src/mbgl/map/raster_tile_data.hpp
@@ -3,12 +3,11 @@
 
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/renderer/raster_bucket.hpp>
-#include <mbgl/storage/request_holder.hpp>
 
 namespace mbgl {
 
 class SourceInfo;
-class Request;
+class FileRequest;
 class StyleLayer;
 class TexturePool;
 class WorkRequest;
@@ -29,7 +28,7 @@ private:
     TexturePool& texturePool;
     const SourceInfo& source;
     Worker& worker;
-    RequestHolder req;
+    std::unique_ptr<FileRequest> req;
 
     std::unique_ptr<Bucket> bucket;
 
diff --git a/src/mbgl/map/source.hpp b/src/mbgl/map/source.hpp
index 3abb8f8a1f..661aa09e84 100644
--- a/src/mbgl/map/source.hpp
+++ b/src/mbgl/map/source.hpp
@@ -5,7 +5,6 @@
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/map/tile_cache.hpp>
 #include <mbgl/style/types.hpp>
-#include <mbgl/storage/request_holder.hpp>
 
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/mat4.hpp>
@@ -27,7 +26,7 @@ class MapData;
 class TexturePool;
 class Style;
 class Painter;
-class Request;
+class FileRequest;
 class TransformState;
 class Tile;
 struct ClipID;
@@ -130,7 +129,7 @@ private:
     std::map<TileID, std::weak_ptr<TileData>> tile_data;
     TileCache cache;
 
-    RequestHolder req;
+    std::unique_ptr<FileRequest> req;
     Observer* observer_ = nullptr;
 };
 
diff --git a/src/mbgl/map/vector_tile.cpp b/src/mbgl/map/vector_tile.cpp
index 1159c6fc22..8b06932615 100644
--- a/src/mbgl/map/vector_tile.cpp
+++ b/src/mbgl/map/vector_tile.cpp
@@ -181,7 +181,7 @@ VectorTileMonitor::VectorTileMonitor(const SourceInfo& source, const TileID& id,
     : url(source.tileURL(id, pixelRatio)) {
 }
 
-Request* VectorTileMonitor::monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)> callback) {
+std::unique_ptr<FileRequest> VectorTileMonitor::monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)> callback) {
     return util::ThreadContext::getFileSource()->request({ Resource::Kind::Tile, url }, [callback, this](Response res) {
         if (res.data && data == res.data) {
             // We got the same data again. Abort early.
diff --git a/src/mbgl/map/vector_tile.hpp b/src/mbgl/map/vector_tile.hpp
index 68ed6c2629..7c7f96abbd 100644
--- a/src/mbgl/map/vector_tile.hpp
+++ b/src/mbgl/map/vector_tile.hpp
@@ -63,7 +63,7 @@ class VectorTileMonitor : public GeometryTileMonitor {
 public:
     VectorTileMonitor(const SourceInfo&, const TileID&, float pixelRatio);
 
-    Request* monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)>) override;
+    std::unique_ptr<FileRequest> monitorTile(std::function<void (std::exception_ptr, std::unique_ptr<GeometryTile>)>) override;
 
 private:
     std::string url;
diff --git a/src/mbgl/map/vector_tile_data.cpp b/src/mbgl/map/vector_tile_data.cpp
index cd28fcbd41..28be9627ae 100644
--- a/src/mbgl/map/vector_tile_data.cpp
+++ b/src/mbgl/map/vector_tile_data.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/util/worker.hpp>
 #include <mbgl/util/work_request.hpp>
 #include <mbgl/style/style.hpp>
+#include <mbgl/storage/file_source.hpp>
 
 #include <sstream>
 
@@ -24,7 +25,7 @@ VectorTileData::VectorTileData(const TileID& id_,
       monitor(std::move(monitor_))
 {
     state = State::loading;
-    req = monitor->monitorTile([callback, this](std::exception_ptr err, std::unique_ptr<GeometryTile> tile) {
+    tileRequest = monitor->monitorTile([callback, this](std::exception_ptr err, std::unique_ptr<GeometryTile> tile) {
         if (err) {
             try {
                 std::rethrow_exception(err);
@@ -177,10 +178,8 @@ void VectorTileData::redoPlacement() {
 }
 
 void VectorTileData::cancel() {
-    if (state != State::obsolete) {
-        state = State::obsolete;
-    }
-    req = nullptr;
+    state = State::obsolete;
+    tileRequest.reset();
     workRequest.reset();
 }
 
diff --git a/src/mbgl/map/vector_tile_data.hpp b/src/mbgl/map/vector_tile_data.hpp
index 81064e3133..1b31f3db86 100644
--- a/src/mbgl/map/vector_tile_data.hpp
+++ b/src/mbgl/map/vector_tile_data.hpp
@@ -3,7 +3,6 @@
 
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/map/tile_worker.hpp>
-#include <mbgl/storage/request_holder.hpp>
 #include <mbgl/text/placement_config.hpp>
 
 #include <atomic>
@@ -14,6 +13,7 @@ namespace mbgl {
 
 class Style;
 class WorkRequest;
+class FileRequest;
 class GeometryTileMonitor;
 
 class VectorTileData : public TileData {
@@ -41,8 +41,8 @@ private:
     TileWorker tileWorker;
 
     std::unique_ptr<GeometryTileMonitor> monitor;
+    std::unique_ptr<FileRequest> tileRequest;
     std::unique_ptr<WorkRequest> workRequest;
-    RequestHolder req;
 
     // Contains all the Bucket objects for the tile. Buckets are render
     // objects and they get added by tile parsing operations.
diff --git a/src/mbgl/sprite/sprite_store.cpp b/src/mbgl/sprite/sprite_store.cpp
index c1f4427959..8e00229050 100644
--- a/src/mbgl/sprite/sprite_store.cpp
+++ b/src/mbgl/sprite/sprite_store.cpp
@@ -4,7 +4,6 @@
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
-#include <mbgl/storage/request_holder.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/thread_context.hpp>
 #include <mbgl/util/run_loop.hpp>
@@ -17,8 +16,8 @@ namespace mbgl {
 struct SpriteStore::Loader {
     std::shared_ptr<const std::string> image;
     std::shared_ptr<const std::string> json;
-    RequestHolder jsonRequest;
-    RequestHolder spriteRequest;
+    std::unique_ptr<FileRequest> jsonRequest;
+    std::unique_ptr<FileRequest> spriteRequest;
 };
 
 SpriteStore::SpriteStore(float pixelRatio_)
diff --git a/src/mbgl/storage/default_file_source.cpp b/src/mbgl/storage/default_file_source.cpp
index 47873f76f4..dd8f8370ec 100644
--- a/src/mbgl/storage/default_file_source.cpp
+++ b/src/mbgl/storage/default_file_source.cpp
@@ -1,5 +1,4 @@
 #include <mbgl/storage/default_file_source_impl.hpp>
-#include <mbgl/storage/request.hpp>
 #include <mbgl/storage/asset_context_base.hpp>
 #include <mbgl/storage/http_context_base.hpp>
 #include <mbgl/storage/network_status.hpp>
@@ -35,11 +34,9 @@ DefaultFileSource::DefaultFileSource(FileCache* cache, const std::string& root)
           root)) {
 }
 
-DefaultFileSource::~DefaultFileSource() {
-    MBGL_VERIFY_THREAD(tid);
-}
+DefaultFileSource::~DefaultFileSource() = default;
 
-Request* DefaultFileSource::request(const Resource& resource, Callback callback) {
+std::unique_ptr<FileRequest> DefaultFileSource::request(const Resource& resource, Callback callback) {
     if (!callback) {
         throw util::MisuseException("FileSource callback can't be empty");
     }
@@ -68,15 +65,14 @@ Request* DefaultFileSource::request(const Resource& resource, Callback callback)
         url = resource.url;
     }
 
-    auto req = new Request({ resource.kind, url }, util::RunLoop::getLoop(), std::move(callback));
-    thread->invoke(&Impl::add, req);
-    return req;
+    Resource res { resource.kind, url };
+    auto req = std::make_unique<DefaultFileRequest>(res, *this);
+    req->workRequest = thread->invokeWithCallback(&Impl::add, callback, res, req.get());
+    return std::move(req);
 }
 
-void DefaultFileSource::cancel(Request* req) {
-    assert(req);
-    req->cancel();
-    thread->invoke(&Impl::cancel, req);
+void DefaultFileSource::cancel(const Resource& res, FileRequest* req) {
+    thread->invoke(&Impl::cancel, res, req);
 }
 
 // ----- Impl -----
@@ -101,7 +97,7 @@ DefaultFileSource::Impl::~Impl() {
 
 void DefaultFileSource::Impl::networkIsReachableAgain() {
     for (auto& req : pending) {
-        auto& request = req.second;
+        auto& request = *req.second;
         auto& response = request.getResponse();
         if (!request.realRequest && response && response->error && response->error->reason == Response::Error::Reason::Connection) {
             // We need all requests to fail at least once before we are going to start retrying
@@ -111,18 +107,19 @@ void DefaultFileSource::Impl::networkIsReachableAgain() {
     }
 }
 
-void DefaultFileSource::Impl::add(Request* req) {
-    auto& request = pending.emplace(req->resource, req->resource).first->second;
+void DefaultFileSource::Impl::add(Resource resource, FileRequest* req, Callback callback) {
+    auto& request = *pending.emplace(resource,
+        std::make_unique<DefaultFileRequestImpl>(resource)).first->second;
 
     // Trigger a potentially required refresh of this Request
     update(request);
 
     // Add this request as an observer so that it'll get notified when something about this
     // request changes.
-    request.addObserver(req);
+    request.addObserver(req, callback);
 }
 
-void DefaultFileSource::Impl::update(DefaultFileRequest& request) {
+void DefaultFileSource::Impl::update(DefaultFileRequestImpl& request) {
     if (request.getResponse()) {
         // We've at least obtained a cache value, potentially we also got a final response.
         // The observers have been notified already; send what we have to the new one as well.
@@ -154,7 +151,7 @@ void DefaultFileSource::Impl::update(DefaultFileRequest& request) {
     }
 }
 
-void DefaultFileSource::Impl::startCacheRequest(DefaultFileRequest& request) {
+void DefaultFileSource::Impl::startCacheRequest(DefaultFileRequestImpl& request) {
     // Check the cache for existing data so that we can potentially
     // revalidate the information without having to redownload everything.
     request.cacheRequest =
@@ -177,7 +174,7 @@ void DefaultFileSource::Impl::startCacheRequest(DefaultFileRequest& request) {
         });
 }
 
-void DefaultFileSource::Impl::startRealRequest(DefaultFileRequest& request) {
+void DefaultFileSource::Impl::startRealRequest(DefaultFileRequestImpl& request) {
     assert(!request.realRequest);
 
     // Cancel the timer if we have one.
@@ -212,12 +209,12 @@ void DefaultFileSource::Impl::startRealRequest(DefaultFileRequest& request) {
     }
 }
 
-void DefaultFileSource::Impl::cancel(Request* req) {
-    auto it = pending.find(req->resource);
+void DefaultFileSource::Impl::cancel(Resource resource, FileRequest* req) {
+    auto it = pending.find(resource);
     if (it != pending.end()) {
         // If the number of dependent requests of the DefaultFileRequest drops to zero,
         // cancel the request and remove it from the pending list.
-        auto& request = it->second;
+        auto& request = *it->second;
         request.removeObserver(req);
         if (!request.hasObservers()) {
             pending.erase(it);
@@ -226,13 +223,9 @@ void DefaultFileSource::Impl::cancel(Request* req) {
         // There is no request for this URL anymore. Likely, the request already completed
         // before we got around to process the cancelation request.
     }
-
-    // Send a message back to the requesting thread and notify it that this request has been
-    // canceled and is now safe to be deleted.
-    req->destruct();
 }
 
-void DefaultFileSource::Impl::reschedule(DefaultFileRequest& request) {
+void DefaultFileSource::Impl::reschedule(DefaultFileRequestImpl& request) {
     if (request.realRequest) {
         // There's already a request in progress; don't start another one.
         return;
@@ -257,7 +250,7 @@ void DefaultFileSource::Impl::reschedule(DefaultFileRequest& request) {
 
 // ----- DefaultFileRequest -----
 
-DefaultFileRequest::~DefaultFileRequest() {
+DefaultFileRequestImpl::~DefaultFileRequestImpl() {
     if (realRequest) {
         realRequest->cancel();
         realRequest = nullptr;
@@ -265,32 +258,32 @@ DefaultFileRequest::~DefaultFileRequest() {
     // timerRequest and cacheRequest are automatically canceld upon destruction.
 }
 
-void DefaultFileRequest::addObserver(Request* req) {
-    observers.insert(req);
+void DefaultFileRequestImpl::addObserver(FileRequest* req, Callback callback) {
+    observers.emplace(req, callback);
 
     if (response) {
         // We've got a response, so send the (potentially stale) response to the requester.
-        req->notify(response);
+        callback(*response);
     }
 }
 
-void DefaultFileRequest::removeObserver(Request* req) {
+void DefaultFileRequestImpl::removeObserver(FileRequest* req) {
     observers.erase(req);
 }
 
-bool DefaultFileRequest::hasObservers() const {
+bool DefaultFileRequestImpl::hasObservers() const {
     return !observers.empty();
 }
 
-void DefaultFileRequest::notify() {
+void DefaultFileRequestImpl::notify() {
     if (response) {
-        for (auto req : observers) {
-            req->notify(response);
+        for (auto& req : observers) {
+            req.second(*response);
         }
     }
 }
 
-void DefaultFileRequest::setResponse(const std::shared_ptr<const Response>& response_) {
+void DefaultFileRequestImpl::setResponse(const std::shared_ptr<const Response>& response_) {
     response = response_;
 
     if (response->error) {
@@ -301,11 +294,11 @@ void DefaultFileRequest::setResponse(const std::shared_ptr<const Response>& resp
     }
 }
 
-const std::shared_ptr<const Response>& DefaultFileRequest::getResponse() const {
+const std::shared_ptr<const Response>& DefaultFileRequestImpl::getResponse() const {
     return response;
 }
 
-int64_t DefaultFileRequest::getRetryTimeout() const {
+int64_t DefaultFileRequestImpl::getRetryTimeout() const {
     if (!response) {
         // If we don't have a response, we should retry immediately.
         return 0;
@@ -350,7 +343,7 @@ int64_t DefaultFileRequest::getRetryTimeout() const {
     return timeout;
 }
 
-void DefaultFileRequest::checkResponseFreshness() {
+void DefaultFileRequestImpl::checkResponseFreshness() {
     if (response && !response->stale && response->isExpired()) {
         // Create a new Response object with `stale = true`, but the same data, and
         // replace the current request object we have.
diff --git a/src/mbgl/storage/default_file_source_impl.hpp b/src/mbgl/storage/default_file_source_impl.hpp
index 4ca8e42721..c063a7d1f8 100644
--- a/src/mbgl/storage/default_file_source_impl.hpp
+++ b/src/mbgl/storage/default_file_source_impl.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/storage/asset_context_base.hpp>
 #include <mbgl/storage/http_context_base.hpp>
+#include <mbgl/util/noncopyable.hpp>
 
 #include <set>
 #include <unordered_map>
@@ -12,27 +13,41 @@ namespace mbgl {
 
 class RequestBase;
 
-class DefaultFileRequest {
+class DefaultFileRequest : public FileRequest {
 public:
+    DefaultFileRequest(const Resource& resource_,
+                       DefaultFileSource& fileSource_)
+        : resource(resource_),
+          fileSource(fileSource_) {
+    }
+
+    ~DefaultFileRequest() {
+        fileSource.cancel(resource, this);
+    }
+
+    Resource resource;
+    DefaultFileSource& fileSource;
+
+    std::unique_ptr<WorkRequest> workRequest;
+};
+
+class DefaultFileRequestImpl : public util::noncopyable {
+public:
+    using Callback = std::function<void (Response)>;
+
     const Resource resource;
     std::unique_ptr<WorkRequest> cacheRequest;
     RequestBase* realRequest = nullptr;
     std::unique_ptr<uv::timer> timerRequest;
 
-    inline DefaultFileRequest(const Resource& resource_)
+    inline DefaultFileRequestImpl(const Resource& resource_)
         : resource(resource_) {}
 
-public:
-    // Make it movable-only.
-    DefaultFileRequest(const DefaultFileRequest&) = delete;
-    inline DefaultFileRequest(DefaultFileRequest&&) = default;
-    DefaultFileRequest& operator=(const DefaultFileRequest&) = delete;
-    inline DefaultFileRequest& operator=(DefaultFileRequest&&) = default;
-    ~DefaultFileRequest();
+    ~DefaultFileRequestImpl();
 
     // Observer accessors.
-    void addObserver(Request*);
-    void removeObserver(Request*);
+    void addObserver(FileRequest*, Callback);
+    void removeObserver(FileRequest*);
     bool hasObservers() const;
 
     // Updates/gets the response of this request object.
@@ -54,7 +69,7 @@ public:
 
 private:
     // Stores a set of all observing Request objects.
-    std::set<Request*> observers;
+    std::unordered_map<FileRequest*, Callback> observers;
 
     // The current response data. We're storing it because we can satisfy requests for the same
     // resource directly by returning this response object. We also need it to create conditional
@@ -68,21 +83,23 @@ private:
 
 class DefaultFileSource::Impl {
 public:
+    using Callback = std::function<void (Response)>;
+
     Impl(FileCache*, const std::string& = "");
     ~Impl();
 
     void networkIsReachableAgain();
 
-    void add(Request*);
-    void cancel(Request*);
+    void add(Resource, FileRequest*, Callback);
+    void cancel(Resource, FileRequest*);
 
 private:
-    void update(DefaultFileRequest&);
-    void startCacheRequest(DefaultFileRequest&);
-    void startRealRequest(DefaultFileRequest&);
-    void reschedule(DefaultFileRequest&);
+    void update(DefaultFileRequestImpl&);
+    void startCacheRequest(DefaultFileRequestImpl&);
+    void startRealRequest(DefaultFileRequestImpl&);
+    void reschedule(DefaultFileRequestImpl&);
 
-    std::unordered_map<Resource, DefaultFileRequest, Resource::Hash> pending;
+    std::unordered_map<Resource, std::unique_ptr<DefaultFileRequestImpl>, Resource::Hash> pending;
     uv_loop_t* const loop;
     FileCache* const cache;
     const std::string assetRoot;
diff --git a/src/mbgl/storage/request.cpp b/src/mbgl/storage/request.cpp
deleted file mode 100644
index 5ed9278d0a..0000000000
--- a/src/mbgl/storage/request.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include <mbgl/storage/request.hpp>
-
-#include <mbgl/storage/response.hpp>
-#include <mbgl/util/util.hpp>
-#include <mbgl/util/uv_detail.hpp>
-
-#include <cassert>
-#include <functional>
-#include <memory>
-
-namespace mbgl {
-
-// Note: This requires that loop is running in the current thread (or not yet running).
-Request::Request(const Resource &resource_, uv_loop_t *loop, Callback callback_)
-    : async(std::make_unique<uv::async>(loop, [this] { notifyCallback(); })),
-      callback(callback_),
-      resource(resource_) {
-}
-
-// Called in the originating thread.
-void Request::notifyCallback() {
-    std::unique_lock<std::mutex> lock(mtx);
-    if (!canceled) {
-        // Move the response object out so that we can't accidentally notify twice.
-        auto res = std::move(response);
-        assert(!response);
-        // Unlock before, since callbacks may call cancel, which also locks this mutex.
-        lock.unlock();
-        // The user could supply a null pointer or empty std::function as a callback. In this case, we
-        // still do the file request, but we don't need to deliver a result.
-        // Similarly, two consecutive updates could trigger two notifyCallbacks, so we need to make
-        // sure
-        if (callback && res) {
-            callback(*res);
-        }
-    } else {
-        // Don't delete right way, because we have to unlock the mutex before deleting.
-        if (confirmed) {
-            lock.unlock();
-            delete this;
-        }
-    }
-}
-
-Request::~Request() = default;
-
-// Called in the FileSource thread.
-void Request::notify(const std::shared_ptr<const Response> &response_) {
-    std::lock_guard<std::mutex> lock(mtx);
-    assert(response_);
-    response = response_;
-    async->send();
-}
-
-// Called in the originating thread.
-void Request::cancel() {
-    std::lock_guard<std::mutex> lock(mtx);
-    assert(!canceled);
-    canceled = true;
-}
-
-
-// Called in the FileSource thread.
-// Will only ever be invoked after cancel() was called in the original requesting thread.
-void Request::destruct() {
-    std::lock_guard<std::mutex> lock(mtx);
-    assert(canceled);
-    confirmed = true;
-    // We need to extend the lock until after the async has been sent, otherwise the requesting
-    // thread could destroy the async while this call is still in progress.
-    async->send();
-    // After this method returns, the FileSource thread has no knowledge of
-    // this object anymore.
-}
-
-}
diff --git a/src/mbgl/storage/request_holder.cpp b/src/mbgl/storage/request_holder.cpp
deleted file mode 100644
index 3a038623c4..0000000000
--- a/src/mbgl/storage/request_holder.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <mbgl/storage/request_holder.hpp>
-#include <mbgl/storage/file_source.hpp>
-#include <mbgl/util/thread_context.hpp>
-
-namespace mbgl {
-
-void RequestHolder::Deleter::operator()(Request* req) const {
-    // This function is called by the unique_ptr's Deleter.
-    util::ThreadContext::getFileSource()->cancel(req);
-}
-
-}
diff --git a/src/mbgl/storage/request_holder.hpp b/src/mbgl/storage/request_holder.hpp
deleted file mode 100644
index 62edbfde7d..0000000000
--- a/src/mbgl/storage/request_holder.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef MBGL_STORAGE_REQUEST_HOLDER
-#define MBGL_STORAGE_REQUEST_HOLDER
-
-#include <memory>
-
-namespace mbgl {
-
-class Request;
-
-class RequestHolder {
-public:
-    inline RequestHolder& operator=(Request* req) {
-        ptr = std::unique_ptr<Request, Deleter>(req);
-        return *this;
-    }
-
-private:
-    struct Deleter {
-        void operator()(Request*) const;
-    };
-    std::unique_ptr<Request, Deleter> ptr;
-};
-
-}
-
-#endif
diff --git a/src/mbgl/text/glyph_pbf.hpp b/src/mbgl/text/glyph_pbf.hpp
index bf8567dbec..69d7747471 100644
--- a/src/mbgl/text/glyph_pbf.hpp
+++ b/src/mbgl/text/glyph_pbf.hpp
@@ -3,17 +3,17 @@
 
 #include <mbgl/text/glyph.hpp>
 #include <mbgl/util/noncopyable.hpp>
-#include <mbgl/storage/request_holder.hpp>
 
 #include <atomic>
 #include <functional>
 #include <string>
+#include <memory>
 
 namespace mbgl {
 
 class GlyphStore;
 class FontStack;
-class Request;
+class FileRequest;
 
 class GlyphPBF : private util::noncopyable {
 public:
@@ -45,7 +45,7 @@ private:
     std::shared_ptr<const std::string> data;
     std::atomic<bool> parsed;
 
-    RequestHolder req;
+    std::unique_ptr<FileRequest> req;
 
     Observer* observer = nullptr;
 };