CrossThreadCopier.h [plain text]
#ifndef CrossThreadCopier_h
#define CrossThreadCopier_h
#include <wtf/Assertions.h>
#include <wtf/Forward.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/Threading.h>
namespace WebCore {
class IntRect;
class IntSize;
class URL;
class ResourceError;
class ResourceRequest;
class ResourceResponse;
class SessionID;
struct CrossThreadResourceResponseData;
struct CrossThreadResourceRequestData;
struct ThreadableLoaderOptions;
struct CrossThreadCopierBaseHelper {
template<typename T> struct RemovePointer {
typedef T Type;
};
template<typename T> struct RemovePointer<T*> {
typedef T Type;
};
template<typename T> struct RemovePointer<RefPtr<T>> {
typedef T Type;
};
template<typename T> struct RemovePointer<PassRefPtr<T>> {
typedef T Type;
};
template<typename T> struct IsEnumOrConvertibleToInteger {
static const bool value = std::is_integral<T>::value || std::is_enum<T>::value || std::is_convertible<T, long double>::value;
};
template<typename T> struct IsThreadSafeRefCountedPointer {
static const bool value = std::is_convertible<typename RemovePointer<T>::Type*, ThreadSafeRefCounted<typename RemovePointer<T>::Type>*>::value;
};
};
template<typename T> struct CrossThreadCopierPassThrough {
typedef T Type;
static Type copy(const T& parameter)
{
return parameter;
}
};
template<bool isEnumOrConvertibleToInteger, bool isThreadSafeRefCounted, typename T> struct CrossThreadCopierBase;
template<typename T> struct CrossThreadCopierBase<true, false, T> : public CrossThreadCopierPassThrough<T> {
};
template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
};
template<> struct CrossThreadCopierBase<false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
};
template<typename T> struct CrossThreadCopierBase<false, true, T> {
typedef typename CrossThreadCopierBaseHelper::RemovePointer<T>::Type RefCountedType;
static_assert(std::is_convertible<RefCountedType*, ThreadSafeRefCounted<RefCountedType>*>::value, "T is not convertible to ThreadSafeRefCounted!");
typedef PassRefPtr<RefCountedType> Type;
WEBCORE_EXPORT static Type copy(const T& refPtr)
{
return refPtr;
}
};
template<> struct CrossThreadCopierBase<false, false, URL> {
typedef URL Type;
static Type copy(const URL&);
};
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, String> {
typedef String Type;
static Type copy(const String&);
};
template<> struct CrossThreadCopierBase<false, false, ResourceError> {
typedef ResourceError Type;
static Type copy(const ResourceError&);
};
template<> struct CrossThreadCopierBase<false, false, ResourceRequest> {
typedef std::unique_ptr<CrossThreadResourceRequestData> Type;
static Type copy(const ResourceRequest&);
};
template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {
typedef std::unique_ptr<CrossThreadResourceResponseData> Type;
static Type copy(const ResourceResponse&);
};
template<> struct CrossThreadCopierBase<false, false, SessionID> {
typedef SessionID Type;
static Type copy(const SessionID&);
};
#if ENABLE(INDEXED_DATABASE)
namespace IndexedDB {
enum class TransactionMode;
enum class CursorDirection;
enum class CursorType;
}
template<> struct CrossThreadCopierBase<false, false, IndexedDB::TransactionMode> {
WEBCORE_EXPORT static IndexedDB::TransactionMode copy(const IndexedDB::TransactionMode&);
};
template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorDirection> {
WEBCORE_EXPORT static IndexedDB::CursorDirection copy(const IndexedDB::CursorDirection&);
};
template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorType> {
WEBCORE_EXPORT static IndexedDB::CursorType copy(const IndexedDB::CursorType&);
};
struct IDBDatabaseMetadata;
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBDatabaseMetadata> {
typedef IDBDatabaseMetadata Type;
static Type copy(const IDBDatabaseMetadata&);
};
struct IDBGetResult;
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBGetResult> {
typedef IDBGetResult Type;
static Type copy(const IDBGetResult&);
};
struct IDBIndexMetadata;
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBIndexMetadata> {
typedef IDBIndexMetadata Type;
static Type copy(const IDBIndexMetadata&);
};
struct IDBKeyData;
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBKeyData> {
typedef IDBKeyData Type;
static Type copy(const IDBKeyData&);
};
struct IDBKeyRangeData;
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBKeyRangeData> {
typedef IDBKeyRangeData Type;
static Type copy(const IDBKeyRangeData&);
};
struct IDBObjectStoreMetadata;
template<> struct WEBCORE_EXPORT CrossThreadCopierBase<false, false, IDBObjectStoreMetadata> {
typedef IDBObjectStoreMetadata Type;
static Type copy(const IDBObjectStoreMetadata&);
};
#endif
template<typename T>
struct CrossThreadCopier : public CrossThreadCopierBase<CrossThreadCopierBaseHelper::IsEnumOrConvertibleToInteger<T>::value, CrossThreadCopierBaseHelper::IsThreadSafeRefCountedPointer<T>::value, T> {
};
template<typename T> struct AllowCrossThreadAccessWrapper {
public:
explicit AllowCrossThreadAccessWrapper(T* value) : m_value(value) { }
T* value() const { return m_value; }
private:
T* m_value;
};
template<typename T> struct CrossThreadCopierBase<false, false, AllowCrossThreadAccessWrapper<T>> {
typedef T* Type;
static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
};
template<typename T> AllowCrossThreadAccessWrapper<T> AllowCrossThreadAccess(T* value)
{
return AllowCrossThreadAccessWrapper<T>(value);
}
template<typename T> struct AllowAccessLaterWrapper {
public:
explicit AllowAccessLaterWrapper(T* value) : m_value(value) { }
T* value() const { return m_value; }
private:
T* m_value;
};
template<typename T> struct CrossThreadCopierBase<false, false, AllowAccessLaterWrapper<T>> {
typedef T* Type;
static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
};
template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
{
return AllowAccessLaterWrapper<T>(value);
}
}
#endif // CrossThreadCopier_h