#ifndef GenericCallback_h
#define GenericCallback_h
#include "ShareableBitmap.h"
#include "WKAPICast.h"
#include "WebError.h"
#include <wtf/HashMap.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
namespace WebKit {
class CallbackBase : public RefCounted<CallbackBase> {
public:
virtual ~CallbackBase()
{
}
uint64_t callbackID() const { return m_callbackID; }
protected:
explicit CallbackBase(void* context)
: m_context(context)
, m_callbackID(generateCallbackID())
{
}
void* context() const { return m_context; }
private:
static uint64_t generateCallbackID()
{
static uint64_t uniqueCallbackID = 1;
return uniqueCallbackID++;
}
void* m_context;
uint64_t m_callbackID;
};
class VoidCallback : public CallbackBase {
public:
typedef void (*CallbackFunction)(WKErrorRef, void*);
static PassRefPtr<VoidCallback> create(void* context, CallbackFunction callback)
{
return adoptRef(new VoidCallback(context, callback));
}
virtual ~VoidCallback()
{
ASSERT(!m_callback);
}
void performCallback()
{
if (!m_callback)
return;
m_callback(0, context());
m_callback = 0;
}
void invalidate()
{
if (!m_callback)
return;
RefPtr<WebError> error = WebError::create();
m_callback(toAPI(error.get()), context());
m_callback = 0;
}
private:
VoidCallback(void* context, CallbackFunction callback)
: CallbackBase(context)
, m_callback(callback)
{
}
CallbackFunction m_callback;
};
template<typename APIReturnValueType, typename InternalReturnValueType = typename APITypeInfo<APIReturnValueType>::ImplType>
class GenericCallback : public CallbackBase {
public:
typedef void (*CallbackFunction)(APIReturnValueType, WKErrorRef, void*);
static PassRefPtr<GenericCallback> create(void* context, CallbackFunction callback)
{
return adoptRef(new GenericCallback(context, callback));
}
virtual ~GenericCallback()
{
ASSERT(!m_callback);
}
void performCallbackWithReturnValue(InternalReturnValueType returnValue)
{
ASSERT(m_callback);
m_callback(toAPI(returnValue), 0, context());
m_callback = 0;
}
void invalidate()
{
ASSERT(m_callback);
RefPtr<WebError> error = WebError::create();
m_callback(0, toAPI(error.get()), context());
m_callback = 0;
}
private:
GenericCallback(void* context, CallbackFunction callback)
: CallbackBase(context)
, m_callback(callback)
{
}
CallbackFunction m_callback;
};
class ComputedPagesCallback : public CallbackBase {
public:
typedef void (*CallbackFunction)(const Vector<WebCore::IntRect>&, double, WKErrorRef, void*);
static PassRefPtr<ComputedPagesCallback> create(void* context, CallbackFunction callback)
{
return adoptRef(new ComputedPagesCallback(context, callback));
}
virtual ~ComputedPagesCallback()
{
ASSERT(!m_callback);
}
void performCallbackWithReturnValue(const Vector<WebCore::IntRect>& returnValue1, double returnValue2)
{
ASSERT(m_callback);
m_callback(returnValue1, returnValue2, 0, context());
m_callback = 0;
}
void invalidate()
{
ASSERT(m_callback);
RefPtr<WebError> error = WebError::create();
m_callback(Vector<WebCore::IntRect>(), 0, toAPI(error.get()), context());
m_callback = 0;
}
private:
ComputedPagesCallback(void* context, CallbackFunction callback)
: CallbackBase(context)
, m_callback(callback)
{
}
CallbackFunction m_callback;
};
class ImageCallback : public CallbackBase {
public:
typedef void (*CallbackFunction)(const ShareableBitmap::Handle&, WKErrorRef, void*);
static PassRefPtr<ImageCallback> create(void* context, CallbackFunction callback)
{
return adoptRef(new ImageCallback(context, callback));
}
virtual ~ImageCallback()
{
ASSERT(!m_callback);
}
void performCallbackWithReturnValue(const ShareableBitmap::Handle& returnValue1)
{
ASSERT(m_callback);
m_callback(returnValue1, 0, context());
m_callback = 0;
}
void invalidate()
{
ASSERT(m_callback);
RefPtr<WebError> error = WebError::create();
ShareableBitmap::Handle handle;
m_callback(handle, toAPI(error.get()), context());
m_callback = 0;
}
private:
ImageCallback(void* context, CallbackFunction callback)
: CallbackBase(context)
, m_callback(callback)
{
}
CallbackFunction m_callback;
};
template<typename T>
void invalidateCallbackMap(HashMap<uint64_t, T>& map)
{
Vector<T> callbacksVector;
copyValuesToVector(map, callbacksVector);
for (size_t i = 0, size = callbacksVector.size(); i < size; ++i)
callbacksVector[i]->invalidate();
map.clear();
}
}
#endif // GenericCallback_h