Revert of Remove base/move.h

base/scoped_generic.h

 // Copyright 2014 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.
 
 #ifndef BASE_SCOPED_GENERIC_H_
 #define BASE_SCOPED_GENERIC_H_
 
 #include <stdlib.h>
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "base/move.h"
 
 namespace base {
 
 // This class acts like ScopedPtr with a custom deleter (although is slightly
 // less fancy in some of the more escoteric respects) except that it keeps a
 // copy of the object rather than a pointer, and we require that the contained
 // object has some kind of "invalid" value.
 //
 // Defining a scoper based on this class allows you to get a scoper for
 // non-pointer types without having to write custom code for set, reset, and
@@ skipping 22 matching lines @@
 //
 //     // This free function will not be called if f == InvalidValue()!
 //     static void Free(int f) {
 //       ::FreeFoo(f);
 //     }
 //   };
 //
 //   typedef ScopedGeneric<int, FooScopedTraits> ScopedFoo;
 template<typename T, typename Traits>
 class ScopedGeneric {
+  DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(ScopedGeneric)
+
  private:
   // This must be first since it's used inline below.
   //
   // Use the empty base class optimization to allow us to have a D
   // member, while avoiding any space overhead for it when D is an
   // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
   // discussion of this technique.
   struct Data : public Traits {
     explicit Data(const T& in) : generic(in) {}
     Data(const T& in, const Traits& other) : Traits(other), generic(in) {}
@@ skipping 84 matching lines @@
 
   // Forbid comparison. If U != T, it totally doesn't make sense, and if U ==
   // T, it still doesn't make sense because you should never have the same
   // object owned by two different ScopedGenerics.
   template <typename T2, typename Traits2> bool operator==(
       const ScopedGeneric<T2, Traits2>& p2) const;
   template <typename T2, typename Traits2> bool operator!=(
       const ScopedGeneric<T2, Traits2>& p2) const;
 
   Data data_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedGeneric);
 };
 
 template<class T, class Traits>
 void swap(const ScopedGeneric<T, Traits>& a,
           const ScopedGeneric<T, Traits>& b) {
   a.swap(b);
 }
 
 template<class T, class Traits>
 bool operator==(const T& value, const ScopedGeneric<T, Traits>& scoped) {
   return value == scoped.get();
 }
 
 template<class T, class Traits>
 bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
   return value != scoped.get();
 }
 
 }  // namespace base
 
 #endif  // BASE_SCOPED_GENERIC_H_