src/third_party/WebKit/Source/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 "platform/PlatformExport.h"
  35 #include "platform/heap/Handle.h"
  36 #include "wtf/Assertions.h"
  37 #include "wtf/Forward.h"
  38 #include "wtf/PassOwnPtr.h"
  39 #include "wtf/PassRefPtr.h"
  40 #include "wtf/RawPtr.h"
  41 #include "wtf/RefPtr.h"
  42 #include "wtf/ThreadSafeRefCounted.h"
  43 #include "wtf/TypeTraits.h"
  44
  45 namespace blink {
  46
  47     class IntRect;
  48     class IntSize;
  49     class KURL;
  50     class ResourceError;
  51     class ResourceRequest;
  52     class ResourceResponse;
  53     struct CrossThreadResourceResponseData;
  54     struct CrossThreadResourceRequestData;
  55
  56     template<typename T> struct CrossThreadCopierPassThrough {
  57         typedef T Type;
  58         static Type copy(const T& parameter)
  59         {
  60             return parameter;
  61         }
  62     };
  63
  64     template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, bool isGarbageCollected, typename T> struct CrossThreadCopierBase;
  65
  66     // Integers get passed through without any changes.
  67     template<typename T> struct CrossThreadCopierBase<true, false, false, T> : public CrossThreadCopierPassThrough<T> {
  68     };
  69
  70     // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
  71     // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
  72     template<> struct CrossThreadCopierBase<false, false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
  73     };
  74
  75     template<> struct CrossThreadCopierBase<false, false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
  76     };
  77
  78     // Custom copy methods.
  79     template<typename T> struct CrossThreadCopierBase<false, true, false, T> {
  80         typedef typename WTF::RemoveTemplate<T, RefPtr>::Type TypeWithoutRefPtr;
  81         typedef typename WTF::RemoveTemplate<TypeWithoutRefPtr, PassRefPtr>::Type TypeWithoutPassRefPtr;
  82         typedef typename WTF::RemovePointer<TypeWithoutPassRefPtr>::Type RefCountedType;
  83
  84         // Verify that only one of the above did a change.
  85         COMPILE_ASSERT((WTF::IsSameType<RefPtr<RefCountedType>, T>::value
  86                         || WTF::IsSameType<PassRefPtr<RefCountedType>, T>::value
  87                         || WTF::IsSameType<RefCountedType*, T>::value),
  88                        OnlyAllowOneTypeModification);
  89
  90         typedef PassRefPtr<RefCountedType> Type;
  91         static Type copy(const T& refPtr)
  92         {
  93             return refPtr;
  94         }
  95     };
  96
  97     template<typename T> struct CrossThreadCopierBase<false, false, false, PassOwnPtr<T> > {
  98         typedef PassOwnPtr<T> Type;
  99         static Type copy(Type ownPtr)
 100         {
 101             return ownPtr;
 102         }
 103     };
 104
 105     template<typename T> struct CrossThreadCopierBase<false, false, false, WeakMember<T>*> {
 106         typedef WeakMember<T>* Type;
 107         static Type copy(Type ptr)
 108         {
 109             return ptr;
 110         }
 111     };
 112
 113     template<> struct CrossThreadCopierBase<false, false, false, KURL> {
 114         typedef KURL Type;
 115         PLATFORM_EXPORT static Type copy(const KURL&);
 116     };
 117
 118     template<> struct CrossThreadCopierBase<false, false, false, String> {
 119         typedef String Type;
 120         PLATFORM_EXPORT static Type copy(const String&);
 121     };
 122
 123     template<> struct CrossThreadCopierBase<false, false, false, ResourceError> {
 124         typedef ResourceError Type;
 125         PLATFORM_EXPORT static Type copy(const ResourceError&);
 126     };
 127
 128     template<> struct CrossThreadCopierBase<false, false, false, ResourceRequest> {
 129         typedef PassOwnPtr<CrossThreadResourceRequestData> Type;
 130         PLATFORM_EXPORT static Type copy(const ResourceRequest&);
 131     };
 132
 133     template<> struct CrossThreadCopierBase<false, false, false, ResourceResponse> {
 134         typedef PassOwnPtr<CrossThreadResourceResponseData> Type;
 135         PLATFORM_EXPORT static Type copy(const ResourceResponse&);
 136     };
 137
 138     template<typename T> struct CrossThreadCopierBase<false, false, true, T> {
 139         typedef typename WTF::RemovePointer<T>::Type TypeWithoutPointer;
 140         typedef RawPtr<TypeWithoutPointer> Type;
 141         static Type copy(const T& ptr)
 142         {
 143             return ptr;
 144         }
 145     };
 146
 147     template<typename T> struct CrossThreadCopierBase<false, false, true, RawPtr<T> > {
 148         typedef RawPtr<T> Type;
 149         static Type copy(const Type& ptr)
 150         {
 151             return ptr;
 152         }
 153     };
 154
 155     template<typename T> struct CrossThreadCopierBase<false, false, true, Member<T> > {
 156         typedef RawPtr<T> Type;
 157         static Type copy(const Member<T>& ptr)
 158         {
 159             return ptr;
 160         }
 161     };
 162
 163     template<typename T> struct CrossThreadCopierBase<false, false, true, WeakMember<T> > {
 164         typedef RawPtr<T> Type;
 165         static Type copy(const WeakMember<T>& ptr)
 166         {
 167             return ptr;
 168         }
 169     };
 170
 171     template<typename T> struct CrossThreadCopier : public CrossThreadCopierBase<WTF::IsConvertibleToInteger<T>::value,
 172         WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RefPtr>::Type, ThreadSafeRefCounted>::value
 173             || WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type, ThreadSafeRefCounted>::value
 174             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, PassRefPtr>::Type, ThreadSafeRefCounted>::value,
 175         WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type, GarbageCollected>::value
 176             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RawPtr>::Type, GarbageCollected>::value
 177             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, Member>::Type, GarbageCollected>::value
 178             || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, WeakMember>::Type, GarbageCollected>::value,
 179         T> {
 180     };
 181
 182     template<typename T> struct AllowCrossThreadAccessWrapper {
 183         STACK_ALLOCATED();
 184     public:
 185         explicit AllowCrossThreadAccessWrapper(T* value) : m_value(value) { }
 186         T* value() const { return m_value; }
 187     private:
 188         // This raw pointer is safe since AllowCrossThreadAccessWrapper is
 189         // always stack-allocated. Ideally this should be Member<T> if T is
 190         // garbage-collected and T* otherwise, but we don't want to introduce
 191         // another template magic just for distinguishing Member<T> from T*.
 192         // From the perspective of GC, T* always works correctly.
 193         GC_PLUGIN_IGNORE("")
 194         T* m_value;
 195     };
 196
 197     template<typename T> struct CrossThreadCopierBase<false, false, false, AllowCrossThreadAccessWrapper<T> > {
 198         typedef T* Type;
 199         static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
 200     };
 201
 202     template<typename T> AllowCrossThreadAccessWrapper<T> AllowCrossThreadAccess(T* value)
 203     {
 204         return AllowCrossThreadAccessWrapper<T>(value);
 205     }
 206
 207     // FIXME: Move to a different header file. AllowAccessLater is for cross-thread access
 208     // that is not cross-thread (tasks posted to a queue guaranteed to run on the same thread).
 209     template<typename T> struct AllowAccessLaterWrapper {
 210     public:
 211         explicit AllowAccessLaterWrapper(T* value) : m_value(value) { }
 212         T* value() const { return m_value; }
 213     private:
 214         T* m_value;
 215     };
 216
 217     template<typename T> struct CrossThreadCopierBase<false, false, false, AllowAccessLaterWrapper<T> > {
 218         typedef T* Type;
 219         static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
 220     };
 221
 222     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
 223     {
 224         return AllowAccessLaterWrapper<T>(value);
 225     }
 226
 227
 228 } // namespace blink
 229
 230 #endif // CrossThreadCopier_h