[core] Use std::unique_ptr for FileSource request

2 files changed, 66 insertions, 58 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_;
 };