Fix base::Callback<>::IsCancelled handling on nested base::Callback

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>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/test/gtest_util.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace base {
+
+using internal::OnceCallback;
+using internal::RepeatingCallback;
+using internal::OnceClosure;
+using internal::RepeatingClosure;
+using internal::BindOnce;
+using internal::BindRepeating;
+
 namespace {
 
 class IncompleteType;
 
 class NoRef {
  public:
   NoRef() {}
 
   MOCK_METHOD0(VoidMethod0, void());
   MOCK_CONST_METHOD0(VoidConstMethod0, void());
@@ skipping 997 matching lines @@
   cb.Run(6);
   EXPECT_EQ(6, x);
   cb.Run(7);
   EXPECT_EQ(42, x);
 }
 
 TEST_F(BindTest, Cancellation) {
   EXPECT_CALL(no_ref_, VoidMethodWithIntArg(_)).Times(2);
 
   WeakPtrFactory<NoRef> weak_factory(&no_ref_);
-  base::Callback<void(int)> cb =
-      Bind(&NoRef::VoidMethodWithIntArg, weak_factory.GetWeakPtr());
-  Closure cb2 = Bind(cb, 8);
+  RepeatingCallback<void(int)> cb =
+      BindRepeating(&NoRef::VoidMethodWithIntArg, weak_factory.GetWeakPtr());
+  RepeatingClosure cb2 = BindRepeating(cb, 8);
+  OnceClosure cb3 = BindOnce(cb, 8);
+
+  OnceCallback<void(int)> cb4 =
+      BindOnce(&NoRef::VoidMethodWithIntArg, weak_factory.GetWeakPtr());
+  EXPECT_FALSE(cb4.IsCancelled());
+
+  OnceClosure cb5 = BindOnce(std::move(cb4), 8);
 
   EXPECT_FALSE(cb.IsCancelled());
   EXPECT_FALSE(cb2.IsCancelled());
+  EXPECT_FALSE(cb3.IsCancelled());
+  EXPECT_FALSE(cb5.IsCancelled());
 
   cb.Run(6);
   cb2.Run();
 
   weak_factory.InvalidateWeakPtrs();
 
   EXPECT_TRUE(cb.IsCancelled());
   EXPECT_TRUE(cb2.IsCancelled());
+  EXPECT_TRUE(cb3.IsCancelled());
+  EXPECT_TRUE(cb5.IsCancelled());
 
   cb.Run(6);
   cb2.Run();
+  std::move(cb3).Run();
+  std::move(cb5).Run();
 }
 
 TEST_F(BindTest, OnceCallback) {
   using internal::OnceClosure;
   using internal::RepeatingClosure;
   using internal::BindOnce;
   using internal::BindRepeating;
   using internal::OnceCallback;
 
   // Check if Callback variants have declarations of conversions as expected.
@@ skipping 108 matching lines @@
 
 // Test null callbacks cause a DCHECK.
 TEST(BindDeathTest, NullCallback) {
   base::Callback<void(int)> null_cb;
   ASSERT_TRUE(null_cb.is_null());
   EXPECT_DCHECK_DEATH(base::Bind(null_cb, 42));
 }
 
 }  // namespace
 }  // namespace base