1 files changed, 93 insertions, 4 deletions

diff --git a/chromium/third_party/WebKit/Source/wtf/TypeTraits.h b/chromium/third_party/WebKit/Source/wtf/TypeTraits.h
index 7942b7de165..95254c4299a 100644
--- a/chromium/third_party/WebKit/Source/wtf/TypeTraits.h
+++ b/chromium/third_party/WebKit/Source/wtf/TypeTraits.h
@@ -68,12 +68,19 @@ namespace WTF {
     template<> struct IsFloatingPoint<double>       { static const bool value = true; };
     template<> struct IsFloatingPoint<long double>  { static const bool value = true; };
 
-    template<typename T> struct IsArithmetic     { static const bool value = IsInteger<T>::value || IsFloatingPoint<T>::value; };
+    template<typename T> struct IsArithmetic        { static const bool value = IsInteger<T>::value || IsFloatingPoint<T>::value; };
+
+    template<typename T> struct IsWeak              { static const bool value = false; };
+
+    enum WeakHandlingFlag {
+        NoWeakHandlingInCollections,
+        WeakHandlingInCollections
+    };
 
     // IsPod is misnamed as it doesn't cover all plain old data (pod) types.
     // Specifically, it doesn't allow for enums or for structs.
-    template <typename T> struct IsPod           { static const bool value = IsArithmetic<T>::value; };
-    template <typename P> struct IsPod<P*>       { static const bool value = true; };
+    template <typename T> struct IsPod              { static const bool value = IsArithmetic<T>::value; };
+    template <typename P> struct IsPod<P*>          { static const bool value = true; };
 
     template<typename T> class IsConvertibleToInteger {
         // Avoid "possible loss of data" warning when using Microsoft's C++ compiler
@@ -162,6 +169,58 @@ namespace WTF {
         static const bool value = sizeof(subclassCheck(t)) == sizeof(YesType);
     };
 
+    template <typename T, template<typename V, size_t W> class U> class IsSubclassOfTemplateTypenameSize {
+        typedef char YesType;
+        struct NoType {
+            char padding[8];
+        };
+
+        template<typename X, size_t Y> static YesType subclassCheck(U<X, Y>*);
+        static NoType subclassCheck(...);
+        static T* t;
+    public:
+        static const bool value = sizeof(subclassCheck(t)) == sizeof(YesType);
+    };
+
+    template <typename T, template<typename V, size_t W, typename X> class U> class IsSubclassOfTemplateTypenameSizeTypename {
+        typedef char YesType;
+        struct NoType {
+            char padding[8];
+        };
+
+        template<typename Y, size_t Z, typename A> static YesType subclassCheck(U<Y, Z, A>*);
+        static NoType subclassCheck(...);
+        static T* t;
+    public:
+        static const bool value = sizeof(subclassCheck(t)) == sizeof(YesType);
+    };
+
+    template <typename T, template<class A, class B, class C> class U> class IsSubclassOfTemplate3 {
+        typedef char YesType;
+        struct NoType {
+            char padding[8];
+        };
+
+        template<typename D, typename E, typename F> static YesType subclassCheck(U<D, E, F>*);
+        static NoType subclassCheck(...);
+        static T* t;
+    public:
+        static const bool value = sizeof(subclassCheck(t)) == sizeof(YesType);
+    };
+
+    template <typename T, template<class A, class B, class C, class D, class E> class U> class IsSubclassOfTemplate5 {
+        typedef char YesType;
+        struct NoType {
+            char padding[8];
+        };
+
+        template<typename F, typename G, typename H, typename I, typename J> static YesType subclassCheck(U<F, G, H, I, J>*);
+        static NoType subclassCheck(...);
+        static T* t;
+    public:
+        static const bool value = sizeof(subclassCheck(t)) == sizeof(YesType);
+    };
+
     template <typename T, template <class V> class OuterTemplate> struct RemoveTemplate {
         typedef T Type;
     };
@@ -218,6 +277,11 @@ namespace WTF {
         typedef T Type;
     };
 
+    // Determines whether this type has a vtable.
+    template <typename T> struct IsPolymorphic {
+        static const bool value = __is_polymorphic(T);
+    };
+
 #define EnsurePtrConvertibleArgDecl(From, To) \
     typename WTF::EnableIf<WTF::IsPointerConvertible<From, To>::Value, bool>::Type = true
 #define EnsurePtrConvertibleArgDefn(From, To) \
@@ -242,7 +306,32 @@ namespace WTF {
         };
     };
 
-} // namespace WTF
+template<typename T>
+class NeedsTracing {
+    typedef char YesType;
+    typedef struct NoType {
+        char padding[8];
+    } NoType;
+
+#if COMPILER(MSVC)
+    template<typename V> static YesType checkHasTraceMethod(char[&V::trace != 0]);
+#else
+    template<size_t> struct HasMethod;
+    template<typename V> static YesType checkHasTraceMethod(HasMethod<sizeof(&V::trace)>*);
+#endif // COMPILER(MSVC)
+    template<typename V> static NoType checkHasTraceMethod(...);
+public:
+    static const bool value = sizeof(YesType) == sizeof(checkHasTraceMethod<T>(0));
+};
+
+// Convenience template wrapping the NeedsTracingLazily template in
+// Collection Traits. It helps make the code more readable.
+template<typename Traits>
+class ShouldBeTraced {
+public:
+    static const bool value = Traits::template NeedsTracingLazily<>::value;
+};
 
+} // namespace WTF
 
 #endif // TypeTraits_h