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

base/bind_unittest.cc

 // 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.
 
 #include "base/bind.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 910 matching lines @@
 
   copies = 0;
   assigns = 0;
   Bind(&VoidPolymorphic<CopyCounter>::Run, CopyCounter(&copies, &assigns));
   EXPECT_EQ(1, copies);
   EXPECT_EQ(0, assigns);
 
   copies = 0;
   assigns = 0;
   Bind(&VoidPolymorphic<CopyCounter>::Run).Run(counter);
-  EXPECT_EQ(1, copies);
+  EXPECT_EQ(2, copies);
   EXPECT_EQ(0, assigns);
 
   copies = 0;
   assigns = 0;
   Bind(&VoidPolymorphic<CopyCounter>::Run).Run(CopyCounter(&copies, &assigns));
   EXPECT_EQ(1, copies);
   EXPECT_EQ(0, assigns);
 
   copies = 0;
   assigns = 0;
@@ skipping 18 matching lines @@
   int move_assigns = 0;
 
   Bind(&VoidPolymorphic<const MoveCounter&>::Run,
        MoveCounter(&move_constructs, &move_assigns));
   EXPECT_EQ(1, move_constructs);
   EXPECT_EQ(0, move_assigns);
 
   // TODO(tzik): Support binding move-only type into a non-reference parameter
   // of a variant of Callback.
 
-  // TODO(tzik): Support move-only type forwarding on Callback::Run.
+  move_constructs = 0;
+  move_assigns = 0;
+  Bind(&VoidPolymorphic<MoveCounter>::Run)
+      .Run(MoveCounter(&move_constructs, &move_assigns));
+  EXPECT_EQ(1, move_constructs);
+  EXPECT_EQ(0, move_assigns);
+
+  move_constructs = 0;
+  move_assigns = 0;
+  Bind(&VoidPolymorphic<MoveCounter>::Run)
+      .Run(MoveCounter(DerivedCopyMoveCounter(
+          nullptr, nullptr, &move_constructs, &move_assigns)));
+  EXPECT_EQ(2, move_constructs);
+  EXPECT_EQ(0, move_assigns);
 }
 
 // Argument constructor usage for non-reference movable-copyable
 // parameters.
 //   - Bound arguments passed by move are not copied.
 //   - Forwarded arguments are only copied once.
 //   - Forwarded arguments with coercions are only copied once and moved once.
 TEST_F(BindTest, ArgumentCopiesAndMoves) {
   int copies = 0;
   int assigns = 0;
@@ skipping 18 matching lines @@
   EXPECT_EQ(1, move_constructs);
   EXPECT_EQ(0, move_assigns);
 
   copies = 0;
   assigns = 0;
   move_constructs = 0;
   move_assigns = 0;
   Bind(&VoidPolymorphic<CopyMoveCounter>::Run).Run(counter);
   EXPECT_EQ(1, copies);
   EXPECT_EQ(0, assigns);
-  EXPECT_EQ(0, move_constructs);
+  EXPECT_EQ(1, move_constructs);
   EXPECT_EQ(0, move_assigns);
 
-  // TODO(tzik): This case should be done in no copy and one move.
   copies = 0;
   assigns = 0;
   move_constructs = 0;
   move_assigns = 0;
   Bind(&VoidPolymorphic<CopyMoveCounter>::Run)
       .Run(CopyMoveCounter(&copies, &assigns, &move_constructs, &move_assigns));
-  EXPECT_EQ(1, copies);
+  EXPECT_EQ(0, copies);
   EXPECT_EQ(0, assigns);
-  EXPECT_EQ(0, move_constructs);
+  EXPECT_EQ(1, move_constructs);
   EXPECT_EQ(0, move_assigns);
 
-  // TODO(tzik): This case should be done in one copy and one move.
   DerivedCopyMoveCounter derived_counter(&copies, &assigns, &move_constructs,
                                          &move_assigns);
   copies = 0;
   assigns = 0;
   move_constructs = 0;
   move_assigns = 0;
   Bind(&VoidPolymorphic<CopyMoveCounter>::Run)
       .Run(CopyMoveCounter(derived_counter));
-  EXPECT_EQ(2, copies);
+  EXPECT_EQ(1, copies);
   EXPECT_EQ(0, assigns);
-  EXPECT_EQ(0, move_constructs);
+  EXPECT_EQ(1, move_constructs);
   EXPECT_EQ(0, move_assigns);
 
-  // TODO(tzik): This case should be done in no copy and two move.
   copies = 0;
   assigns = 0;
   move_constructs = 0;
   move_assigns = 0;
   Bind(&VoidPolymorphic<CopyMoveCounter>::Run)
       .Run(CopyMoveCounter(DerivedCopyMoveCounter(
           &copies, &assigns, &move_constructs, &move_assigns)));
-  EXPECT_EQ(1, copies);
+  EXPECT_EQ(0, copies);
   EXPECT_EQ(0, assigns);
-  EXPECT_EQ(1, move_constructs);
+  EXPECT_EQ(2, move_constructs);
   EXPECT_EQ(0, move_assigns);
 }
 
 // Callback construction and assignment tests.
 //   - Construction from an InvokerStorageHolder should not cause ref/deref.
 //   - Assignment from other callback should only cause one ref
 //
 // TODO(ajwong): Is there actually a way to test this?
 
 #if defined(OS_WIN)
@@ skipping 24 matching lines @@
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DEATH(base::Bind(null_cb, 42), "");
 }
 
 #endif  // (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)) &&
         //     GTEST_HAS_DEATH_TEST
 
 }  // namespace
 }  // namespace base