Source/WebCore/platform/CrossThreadCopier.h

   1 /*
   2  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef CrossThreadCopier_h
  32 #define CrossThreadCopier_h
  33
  34 #include <wtf/Assertions.h>
  35 #include <wtf/Forward.h>
  36 #include <wtf/PassOwnPtr.h>
  37 #include <wtf/PassRefPtr.h>
  38 #include <wtf/RefPtr.h>
  39 #include <wtf/Threading.h>
  40
  41 namespace WebCore {
  42
  43     class IntRect;
  44     class IntSize;
  45     class URL;
  46     class ResourceError;
  47     class ResourceRequest;
  48     class ResourceResponse;
  49     struct CrossThreadResourceResponseData;
  50     struct CrossThreadResourceRequestData;
  51     struct ThreadableLoaderOptions;
  52
  53     struct CrossThreadCopierBaseHelper {
  54         template<typename T> struct RemovePointer {
  55             typedef T Type;
  56         };
  57         template<typename T> struct RemovePointer<T*> {
  58             typedef T Type;
  59         };
  60
  61         template<typename T> struct RemovePointer<RefPtr<T>> {
  62             typedef T Type;
  63         };
  64
  65         template<typename T> struct RemovePointer<PassRefPtr<T>> {
  66             typedef T Type;
  67         };
  68
  69         template<typename T> struct IsConvertibleToInteger {
  70             static const bool value = std::is_integral<T>::value || std::is_convertible<T, long double>::value;
  71         };
  72
  73         template<typename T> struct IsThreadSafeRefCountedPointer {
  74             static const bool value = std::is_convertible<typename RemovePointer<T>::Type*, ThreadSafeRefCounted<typename RemovePointer<T>::Type>*>::value;
  75         };
  76     };
  77
  78     template<typename T> struct CrossThreadCopierPassThrough {
  79         typedef T Type;
  80         static Type copy(const T& parameter)
  81         {
  82             return parameter;
  83         }
  84     };
  85
  86     template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, typename T> struct CrossThreadCopierBase;
  87
  88     // Integers get passed through without any changes.
  89     template<typename T> struct CrossThreadCopierBase<true, false, T> : public CrossThreadCopierPassThrough<T> {
  90     };
  91
  92     // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
  93     // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
  94     template<> struct CrossThreadCopierBase<false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
  95     };
  96
  97     template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
  98     };
  99
 100     template<> struct CrossThreadCopierBase<false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
 101     };
 102
 103     // Custom copy methods.
 104     template<typename T> struct CrossThreadCopierBase<false, true, T> {
 105         typedef typename CrossThreadCopierBaseHelper::RemovePointer<T>::Type RefCountedType;
 106         static_assert(std::is_convertible<RefCountedType*, ThreadSafeRefCounted<RefCountedType>*>::value, "T is not convertible to ThreadSafeRefCounted!");
 107
 108         typedef PassRefPtr<RefCountedType> Type;
 109         static Type copy(const T& refPtr)
 110         {
 111             return refPtr;
 112         }
 113     };
 114
 115     template<typename T> struct CrossThreadCopierBase<false, false, PassOwnPtr<T>> {
 116         typedef PassOwnPtr<T> Type;
 117         static Type copy(Type ownPtr)
 118         {
 119             return ownPtr;
 120         }
 121     };
 122
 123     template<> struct CrossThreadCopierBase<false, false, URL> {
 124         typedef URL Type;
 125         static Type copy(const URL&);
 126     };
 127
 128     template<> struct CrossThreadCopierBase<false, false, String> {
 129         typedef String Type;
 130         static Type copy(const String&);
 131     };
 132
 133     template<> struct CrossThreadCopierBase<false, false, ResourceError> {
 134         typedef ResourceError Type;
 135         static Type copy(const ResourceError&);
 136     };
 137
 138     template<> struct CrossThreadCopierBase<false, false, ResourceRequest> {
 139         typedef PassOwnPtr<CrossThreadResourceRequestData> Type;
 140         static Type copy(const ResourceRequest&);
 141     };
 142
 143     template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {
 144         typedef PassOwnPtr<CrossThreadResourceResponseData> Type;
 145         static Type copy(const ResourceResponse&);
 146     };
 147
 148 #if ENABLE(INDEXED_DATABASE)
 149     namespace IndexedDB {
 150         enum class TransactionMode;
 151         enum class CursorDirection;
 152         enum class CursorType;
 153     }
 154     template<> struct CrossThreadCopierBase<false, false, IndexedDB::TransactionMode> {
 155         static IndexedDB::TransactionMode copy(const IndexedDB::TransactionMode&);
 156     };
 157     template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorDirection> {
 158         static IndexedDB::CursorDirection copy(const IndexedDB::CursorDirection&);
 159     };
 160     template<> struct CrossThreadCopierBase<false, false, IndexedDB::CursorType> {
 161         static IndexedDB::CursorType copy(const IndexedDB::CursorType&);
 162     };
 163
 164     struct IDBDatabaseMetadata;
 165     template<> struct CrossThreadCopierBase<false, false, IDBDatabaseMetadata> {
 166         typedef IDBDatabaseMetadata Type;
 167         static Type copy(const IDBDatabaseMetadata&);
 168     };
 169
 170     struct IDBIndexMetadata;
 171     template<> struct CrossThreadCopierBase<false, false, IDBIndexMetadata> {
 172         typedef IDBIndexMetadata Type;
 173         static Type copy(const IDBIndexMetadata&);
 174     };
 175
 176     struct IDBKeyData;
 177     template<> struct CrossThreadCopierBase<false, false, IDBKeyData> {
 178         typedef IDBKeyData Type;
 179         static Type copy(const IDBKeyData&);
 180     };
 181
 182     struct IDBObjectStoreMetadata;
 183     template<> struct CrossThreadCopierBase<false, false, IDBObjectStoreMetadata> {
 184         typedef IDBObjectStoreMetadata Type;
 185         static Type copy(const IDBObjectStoreMetadata&);
 186     };
 187 #endif
 188
 189     template<typename T>
 190     struct CrossThreadCopier : public CrossThreadCopierBase<CrossThreadCopierBaseHelper::IsConvertibleToInteger<T>::value, CrossThreadCopierBaseHelper::IsThreadSafeRefCountedPointer<T>::value, T> {
 191     };
 192
 193     template<typename T> struct AllowCrossThreadAccessWrapper {
 194     public:
 195         explicit AllowCrossThreadAccessWrapper(T* value) : m_value(value) { }
 196         T* value() const { return m_value; }
 197     private:
 198         T* m_value;
 199     };
 200
 201     template<typename T> struct CrossThreadCopierBase<false, false, AllowCrossThreadAccessWrapper<T>> {
 202         typedef T* Type;
 203         static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
 204     };
 205
 206     template<typename T> AllowCrossThreadAccessWrapper<T> AllowCrossThreadAccess(T* value)
 207     {
 208         return AllowCrossThreadAccessWrapper<T>(value);
 209     }
 210
 211     // FIXME: Move to a different header file. AllowAccessLater is for cross-thread access
 212     // that is not cross-thread (tasks posted to a queue guaranteed to run on the same thread).
 213     template<typename T> struct AllowAccessLaterWrapper {
 214     public:
 215         explicit AllowAccessLaterWrapper(T* value) : m_value(value) { }
 216         T* value() const { return m_value; }
 217     private:
 218         T* m_value;
 219     };
 220
 221     template<typename T> struct CrossThreadCopierBase<false, false, AllowAccessLaterWrapper<T>> {
 222         typedef T* Type;
 223         static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
 224     };
 225
 226     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
 227     {
 228         return AllowAccessLaterWrapper<T>(value);
 229     }
 230
 231
 232 } // namespace WebCore
 233
 234 #endif // CrossThreadCopier_h