CrossThreadCopier.h [plain text]
#pragma once
#include <wtf/Assertions.h>
#include <wtf/Forward.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/Threading.h>
#include <wtf/text/WTFString.h>
namespace WTF {
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<class T> struct CrossThreadCopierBase<false, false, T> {
static T copy(const T& value)
{
return value.isolatedCopy();
}
};
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;
static Type copy(const T& refPtr)
{
return refPtr;
}
};
template<> struct CrossThreadCopierBase<false, false, std::chrono::system_clock::time_point> {
typedef std::chrono::system_clock::time_point Type;
static Type copy(const Type& source)
{
return source;
}
};
template<> struct CrossThreadCopierBase<false, false, WTF::ASCIILiteral> {
typedef WTF::ASCIILiteral Type;
static Type copy(const Type& source)
{
return source;
}
};
template<typename T>
struct CrossThreadCopier : public CrossThreadCopierBase<CrossThreadCopierBaseHelper::IsEnumOrConvertibleToInteger<T>::value, CrossThreadCopierBaseHelper::IsThreadSafeRefCountedPointer<T>::value, T> {
};
template<typename T> struct CrossThreadCopierBase<false, false, Vector<T>> {
typedef Vector<T> Type;
static Type copy(const Type& source)
{
Type destination;
destination.reserveInitialCapacity(source.size());
for (auto& object : source)
destination.uncheckedAppend(CrossThreadCopier<T>::copy(object));
return destination;
}
};
}
using WTF::CrossThreadCopierBaseHelper;
using WTF::CrossThreadCopierBase;
using WTF::CrossThreadCopier;