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

base/bind_helpers.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
 // It also defines a set of simple functions and utilities that people want
 // when using Callback<> and Bind().
@@ skipping 545 matching lines @@
 }
 
 // We offer 2 syntaxes for calling Passed().  The first takes an rvalue and
 // is best suited for use with the return value of a function or other temporary
 // rvalues. The second takes a pointer to the scoper and is just syntactic sugar
 // to avoid having to write Passed(std::move(scoper)).
 //
 // 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));
 }
 
 template <typename T>
 static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
   return internal::IgnoreResultHelper<T>(data);
 }
 
 template <typename T>
 static inline internal::IgnoreResultHelper<Callback<T> >
 IgnoreResult(const Callback<T>& data) {
   return internal::IgnoreResultHelper<Callback<T> >(data);
 }
 
 BASE_EXPORT void DoNothing();
 
 template<typename T>
 void DeletePointer(T* obj) {
   delete obj;
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_