[core] Use std::unique_ptr for FileSource request

16 files changed, 137 insertions, 136 deletions

diff --git a/test/fixtures/mock_file_source.cpp b/test/fixtures/mock_file_source.cpp
index 33d7397d54..ea580276d6 100644
--- a/test/fixtures/mock_file_source.cpp
+++ b/test/fixtures/mock_file_source.cpp
@@ -1,11 +1,11 @@
 #include "../fixtures/util.hpp"
 #include "mock_file_source.hpp"
 
-#include <mbgl/storage/request.hpp>
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/thread.hpp>
 
 #include <algorithm>
+#include <unordered_map>
 
 namespace {
 
@@ -15,6 +15,24 @@ const uint64_t timeout = 1000000;
 
 namespace mbgl {
 
+class MockFileRequest : public FileRequest {
+public:
+    MockFileRequest(const Resource& resource_,
+                    MockFileSource& fileSource_)
+        : resource(resource_),
+          fileSource(fileSource_) {
+    }
+
+    ~MockFileRequest() {
+        fileSource.cancel(this);
+    }
+
+    Resource resource;
+    MockFileSource& fileSource;
+
+    std::unique_ptr<WorkRequest> workRequest;
+};
+
 class MockFileSource::Impl {
 public:
     Impl(Type type, const std::string& match)
@@ -31,107 +49,97 @@ public:
         requestEnqueuedCallback_ = callback;
     }
 
-    void handleRequest(Request* req);
-    void cancelRequest(Request* req);
+    void handleRequest(FileRequest*, Resource, Callback);
+    void cancelRequest(FileRequest*);
 
 private:
-    void replyWithSuccess(Request* req) const;
-    void replyWithSuccessWithDelay(Request* req);
-    void replyWithFailure(Request* req) const;
-    void replyWithCorruptedData(Request* req) const;
+    void replyWithSuccess(Resource, Callback) const;
+    void replyWithSuccessWithDelay(FileRequest*, Resource, Callback);
+    void replyWithFailure(Resource, Callback) const;
+    void replyWithCorruptedData(Resource, Callback) const;
 
     void dispatchPendingRequests();
 
     Type type_;
     std::string match_;
-    std::vector<Request*> pendingRequests_;
+    std::unordered_map<FileRequest*, std::pair<Resource, Callback>> pendingRequests_;
     uv::timer timer_;
 
     std::function<void(void)> requestEnqueuedCallback_;
 };
 
-void MockFileSource::Impl::replyWithSuccess(Request* req) const {
-    std::shared_ptr<Response> res = std::make_shared<Response>();
+void MockFileSource::Impl::replyWithSuccess(Resource resource, Callback callback) const {
+    Response res;
 
     try {
-        res->data = std::make_shared<const std::string>(std::move(util::read_file(req->resource.url)));
+        res.data = std::make_shared<const std::string>(std::move(util::read_file(resource.url)));
     } catch (const std::exception& err) {
-        res->error = std::make_unique<Response::Error>(Response::Error::Reason::Other, err.what());
+        res.error = std::make_unique<Response::Error>(Response::Error::Reason::Other, err.what());
     }
 
-    req->notify(res);
+    callback(res);
 }
 
-void MockFileSource::Impl::replyWithSuccessWithDelay(Request* req) {
-    if (req->resource.url.find(match_) == std::string::npos) {
-        replyWithSuccess(req);
+void MockFileSource::Impl::replyWithSuccessWithDelay(FileRequest* req, Resource resource, Callback callback) {
+    if (resource.url.find(match_) == std::string::npos) {
+        replyWithSuccess(resource, callback);
         return;
     }
 
-    pendingRequests_.push_back(req);
+    pendingRequests_.emplace(req, std::make_pair(resource, callback));
     requestEnqueuedCallback_();
 }
 
-void MockFileSource::Impl::replyWithFailure(Request* req) const {
-    if (req->resource.url.find(match_) == std::string::npos) {
-        replyWithSuccess(req);
+void MockFileSource::Impl::replyWithFailure(Resource resource, Callback callback) const {
+    if (resource.url.find(match_) == std::string::npos) {
+        replyWithSuccess(resource, callback);
         return;
     }
 
-    std::shared_ptr<Response> res = std::make_shared<Response>();
-    res->error = std::make_unique<Response::Error>(Response::Error::Reason::Other, "Failed by the test case");
-
-    req->notify(res);
+    Response res;
+    res.error = std::make_unique<Response::Error>(Response::Error::Reason::Other, "Failed by the test case");
+    callback(res);
 }
 
-void MockFileSource::Impl::replyWithCorruptedData(Request* req) const {
-    if (req->resource.url.find(match_) == std::string::npos) {
-        replyWithSuccess(req);
+void MockFileSource::Impl::replyWithCorruptedData(Resource resource, Callback callback) const {
+    if (resource.url.find(match_) == std::string::npos) {
+        replyWithSuccess(resource, callback);
         return;
     }
 
-    std::shared_ptr<Response> res = std::make_shared<Response>();
-    auto data = std::make_shared<std::string>(std::move(util::read_file(req->resource.url)));
+    Response res;
+    auto data = std::make_shared<std::string>(std::move(util::read_file(resource.url)));
     data->insert(0, "CORRUPTED");
-    res->data = std::move(data);
-
-    req->notify(res);
+    res.data = std::move(data);
+    callback(res);
 }
 
-void MockFileSource::Impl::handleRequest(Request* req) {
+void MockFileSource::Impl::handleRequest(FileRequest* req, Resource resource, Callback callback) {
     switch (type_) {
     case Type::Success:
-        replyWithSuccess(req);
+        replyWithSuccess(resource, callback);
         break;
     case Type::SuccessWithDelay:
-        replyWithSuccessWithDelay(req);
+        replyWithSuccessWithDelay(req, resource, callback);
         break;
     case Type::RequestFail:
-        replyWithFailure(req);
+        replyWithFailure(resource, callback);
         break;
     case Type::RequestWithCorruptedData:
-        replyWithCorruptedData(req);
+        replyWithCorruptedData(resource, callback);
         break;
     default:
         EXPECT_TRUE(false) << "Should never be reached.";
     }
 }
 
-void MockFileSource::Impl::cancelRequest(Request* req) {
-    auto it = std::find(pendingRequests_.begin(), pendingRequests_.end(), req);
-    if (it != pendingRequests_.end()) {
-        pendingRequests_.erase(it);
-    } else {
-        // There is no request for this URL anymore. Likely, the request already completed
-        // before we got around to process the cancelation request.
-    }
-
-    req->destruct();
+void MockFileSource::Impl::cancelRequest(FileRequest* req) {
+    pendingRequests_.erase(req);
 }
 
 void MockFileSource::Impl::dispatchPendingRequests() {
-    for (auto req : pendingRequests_) {
-        replyWithSuccess(req);
+    for (auto& pair : pendingRequests_) {
+        replyWithSuccess(pair.second.first, pair.second.second);
     }
 
     pendingRequests_.clear();
@@ -145,15 +153,13 @@ void MockFileSource::setOnRequestDelayedCallback(std::function<void(void)> callb
     thread_->invokeSync(&Impl::setOnRequestDelayedCallback, callback);
 }
 
-Request* MockFileSource::request(const Resource& resource, Callback callback) {
-    Request* req = new Request(resource, util::RunLoop::getLoop(), std::move(callback));
-    thread_->invoke(&Impl::handleRequest, req);
-
-    return req;
+std::unique_ptr<FileRequest> MockFileSource::request(const Resource& res, Callback callback) {
+    auto req = std::make_unique<MockFileRequest>(res, *this);
+    req->workRequest = thread_->invokeWithCallback(&Impl::handleRequest, callback, req.get(), res);
+    return std::move(req);
 }
 
-void MockFileSource::cancel(Request* req) {
-    req->cancel();
+void MockFileSource::cancel(FileRequest* req) {
     thread_->invoke(&Impl::cancelRequest, req);
 }
 
diff --git a/test/fixtures/mock_file_source.hpp b/test/fixtures/mock_file_source.hpp
index 716b0672e3..f41f808e36 100644
--- a/test/fixtures/mock_file_source.hpp
+++ b/test/fixtures/mock_file_source.hpp
@@ -47,10 +47,12 @@ public:
     void setOnRequestDelayedCallback(std::function<void(void)> callback);
 
     // FileSource implementation.
-    Request* request(const Resource&, Callback) override;
-    void cancel(Request*) override;
+    std::unique_ptr<FileRequest> request(const Resource&, Callback) override;
 
 private:
+    friend class MockFileRequest;
+    void cancel(FileRequest*);
+
     const std::unique_ptr<util::Thread<Impl>> thread_;
 };
 
diff --git a/test/storage/cache_response.cpp b/test/storage/cache_response.cpp
index fb745d9ad4..d089659aeb 100644
--- a/test/storage/cache_response.cpp
+++ b/test/storage/cache_response.cpp
@@ -18,11 +18,11 @@ TEST_F(Storage, CacheResponse) {
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/cache" };
     Response response;
 
-    Request* req1 = nullptr;
-    Request* req2 = nullptr;
+    std::unique_ptr<FileRequest> req1;
+    std::unique_ptr<FileRequest> req2;
 
     req1 = fs.request(resource, [&](Response res) {
-        fs.cancel(req1);
+        req1.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
@@ -35,7 +35,7 @@ TEST_F(Storage, CacheResponse) {
         // Now test that we get the same values as in the previous request. If we'd go to the server
         // again, we'd get different values.
         req2 = fs.request(resource, [&](Response res2) {
-            fs.cancel(req2);
+            req2.reset();
             EXPECT_EQ(response.error, res2.error);
             EXPECT_EQ(response.stale, res2.stale);
             ASSERT_TRUE(res2.data.get());
diff --git a/test/storage/cache_revalidate.cpp b/test/storage/cache_revalidate.cpp
index 0dfe765e7f..540a25acd6 100644
--- a/test/storage/cache_revalidate.cpp
+++ b/test/storage/cache_revalidate.cpp
@@ -16,8 +16,8 @@ TEST_F(Storage, CacheRevalidateSame) {
     util::RunLoop loop(uv_default_loop());
 
     const Resource revalidateSame { Resource::Unknown, "http://127.0.0.1:3000/revalidate-same" };
-    Request* req1 = nullptr;
-    Request* req2 = nullptr;
+    std::unique_ptr<FileRequest> req1;
+    std::unique_ptr<FileRequest> req2;
     req1 = fs.request(revalidateSame, [&](Response res) {
         // This callback can get triggered multiple times. We only care about the first invocation.
         // It will get triggered again when refreshing the req2 (see below).
@@ -41,13 +41,11 @@ TEST_F(Storage, CacheRevalidateSame) {
                 return;
             }
 
-            ASSERT_TRUE(req1);
-            fs.cancel(req1);
-            req1 = nullptr;
+            ASSERT_TRUE(req1.get());
+            req1.reset();
 
-            ASSERT_TRUE(req2);
-            fs.cancel(req2);
-            req2 = nullptr;
+            ASSERT_TRUE(req2.get());
+            req2.reset();
 
             EXPECT_EQ(nullptr, res2.error);
             EXPECT_EQ(false, res2.stale);
@@ -79,8 +77,8 @@ TEST_F(Storage, CacheRevalidateModified) {
 
     const Resource revalidateModified{ Resource::Unknown,
                                        "http://127.0.0.1:3000/revalidate-modified" };
-    Request* req1 = nullptr;
-    Request* req2 = nullptr;
+    std::unique_ptr<FileRequest> req1;
+    std::unique_ptr<FileRequest> req2;
     req1 = fs.request(revalidateModified, [&](Response res) {
         // This callback can get triggered multiple times. We only care about the first invocation.
         // It will get triggered again when refreshing the req2 (see below).
@@ -104,13 +102,11 @@ TEST_F(Storage, CacheRevalidateModified) {
                 return;
             }
 
-            ASSERT_TRUE(req1);
-            fs.cancel(req1);
-            req1 = nullptr;
+            ASSERT_TRUE(req1.get());
+            req1.reset();
 
-            ASSERT_TRUE(req2);
-            fs.cancel(req2);
-            req2 = nullptr;
+            ASSERT_TRUE(req2.get());
+            req2.reset();
 
             EXPECT_EQ(nullptr, res2.error);
             EXPECT_EQ(false, res2.stale);
@@ -140,8 +136,8 @@ TEST_F(Storage, CacheRevalidateEtag) {
     util::RunLoop loop(uv_default_loop());
 
     const Resource revalidateEtag { Resource::Unknown, "http://127.0.0.1:3000/revalidate-etag" };
-    Request* req1 = nullptr;
-    Request* req2 = nullptr;
+    std::unique_ptr<FileRequest> req1;
+    std::unique_ptr<FileRequest> req2;
     req1 = fs.request(revalidateEtag, [&](Response res) {
         // This callback can get triggered multiple times. We only care about the first invocation.
         // It will get triggered again when refreshing the req2 (see below).
@@ -165,13 +161,11 @@ TEST_F(Storage, CacheRevalidateEtag) {
                 return;
             }
 
-            ASSERT_TRUE(req1);
-            fs.cancel(req1);
-            req1 = nullptr;
+            ASSERT_TRUE(req1.get());
+            req1.reset();
 
-            ASSERT_TRUE(req2);
-            fs.cancel(req2);
-            req2 = nullptr;
+            ASSERT_TRUE(req2.get());
+            req2.reset();
 
             EXPECT_EQ(nullptr, res2.error);
             EXPECT_EQ(false, res2.stale);
diff --git a/test/storage/directory_reading.cpp b/test/storage/directory_reading.cpp
index ae8c0b42c1..fab52315fa 100644
--- a/test/storage/directory_reading.cpp
+++ b/test/storage/directory_reading.cpp
@@ -18,8 +18,8 @@ TEST_F(Storage, AssetReadDirectory) {
 
     util::RunLoop loop(uv_default_loop());
 
-    Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage" }, [&](Response res) {
-        fs.cancel(req);
+    std::unique_ptr<FileRequest> req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage" }, [&](Response res) {
+        req.reset();
         ASSERT_NE(nullptr, res.error);
         EXPECT_EQ(Response::Error::Reason::NotFound, res.error->reason);
         EXPECT_EQ(false, res.stale);
diff --git a/test/storage/file_reading.cpp b/test/storage/file_reading.cpp
index b9155c09c5..3fc30df524 100644
--- a/test/storage/file_reading.cpp
+++ b/test/storage/file_reading.cpp
@@ -19,8 +19,8 @@ TEST_F(Storage, AssetEmptyFile) {
 
     util::RunLoop loop(uv_default_loop());
 
-    Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/empty" }, [&](Response res) {
-        fs.cancel(req);
+    std::unique_ptr<FileRequest> req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/empty" }, [&](Response res) {
+        req.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
@@ -48,8 +48,8 @@ TEST_F(Storage, AssetNonEmptyFile) {
 
     util::RunLoop loop(uv_default_loop());
 
-    Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/nonempty" }, [&](Response res) {
-        fs.cancel(req);
+    std::unique_ptr<FileRequest> req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/nonempty" }, [&](Response res) {
+        req.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
@@ -79,8 +79,8 @@ TEST_F(Storage, AssetNonExistentFile) {
 
     util::RunLoop loop(uv_default_loop());
 
-    Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/does_not_exist" }, [&](Response res) {
-        fs.cancel(req);
+    std::unique_ptr<FileRequest> req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/does_not_exist" }, [&](Response res) {
+        req.reset();
         ASSERT_NE(nullptr, res.error);
         EXPECT_EQ(Response::Error::Reason::NotFound, res.error->reason);
         EXPECT_EQ(false, res.stale);
diff --git a/test/storage/http_cancel.cpp b/test/storage/http_cancel.cpp
index 070c54b8b4..eabc895902 100644
--- a/test/storage/http_cancel.cpp
+++ b/test/storage/http_cancel.cpp
@@ -20,7 +20,7 @@ TEST_F(Storage, HTTPCancel) {
         fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" },
                    [&](Response) { ADD_FAILURE() << "Callback should not be called"; });
 
-    fs.cancel(req);
+    req.reset();
     HTTPCancel.finish();
 
     uv_run(uv_default_loop(), UV_RUN_ONCE);
@@ -36,11 +36,11 @@ TEST_F(Storage, HTTPCancelMultiple) {
 
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
 
-    auto req2 = fs.request(resource, [&](Response) {
+    std::unique_ptr<FileRequest> req2 = fs.request(resource, [&](Response) {
         ADD_FAILURE() << "Callback should not be called";
     });
-    Request* req = fs.request(resource, [&](Response res) {
-        fs.cancel(req);
+    std::unique_ptr<FileRequest> req = fs.request(resource, [&](Response res) {
+        req.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
@@ -51,7 +51,7 @@ TEST_F(Storage, HTTPCancelMultiple) {
         loop.stop();
         HTTPCancelMultiple.finish();
     });
-    fs.cancel(req2);
+    req2.reset();
 
     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
 }
diff --git a/test/storage/http_coalescing.cpp b/test/storage/http_coalescing.cpp
index 58f30baebb..38fc0151a3 100644
--- a/test/storage/http_coalescing.cpp
+++ b/test/storage/http_coalescing.cpp
@@ -43,10 +43,10 @@ TEST_F(Storage, HTTPCoalescing) {
 
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
 
-    Request* reqs[total];
+    std::unique_ptr<FileRequest> reqs[total];
     for (int i = 0; i < total; i++) {
         reqs[i] = fs.request(resource, [&complete, &fs, &reqs, i] (Response res) {
-            fs.cancel(reqs[i]);
+            reqs[i].reset();
             complete(res);
         });
     }
@@ -63,8 +63,8 @@ TEST_F(Storage, HTTPMultiple) {
     util::RunLoop loop(uv_default_loop());
 
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test?expires=2147483647" };
-    Request* req1 = nullptr;
-    Request* req2 = nullptr;
+    std::unique_ptr<FileRequest> req1;
+    std::unique_ptr<FileRequest> req2;
     req1 = fs.request(resource, [&] (Response res) {
         // Do not cancel the request right away.
         EXPECT_EQ(nullptr, res.error);
@@ -80,8 +80,8 @@ TEST_F(Storage, HTTPMultiple) {
             EXPECT_EQ(res.data.get(), res2.data.get());
 
             // Now cancel both requests after both have been notified.
-            fs.cancel(req1);
-            fs.cancel(req2);
+            req1.reset();
+            req2.reset();
 
             EXPECT_EQ(nullptr, res2.error);
             ASSERT_TRUE(res2.data.get());
@@ -111,8 +111,8 @@ TEST_F(Storage, HTTPStale) {
     int stale = 0;
 
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test" };
-    Request* req1 = nullptr;
-    Request* req2 = nullptr;
+    std::unique_ptr<FileRequest> req1;
+    std::unique_ptr<FileRequest> req2;
     req1 = fs.request(resource, [&] (Response res) {
         // Do not cancel the request right away.
         EXPECT_EQ(nullptr, res.error);
@@ -144,8 +144,8 @@ TEST_F(Storage, HTTPStale) {
                 stale++;
             } else {
                 // Now cancel both requests after both have been notified.
-                fs.cancel(req1);
-                fs.cancel(req2);
+                req1.reset();
+                req2.reset();
                 loop.stop();
                 HTTPStale.finish();
             }
diff --git a/test/storage/http_error.cpp b/test/storage/http_error.cpp
index ce04e871eb..276793b77f 100644
--- a/test/storage/http_error.cpp
+++ b/test/storage/http_error.cpp
@@ -18,7 +18,7 @@ TEST_F(Storage, HTTPTemporaryError) {
 
     const auto start = uv_hrtime();
 
-    Request* req1 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/temporary-error" }, [&](Response res) {
+    std::unique_ptr<FileRequest> req1 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/temporary-error" }, [&](Response res) {
         static int counter = 0;
         switch (counter++) {
         case 0: {
@@ -35,7 +35,7 @@ TEST_F(Storage, HTTPTemporaryError) {
             EXPECT_EQ("", res.etag);
         } break;
         case 1: {
-            fs.cancel(req1);
+            req1.reset();
             const auto duration = double(uv_hrtime() - start) / 1e9;
             EXPECT_LT(0.99, duration) << "Backoff timer didn't wait 1 second";
             EXPECT_GT(1.2, duration) << "Backoff timer fired too late";
@@ -65,7 +65,7 @@ TEST_F(Storage, HTTPConnectionError) {
 
     const auto start = uv_hrtime();
 
-    Request* req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3001/" }, [&](Response res) {
+    std::unique_ptr<FileRequest> req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3001/" }, [&](Response res) {
         static int counter = 0;
         static int wait = 0;
         const auto duration = double(uv_hrtime() - start) / 1e9;
@@ -91,7 +91,7 @@ TEST_F(Storage, HTTPConnectionError) {
         EXPECT_EQ("", res.etag);
 
         if (counter == 2) {
-            fs.cancel(req2);
+            req2.reset();
             loop.stop();
             HTTPConnectionError.finish();
         }
diff --git a/test/storage/http_header_parsing.cpp b/test/storage/http_header_parsing.cpp
index 8048addb52..041b138b60 100644
--- a/test/storage/http_header_parsing.cpp
+++ b/test/storage/http_header_parsing.cpp
@@ -16,10 +16,10 @@ TEST_F(Storage, HTTPExpiresParsing) {
     DefaultFileSource fs(nullptr);
     util::RunLoop loop(uv_default_loop());
 
-    Request* req1 = fs.request({ Resource::Unknown,
+    std::unique_ptr<FileRequest> req1 = fs.request({ Resource::Unknown,
                  "http://127.0.0.1:3000/test?modified=1420794326&expires=1420797926&etag=foo" },
                [&](Response res) {
-        fs.cancel(req1);
+        req1.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
@@ -45,9 +45,9 @@ TEST_F(Storage, HTTPCacheControlParsing) {
     int64_t now = std::chrono::duration_cast<std::chrono::seconds>(
                        SystemClock::now().time_since_epoch()).count();
 
-    Request* req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=120" },
+    std::unique_ptr<FileRequest> req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=120" },
                [&](Response res) {
-        fs.cancel(req2);
+        req2.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
diff --git a/test/storage/http_issue_1369.cpp b/test/storage/http_issue_1369.cpp
index 5c05aead31..0fe0f5fb1b 100644
--- a/test/storage/http_issue_1369.cpp
+++ b/test/storage/http_issue_1369.cpp
@@ -31,9 +31,9 @@ TEST_F(Storage, HTTPIssue1369) {
     auto req = fs.request(resource, [&](Response) {
         ADD_FAILURE() << "Callback should not be called";
     });
-    fs.cancel(req);
+    req.reset();
     req = fs.request(resource, [&](Response res) {
-        fs.cancel(req);
+        req.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
diff --git a/test/storage/http_load.cpp b/test/storage/http_load.cpp
index fef1f06e7b..0a6b0ef653 100644
--- a/test/storage/http_load.cpp
+++ b/test/storage/http_load.cpp
@@ -17,15 +17,14 @@ TEST_F(Storage, HTTPLoad) {
     const int max = 10000;
     int number = 1;
 
-    Request* reqs[concurrency];
+    std::unique_ptr<FileRequest> reqs[concurrency];
 
     std::function<void(int)> req = [&](int i) {
         const auto current = number++;
         reqs[i] = fs.request({ Resource::Unknown,
                      std::string("http://127.0.0.1:3000/load/") + std::to_string(current) },
                    [&, i, current](Response res) {
-            fs.cancel(reqs[i]);
-            reqs[i] = nullptr;
+            reqs[i].reset();
             EXPECT_EQ(nullptr, res.error);
             EXPECT_EQ(false, res.stale);
             ASSERT_TRUE(res.data.get());
diff --git a/test/storage/http_other_loop.cpp b/test/storage/http_other_loop.cpp
index 52475ae1a4..b432c39ac2 100644
--- a/test/storage/http_other_loop.cpp
+++ b/test/storage/http_other_loop.cpp
@@ -14,9 +14,9 @@ TEST_F(Storage, HTTPOtherLoop) {
     DefaultFileSource fs(nullptr);
     util::RunLoop loop(uv_default_loop());
 
-    Request* req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" },
+    std::unique_ptr<FileRequest> req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" },
                [&](Response res) {
-        fs.cancel(req);
+        req.reset();
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
diff --git a/test/storage/http_reading.cpp b/test/storage/http_reading.cpp
index b72f060e63..b072a6eb53 100644
--- a/test/storage/http_reading.cpp
+++ b/test/storage/http_reading.cpp
@@ -18,9 +18,9 @@ TEST_F(Storage, HTTPTest) {
 
     const auto mainThread = uv_thread_self();
 
-    Request* req1 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" },
+    std::unique_ptr<FileRequest> req1 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" },
                [&](Response res) {
-        fs.cancel(req1);
+        req1.reset();
         EXPECT_EQ(uv_thread_self(), mainThread);
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
@@ -46,9 +46,9 @@ TEST_F(Storage, HTTP404) {
 
     const auto mainThread = uv_thread_self();
 
-    Request* req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/doesnotexist" },
+    std::unique_ptr<FileRequest> req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/doesnotexist" },
                [&](Response res) {
-        fs.cancel(req2);
+        req2.reset();
         EXPECT_EQ(uv_thread_self(), mainThread);
         ASSERT_NE(nullptr, res.error);
         EXPECT_EQ(Response::Error::Reason::NotFound, res.error->reason);
@@ -76,9 +76,9 @@ TEST_F(Storage, HTTP500) {
 
     const auto mainThread = uv_thread_self();
 
-    Request* req3 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/permanent-error" },
+    std::unique_ptr<FileRequest> req3 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/permanent-error" },
                [&](Response res) {
-        fs.cancel(req3);
+        req3.reset();
         EXPECT_EQ(uv_thread_self(), mainThread);
         ASSERT_NE(nullptr, res.error);
         EXPECT_EQ(Response::Error::Reason::Server, res.error->reason);
diff --git a/test/storage/http_retry_network_status.cpp b/test/storage/http_retry_network_status.cpp
index 66182f5be4..08e3be89ab 100644
--- a/test/storage/http_retry_network_status.cpp
+++ b/test/storage/http_retry_network_status.cpp
@@ -24,8 +24,8 @@ TEST_F(Storage, HTTPNetworkStatusChange) {
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/delayed" };
 
     // This request takes 200 milliseconds to answer.
-    Request* req = fs.request(resource, [&](Response res) {
-         fs.cancel(req);
+    std::unique_ptr<FileRequest> req = fs.request(resource, [&](Response res) {
+         req.reset();
          EXPECT_EQ(nullptr, res.error);
          EXPECT_EQ(false, res.stale);
          ASSERT_TRUE(res.data.get());
@@ -64,7 +64,7 @@ TEST_F(Storage, HTTPNetworkStatusChangePreempt) {
     const auto start = uv_hrtime();
 
     const Resource resource{ Resource::Unknown, "http://127.0.0.1:3001/test" };
-    Request* req = fs.request(resource, [&](Response res) {
+    std::unique_ptr<FileRequest> req = fs.request(resource, [&](Response res) {
         static int counter = 0;
         const auto duration = double(uv_hrtime() - start) / 1e9;
         if (counter == 0) {
@@ -95,7 +95,7 @@ TEST_F(Storage, HTTPNetworkStatusChangePreempt) {
         EXPECT_EQ("", res.etag);
 
         if (counter++ == 1) {
-            fs.cancel(req);
+            req.reset();
             loop.stop();
             HTTPNetworkStatusChangePreempt.finish();
         }
diff --git a/test/storage/http_timeout.cpp b/test/storage/http_timeout.cpp
index d59ca3cb77..2c1a1f1f60 100644
--- a/test/storage/http_timeout.cpp
+++ b/test/storage/http_timeout.cpp
@@ -18,7 +18,7 @@ TEST_F(Storage, HTTPTimeout) {
     int counter = 0;
 
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=1" };
-    Request* req = fs.request(resource, [&](Response res) {
+    std::unique_ptr<FileRequest> req = fs.request(resource, [&](Response res) {
         counter++;
         EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
@@ -28,7 +28,7 @@ TEST_F(Storage, HTTPTimeout) {
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
         if (counter == 4) {
-            fs.cancel(req);
+            req.reset();
             loop.stop();
             HTTPTimeout.finish();
         }