Expose Web Animations API to Web Workers

Source/platform/CrossThreadCopier.h

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 23 matching lines @@
 #include "platform/PlatformExport.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
 #include "wtf/Forward.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/TypeTraits.h"
+#include "wtf/Vector.h"
+#include "wtf/text/WTFString.h"
 
 namespace blink {
 
     class IntRect;
     class IntSize;
     class KURL;
     class ResourceError;
     class ResourceRequest;
     class ResourceResponse;
+    class RemotePlayer;
     struct CrossThreadResourceResponseData;
     struct CrossThreadResourceRequestData;
     struct ThreadableLoaderOptions;
     struct ResourceLoaderOptions;
+    struct Timing;
+    struct ProxyKeyframe;
+    struct ProxyPairs;
 
     template<typename T> struct CrossThreadCopierPassThrough {
         typedef T Type;
         static Type copy(const T& parameter)
         {
             return parameter;
         }
     };
 
     template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, bool isGarbageCollected, typename T> struct CrossThreadCopierBase;
 
     // Integers get passed through without any changes.
     template<typename T> struct CrossThreadCopierBase<true, 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, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
     };
 
     template<> struct CrossThreadCopierBase<false, false, false, ResourceLoaderOptions> : public CrossThreadCopierPassThrough<ResourceLoaderOptions> {
     };
 
+    template<> struct CrossThreadCopierBase<false, false, false, Timing> : public CrossThreadCopierPassThrough<Timing> {
+    };
+
+    template<> struct CrossThreadCopierBase<false, false, false, RemotePlayer*> : public CrossThreadCopierPassThrough<RemotePlayer*> {
+    };
+
+    template<> struct CrossThreadCopierBase<false, false, false, Vector<ProxyPairs> > : public CrossThreadCopierPassThrough<Vector<ProxyPairs> > {
+    };
+
+    template<> struct CrossThreadCopierBase<false, false, false, ProxyKeyframe> : public CrossThreadCopierPassThrough<ProxyKeyframe> {
+    };
+
+    template<> struct CrossThreadCopierBase<false, false, false, Vector<ProxyKeyframe> > : public CrossThreadCopierPassThrough<Vector<ProxyKeyframe> > {
+    };
+
+    template<> struct CrossThreadCopierBase<false, false, false, Vector<String> > : public CrossThreadCopierPassThrough<Vector<String> > {
+    };
+
     template<> struct CrossThreadCopierBase<false, false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
     };
 
     template<> struct CrossThreadCopierBase<false, false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
     };
 
     // Custom copy methods.
     template<typename T> struct CrossThreadCopierBase<false, true, false, T> {
         typedef typename WTF::RemoveTemplate<T, RefPtr>::Type TypeWithoutRefPtr;
         typedef typename WTF::RemoveTemplate<TypeWithoutRefPtr, PassRefPtr>::Type TypeWithoutPassRefPtr;
@@ skipping 132 matching lines @@
 
     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
     {
         return AllowAccessLaterWrapper<T>(value);
     }
 
 
 } // namespace blink
 
 #endif // CrossThreadCopier_h