#ifndef AsyncRequest_h
#define AsyncRequest_h
#include <wtf/Function.h>
#include <wtf/HashMap.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>
namespace WebKit {
class AsyncRequest : public RefCounted<AsyncRequest> {
public:
virtual ~AsyncRequest();
uint64_t requestID() { return m_requestID; }
void setAbortHandler(WTF::Function<void ()>&&);
void requestAborted();
template<typename... Arguments> void completeRequest(Arguments&&... arguments);
protected:
explicit AsyncRequest(WTF::Function<void ()>&& abortHandler);
virtual void clearCompletionHandler() = 0;
WTF::Function<void ()> m_abortHandler;
private:
uint64_t m_requestID;
};
template <typename... Arguments>
class AsyncRequestImpl final : public AsyncRequest {
public:
template<typename T> using ArgumentType = typename std::conditional<std::is_integral<T>::value, T, const T&>::type;
static Ref<AsyncRequest> create(WTF::Function<void(ArgumentType<Arguments>...)>&& completionHandler)
{
return adoptRef(*new AsyncRequestImpl<Arguments...>(WTFMove(completionHandler), nullptr));
}
static Ref<AsyncRequest> create(WTF::Function<void(ArgumentType<Arguments>...)>&& completionHandler, WTF::Function<void()>&& abortHandler)
{
return adoptRef(*new AsyncRequestImpl<Arguments...>(WTFMove(completionHandler), WTFMove(abortHandler)));
}
virtual ~AsyncRequestImpl()
{
ASSERT(!m_completionHandler);
}
template<typename... RequestArguments>
void completeRequest(RequestArguments&&... arguments)
{
m_completionHandler(std::forward<RequestArguments>(arguments)...);
m_completionHandler = nullptr;
}
private:
AsyncRequestImpl(WTF::Function<void (ArgumentType<Arguments>...)>&& completionHandler, WTF::Function<void ()>&& abortHandler)
: AsyncRequest(WTFMove(abortHandler))
, m_completionHandler(WTFMove(completionHandler))
{
ASSERT(m_completionHandler);
}
void clearCompletionHandler() override
{
m_completionHandler = nullptr;
}
WTF::Function<void (ArgumentType<Arguments>...)> m_completionHandler;
};
template<typename... Arguments> void AsyncRequest::completeRequest(Arguments&&... arguments)
{
auto* request = static_cast<AsyncRequestImpl<typename std::decay<Arguments>::type...>*>(this);
request->completeRequest(std::forward<Arguments>(arguments)...);
m_abortHandler = nullptr;
}
class AsyncRequestMap {
public:
using RequestMap = HashMap<uint64_t, RefPtr<AsyncRequest>>;
AsyncRequestMap()
#ifndef NDEBUG
: m_lastRequestIDTaken(std::numeric_limits<uint64_t>::max())
#endif
{ }
Ref<AsyncRequest> take(uint64_t requestID)
{
#ifndef NDEBUG
ASSERT_WITH_MESSAGE(requestID != m_lastRequestIDTaken, "Attempt to take the same AsyncRequest twice in a row. A background queue might have dispatched both an error callback and a success callback?");
m_lastRequestIDTaken = requestID;
#endif
RefPtr<AsyncRequest> request = m_requestMap.take(requestID);
RELEASE_ASSERT(request);
return adoptRef(*request.leakRef());
}
void add(uint64_t requestID, RefPtr<AsyncRequest>&& request)
{
m_requestMap.add(requestID, WTFMove(request));
}
void clear()
{
m_requestMap.clear();
}
typename RequestMap::ValuesIteratorRange values()
{
return m_requestMap.values();
}
private:
RequestMap m_requestMap;
#ifndef NDEBUG
uint64_t m_lastRequestIDTaken;
#endif
};
}
#endif // AsyncRequest_h