Unify and provide one IsGarbageCollectedType<T> implementation.

third_party/WebKit/Source/wtf/TypeTraits.h

  /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 282 matching lines @@
     static const bool value = sizeof(checkMarker<T>(nullptr)) == sizeof(YesType);
 };
 
 template<typename T>
 class IsGarbageCollectedType {
     typedef char YesType;
     typedef struct NoType {
         char padding[8];
     } NoType;
 
+    static_assert(sizeof(T), "T must be fully defined");
+
+    using NonConstType = typename std::remove_const<T>::type;
     template <typename U> static YesType checkGarbageCollectedType(typename U::IsGarbageCollectedTypeMarker*);
     template <typename U> static NoType checkGarbageCollectedType(...);
+
+    // Separately check for GarbageCollectedMixin, which declares a different
+    // marker typedef, to avoid resolution ambiguity for cases like
+    // IsGarbageCollectedType<B> over:
+    //
+    //    class A : public GarbageCollected<A>, public GarbageCollectedMixin {
+    //        USING_GARBAGE_COLLECTED_MIXIN(A);
+    //        ...
+    //    };
+    //    class B : public A, public GarbageCollectedMixin { ... };
+    //
+    template <typename U> static YesType checkGarbageCollectedMixinType(typename U::IsGarbageCollectedMixinMarker*);
+    template <typename U> static NoType checkGarbageCollectedMixinType(...);
 public:
-    static const bool value = (sizeof(YesType) == sizeof(checkGarbageCollectedType<T>(nullptr)));
+    static const bool value = (sizeof(YesType) == sizeof(checkGarbageCollectedType<NonConstType>(nullptr)))
+        || (sizeof(YesType) == sizeof(checkGarbageCollectedMixinType<NonConstType>(nullptr)));
+};
+
+template<>
+class IsGarbageCollectedType<void> {
+public:
+    static const bool value = false;
 };
 
 template<typename T>
 class IsPersistentReferenceType {
     typedef char YesType;
     typedef struct NoType {
         char padding[8];
     } NoType;
 
     template <typename U> static YesType checkPersistentReferenceType(typename U::IsPersistentReferenceTypeMarker*);
     template <typename U> static NoType checkPersistentReferenceType(...);
 public:
     static const bool value = (sizeof(YesType) == sizeof(checkPersistentReferenceType<T>(nullptr)));
 };
 
-template<typename T>
+template<typename T, bool = std::is_function<typename std::remove_const<typename std::remove_pointer<T>::type>::type>::value || std::is_void<typename std::remove_const<typename std::remove_pointer<T>::type>::type>::value>
 class IsPointerToGarbageCollectedType {
 public:
     static const bool value = false;
 };
+
 template<typename T>
-class IsPointerToGarbageCollectedType<T*> {
+class IsPointerToGarbageCollectedType<T*, false> {
 public:
     static const bool value = IsGarbageCollectedType<T>::value;
 };
 
 } // namespace WTF
 
+using WTF::IsGarbageCollectedType;
+
 #endif // TypeTraits_h