Rename MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03

base/move.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.
 
 #ifndef BASE_MOVE_H_
 #define BASE_MOVE_H_
 
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 12 matching lines @@
 //   * Passed as a function argument
 //   * Used as the right-hand side of an assignment
 //   * Returned from a function
 //
 // Each class will still need to define their own move constructor and move
 // operator= to make this useful.  Here's an example of the macro, the move
 // constructor, and the move operator= from a hypothetical scoped_ptr class:
 //
 //  template <typename T>
 //  class scoped_ptr {
-//    MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(type);
+//    DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(type);
 //   public:
 //    scoped_ptr(scoped_ptr&& other) : ptr_(other.release()) { }
 //    scoped_ptr& operator=(scoped_ptr&& other) {
 //      reset(other.release());
 //      return *this;
 //    }
 //  };
 //
 //
 // WHY HAVE typedef void MoveOnlyTypeForCPP03
 //
 // Callback<>/Bind() needs to understand movable-but-not-copyable semantics
 // to call .Pass() appropriately when it is expected to transfer the value.
 // The cryptic typedef MoveOnlyTypeForCPP03 is added to make this check
 // easy and automatic in helper templates for Callback<>/Bind().
 // See IsMoveOnlyType template and its usage in base/callback_internal.h
 // for more details.
 
 #define MOVE_ONLY_TYPE_FOR_CPP_03(type) \
-  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(type)
+  DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(type)
 
-#define MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(type)   \
+#define DISALLOW_COPY_AND_ASSIGN_WITH_MOVE_FOR_BIND(type)       \

[Nico, 2015/12/04 21:58:05]

What do you think is the long term plan for this? Once Pass() is gone, this will
go away completely I guess?

Maybe this could be

#define MOVE_ONLY(x) DISALLOW_COPY_AND_ASSIGN(x)

but I guess an explicit move ctor already implicitly deletes the default copy
ctor.

[danakj, 2015/12/04 22:01:47]

We'll still need the typedef whitelist once Pass() is gone, until some form of
Bind/Callback works.
Yah it does, and this macro doesn't actually make it movable.

Long long term this macro goes away and we always use DISALLOW_COPY_AND_ASSIGN,
I think.

I could make this macro actually use DISALLOW_COPY_AND_ASSIGN instead of
re-implementing it, would that be nice do you think?

I should maybe update/slim down the comment above to say use
DISALLOW_COPY_AND_ASSIGN if you don't need Callback support.

[dcheng, 2015/12/04 22:14:00]

I've been thinking: is there a value to forcing the use of MOVE_ONLY for
Callback compatibility? It's a pretty minor speedbump, since it's trivial to
just use this macro.

  private:                                                       \
   type(const type&) = delete;                                   \
   void operator=(const type&) = delete;                         \
                                                                 \
  public:                                                        \
   type&& Pass() WARN_UNUSED_RESULT { return std::move(*this); } \
   typedef void MoveOnlyTypeForCPP03;                            \
                                                                 \
  private:
 
 #endif  // BASE_MOVE_H_