Support move-only type on base::Callback::Run

base/bind_helpers.h

Index: base/bind_helpers.h
diff --git a/base/bind_helpers.h b/base/bind_helpers.h
index 660348e667c102b526b13a1d46a6c720cf30b293..a551465ce8148430a7a62747cd909db8f5ecd284 100644
--- a/base/bind_helpers.h
+++ b/base/bind_helpers.h
@@ -563,15 +563,12 @@ static inline internal::OwnedWrapper<T> Owned(T* o) {
 // Both versions of Passed() prevent T from being an lvalue reference. The first
 // via use of enable_if, and the second takes a T* which will not bind to T&.
 template <typename T,
-          typename std::enable_if<internal::IsMoveOnlyType<T>::value &&
-                                  !std::is_lvalue_reference<T>::value>::type* =
+          typename std::enable_if<!std::is_lvalue_reference<T>::value>::type* =

[dcheng, 2016/03/02 00:25:45]

Is it worth trying to catch that the type is movable? Does
Passed(ReturnCopyOnlyObject()) compile?

[tzik, 2016/03/02 01:04:21]

I think there's no good way to detect the type is movable but not copyable.
Sure, it's detectable if its move-constructor is explicitly deleted, but if it
just has a copy-ctor and doesn't have move-ctor, std::is_move_constructible
returns true.
And, the deleted move-constructor on a copyable type doesn't semantically make
sense to me.

[dcheng, 2016/03/02 08:06:51]

FWIW, I don't think it's that hard to end up with a copyable but not movable
class: won't this be the case for any struct/class with const fields?

However, I guess this is fine: std::move() already can't warn if you call it on
something with no move constructor, so this should be something that developers
already know about.

[tzik, 2016/03/02 12:44:51]

Ah sorry, I told something incorrect.
I meant, it's hard to detect if a copyable class is efficiently movable. If a
class has a copy-ctor but doesn't have a move-ctor, its move-construction is
fallback to a copy. Such a class is detected as movable, even if it's not
lightweight. But, I think we can't detect this and reject it as a CopyOnly
object.

               nullptr>
 static inline internal::PassedWrapper<T> Passed(T&& scoper) {
   return internal::PassedWrapper<T>(std::move(scoper));
 }
-template <typename T,
-          typename std::enable_if<internal::IsMoveOnlyType<T>::value>::type* =
-              nullptr>
+template <typename T>
 static inline internal::PassedWrapper<T> Passed(T* scoper) {
   return internal::PassedWrapper<T>(std::move(*scoper));
 }