Update ParamStorageTraits to disallow raw pointers and Member<> (2/5)

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 22 matching lines @@
 #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;
+template <typename T> class Member;
 }
 
 namespace base {
 
 template <typename T>
 struct IsWeakReceiver<WTF::WeakPtr<T>> : std::true_type {};
 
 }
 
 namespace WTF {
@@ skipping 155 matching lines @@
     }
 
 private:
     R(C::*m_function)(Parameters...);
 };
 
 template <typename T>
 struct ParamStorageTraits {
     typedef T StorageType;
 
+    static_assert(!std::is_pointer<T>::value, "Raw pointer is not allowed to bind into WTF::Function. Wrap it with either Persistent, WeakPersistent, CrossThreadPersistent, CrossThreadWeakPersistent, RefPtr or unretained.");

[sof, 2016/06/24 11:37:19]

Shouldn't the error message be mentioning wrapPersistent() et al?

[tzik, 2016/06/24 13:13:33]

OK, replaced them to wrap*.

+    static_assert(!IsSubclassOfTemplate<T, blink::Member>::value, "Member is not allowed to bind into WTF::Function. Wrap it with either Persistent, WeakPersistent, CrossThreadPersistent or CrossThreadWeakPersistenst.");

[sof, 2016/06/24 11:37:19]

Add a case for WeakMember<>?

[tzik, 2016/06/24 13:13:33]

Done.

+
     static StorageType wrap(const T& value) { return value; } // Copy.
     static StorageType wrap(T&& value) { return std::move(value); }
 
     // Don't move out, because the functor may be called multiple times.
     static const T& unwrap(const StorageType& value) { return value; }
 };
 
 template <typename T>
 struct ParamStorageTraits<PassRefPtr<T>> {
     typedef RefPtr<T> StorageType;
@@ skipping 29 matching lines @@
 };
 
 template <typename T, FunctionThreadAffinity threadAffinity>
 struct ParamStorageTraits<UnretainedWrapper<T, threadAffinity>> {
     typedef UnretainedWrapper<T, threadAffinity> StorageType;
 
     static StorageType wrap(const UnretainedWrapper<T, threadAffinity>& value) { return value; }
     static T* unwrap(const StorageType& value) { return value.value(); }
 };
 
-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);
-};
-
 template<typename, FunctionThreadAffinity threadAffinity = SameThreadAffinity>
 class Function;
 
 template<FunctionThreadAffinity threadAffinity, typename R, typename... Args>
 class Function<R(Args...), threadAffinity> {
     USING_FAST_MALLOC(Function);
     WTF_MAKE_NONCOPYABLE(Function);
 public:
     virtual ~Function() { }
     virtual R operator()(Args... args) = 0;
@@ skipping 103 matching lines @@
 
 using WTF::passed;
 using WTF::unretained;
 using WTF::crossThreadUnretained;
 
 using WTF::Function;
 using WTF::SameThreadClosure;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h