Unify and provide one IsGarbageCollectedType<T> implementation.

third_party/WebKit/Source/wtf/Functional.h

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 16 matching lines @@
 #define WTF_Functional_h
 
 #include "base/tuple.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
+#include "wtf/TypeTraits.h"
 #include "wtf/WeakPtr.h"
 #include <tuple>
 #include <utility>
 
+namespace blink {
+template<typename T> class CrossThreadPersistent;
+}
+
 namespace WTF {
 
 // Functional.h provides a very simple way to bind a function pointer and arguments together into a function object
 // that can be stored, copied and invoked, similar to how boost::bind and std::bind in C++11.
 
 // Thread Safety:
 //
 // WTF::bind() and SameThreadClosure should be used for same-thread closures
 // only, i.e. the closures must be created, executed and destructed on
 // the same thread.
@@ skipping 174 matching lines @@
 };
 
 template <typename T>
 struct ParamStorageTraits<PassedWrapper<T>> {
     typedef PassedWrapper<T> StorageType;
 
     static StorageType wrap(PassedWrapper<T>&& value) { return std::move(value); }
     static T unwrap(StorageType& value) { return value.moveOut(); }
 };
 
+template<typename T, bool isGarbageCollected> struct PointerParamStorageTraits;
+
+template<typename T>
+struct PointerParamStorageTraits<T*, false> {
+    STATIC_ONLY(PointerParamStorageTraits);
+    using StorageType = T*;
+
+    static StorageType wrap(T* value) { return value; }
+    static T* unwrap(const StorageType& value) { return value; }
+};
+
+template<typename T>
+struct PointerParamStorageTraits<T*, true> {
+    STATIC_ONLY(PointerParamStorageTraits);
+    using StorageType = blink::CrossThreadPersistent<T>;
+
+    static StorageType wrap(T* value) { return value; }
+    static T* unwrap(const StorageType& value) { return value.get(); }
+};
+
+template<typename T>
+struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, IsGarbageCollectedType<T>::value> {
+    STATIC_ONLY(ParamStorageTraits);
+};
+
 enum FunctionThreadAffinity {
     CrossThreadAffinity,
     SameThreadAffinity
 };
 
 template<typename, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
 class Function;
 
 template<FunctionThreadAffinity threadAffinity, typename R, typename... Args>
 class Function<R(Args...), threadAffinity> {
@@ skipping 101 matching lines @@
 
 } // namespace WTF
 
 using WTF::passed;
 using WTF::Function;
 using WTF::bind;
 using WTF::SameThreadClosure;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h