Specialize IsMoveOnlyType<T> for vectors.

base/callback_internal.h

 // Copyright (c) 2012 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 file contains utility functions and classes that help the
 // implementation, and management of the Callback objects.
 
 #ifndef BASE_CALLBACK_INTERNAL_H_
 #define BASE_CALLBACK_INTERNAL_H_
 
 #include <stddef.h>
 #include <memory>
 #include <type_traits>
+#include <vector>
 
 #include "base/atomic_ref_count.h"
 #include "base/base_export.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/template_util.h"
 
 namespace base {
 namespace internal {
@@ skipping 85 matching lines @@
   template <typename U>
   static NoType Test(...);
 
   static const bool value = sizeof((Test<T>(0))) == sizeof(YesType) &&
                             !is_const<T>::value;
 };
 
 // Specialization of IsMoveOnlyType so that std::unique_ptr is still considered
 // move-only, even without the sentinel member.
 template <typename T, typename D>
-struct IsMoveOnlyType<std::unique_ptr<T, D>> : std::true_type {};
+struct IsMoveOnlyType<std::unique_ptr<T, D>> : public std::true_type {};

[danakj, 2016/02/02 01:38:34]

nit: let's leave out redundant public here and below

[dcheng, 2016/02/02 01:52:11]

Done.

+
+// Specialization of std::vector, so that it's considered move-only if the
+// element type is move-only.

[danakj, 2016/02/02 01:38:33]

Leave a note that it ignores the Allocator?

[dcheng, 2016/02/02 01:52:11]

Done.

+template <typename T, typename Allocator>
+struct IsMoveOnlyType<std::vector<T, Allocator>>
+    : public IsMoveOnlyType<typename std::vector<T, Allocator>::value_type> {};

[danakj, 2016/02/02 01:39:21]

vlad's right though that this is the same as

: IsMoveOnlyType<T> {}

which is way easier to read, tho less copy-paste friendly. I think I like that
better.

[dcheng, 2016/02/02 01:52:11]

OK, sure. I had imagined that we could use some generic programming to enable
this for most STL containers without having to explicitly specify each one, but
that might be a bit too clever.

 
 template <typename>
 struct CallbackParamTraitsForMoveOnlyType;
 
 template <typename>
 struct CallbackParamTraitsForNonMoveOnlyType;
 
 // TODO(tzik): Use a default parameter once MSVS supports variadic templates
 // with default values.
 // http://connect.microsoft.com/VisualStudio/feedbackdetail/view/957801/compilation-error-with-variadic-templates
@@ skipping 95 matching lines @@
 template <typename T>
 typename std::enable_if<IsMoveOnlyType<T>::value, T>::type CallbackForward(
     T& t) {
   return std::move(t);
 }
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_CALLBACK_INTERNAL_H_