Introduce WTF::unretained() and WTF::crossThreadUnretained()

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 80 matching lines @@
 //     ...
 //     std::unique_ptr<Function<void()>> functor = bind(yourFunction, passed(Argument()));
 //     ...
 //     (*functor)();
 //
 // The underlying function must receive the argument wrapped by passed() by rvalue reference or by value.
 //
 // Obviously, if you create a functor this way, you shouldn't call the functor twice or more; after the second call,
 // the passed argument may be invalid.
 
+enum FunctionThreadAffinity {
+    CrossThreadAffinity,
+    SameThreadAffinity
+};
+
 template <typename T>
 class PassedWrapper final {
 public:
     explicit PassedWrapper(T&& scoper) : m_scoper(std::move(scoper)) { }
     PassedWrapper(PassedWrapper&& other) : m_scoper(std::move(other.m_scoper)) { }
     T moveOut() { return std::move(m_scoper); }
 
 private:
     T m_scoper;
 };
 
 template <typename T>
 PassedWrapper<T> passed(T&& value)
 {
     static_assert(!std::is_reference<T>::value,
         "You must pass an rvalue to passed() so it can be moved. Add std::move() if necessary.");
     static_assert(!std::is_const<T>::value, "|value| must not be const so it can be moved.");
     return PassedWrapper<T>(std::move(value));
 }
 
+template <typename T, FunctionThreadAffinity threadAffinity>
+class UnretainedWrapper final {
+public:
+    explicit UnretainedWrapper(T* ptr) : m_ptr(ptr) { }
+    T* value() const { return m_ptr; }
+
+private:
+    T* m_ptr;
+};
+
+template <typename T>
+UnretainedWrapper<T, SameThreadAffinity> unretained(T* value)
+{
+    static_assert(!WTF::IsGarbageCollectedType<T>::value, "unretained() + GCed type is forbidden");
+    return UnretainedWrapper<T, SameThreadAffinity>(value);
+}
+
+template <typename T>
+UnretainedWrapper<T, CrossThreadAffinity> crossThreadUnretained(T* value)
+{
+    static_assert(!WTF::IsGarbageCollectedType<T>::value, "crossThreadUnretained() + GCed type is forbidden");
+    return UnretainedWrapper<T, CrossThreadAffinity>(value);
+}
+
 // A FunctionWrapper is a class template that can wrap a function pointer or a member function pointer and
 // provide a unified interface for calling that function.
 template <typename>
 class FunctionWrapper;
 
 // Bound static functions:
 template <typename R, typename... Parameters>
 class FunctionWrapper<R(*)(Parameters...)> {
     DISALLOW_NEW();
 public:
@@ skipping 93 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, 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);
 };
 
-enum FunctionThreadAffinity {
-    CrossThreadAffinity,
-    SameThreadAffinity
-};
-
 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 92 matching lines @@
 std::unique_ptr<Function<base::MakeUnboundRunType<FunctionType, BoundParameters...>, SameThreadAffinity>> bind(FunctionType function, BoundParameters&&... boundParameters)
 {
     return bindInternal<SameThreadAffinity>(function, std::forward<BoundParameters>(boundParameters)...);
 }
 
 typedef Function<void(), SameThreadAffinity> SameThreadClosure;
 typedef Function<void(), CrossThreadAffinity> CrossThreadClosure;
 
 } // namespace WTF
 
+using WTF::bind;
+
 using WTF::passed;
+using WTF::unretained;
+using WTF::crossThreadUnretained;
+
 using WTF::Function;
-using WTF::bind;
 using WTF::SameThreadClosure;
 using WTF::CrossThreadClosure;
 
 #endif // WTF_Functional_h