Name all the GLib timeout sources
[WebKit-https.git] / Source / WebCore / platform / CrossThreadCopier.h
index a25d6fa..c77c91b 100644 (file)
 #ifndef CrossThreadCopier_h
 #define CrossThreadCopier_h
 
+#include <wtf/Assertions.h>
 #include <wtf/Forward.h>
 #include <wtf/PassOwnPtr.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 #include <wtf/Threading.h>
-#include <wtf/TypeTraits.h>
 
 namespace WebCore {
 
-    class KURL;
+    class IntRect;
+    class IntSize;
+    class URL;
     class ResourceError;
     class ResourceRequest;
     class ResourceResponse;
@@ -48,6 +50,31 @@ namespace WebCore {
     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 IsConvertibleToInteger {
+            static const bool value = std::is_integral<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)
@@ -62,25 +89,30 @@ namespace WebCore {
     template<typename T> struct CrossThreadCopierBase<true, false, T> : public CrossThreadCopierPassThrough<T> {
     };
 
-    // Pointers get passed through without any significant changes.
-    template<typename T> struct CrossThreadCopierBase<false, false, T*> : public CrossThreadCopierPassThrough<T*> {
+    // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
+    // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
+    template<> struct CrossThreadCopierBase<false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
     };
 
-    template<> struct CrossThreadCopierBase<false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
+    template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
+    };
+
+    template<> struct CrossThreadCopierBase<false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
     };
 
     // Custom copy methods.
     template<typename T> struct CrossThreadCopierBase<false, true, T> {
-        typedef typename WTF::RemoveTemplate<T, RefPtr>::Type TypeWithoutRefPtr;
-        typedef typename WTF::RemoveTemplate<TypeWithoutRefPtr, PassRefPtr>::Type RefCountedType;
+        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.get();
+            return refPtr;
         }
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, PassOwnPtr<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, PassOwnPtr<T>> {
         typedef PassOwnPtr<T> Type;
         static Type copy(Type ownPtr)
         {
@@ -88,9 +120,9 @@ namespace WebCore {
         }
     };
 
-    template<> struct CrossThreadCopierBase<false, false, KURL> {
-        typedef KURL Type;
-        static Type copy(const KURL&);
+    template<> struct CrossThreadCopierBase<false, false, URL> {
+        typedef URL Type;
+        static Type copy(const URL&);
     };
 
     template<> struct CrossThreadCopierBase<false, false, String> {
@@ -113,12 +145,49 @@ namespace WebCore {
         static Type copy(const ResourceResponse&);
     };
 
-    template<typename T> struct CrossThreadCopier : public CrossThreadCopierBase<WTF::IsConvertibleToInteger<T>::value,
-                                                                                 WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RefPtr>::Type, ThreadSafeRefCounted>::value
-                                                                                     || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, PassRefPtr>::Type, ThreadSafeRefCounted>::value,
-                                                                                 T> {
+    template<typename T>
+    struct CrossThreadCopier : public CrossThreadCopierBase<CrossThreadCopierBaseHelper::IsConvertibleToInteger<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);
+    }
+
+    // FIXME: Move to a different header file. AllowAccessLater is for cross-thread access
+    // that is not cross-thread (tasks posted to a queue guaranteed to run on the same thread).
+    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);
+    }
+
+
 } // namespace WebCore
 
 #endif // CrossThreadCopier_h