Use WTF::WeakPtr in WTF::makeCancellable

third_party/WebKit/Source/wtf/MakeCancellableTest.cpp

 // Copyright 2016 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 "wtf/MakeCancellable.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Compiler.h"
 
 namespace WTF {
@@ skipping 25 matching lines @@
 };
 
 } // namespace
 
 TEST(MakeCancellableTest, NotCancelled)
 {
     int v = 0;
     auto f = bind(&add, unretained(&v));
     auto result = makeCancellable(std::move(f));
 
+    EXPECT_FALSE(result.function->isCancelled());
     EXPECT_EQ(0, v);
     (*result.function)(3);
     EXPECT_EQ(3, v);
 }
 
 TEST(MakeCancellableTest, ExplicitCancel)
 {
     int v = 0;
     auto f = bind(&add, unretained(&v));
     auto result = makeCancellable(std::move(f));
 
+    EXPECT_FALSE(result.function->isCancelled());
     EXPECT_TRUE(result.canceller.isActive());
     result.canceller.cancel();
+    EXPECT_TRUE(result.function->isCancelled());
     EXPECT_FALSE(result.canceller.isActive());
 
     EXPECT_EQ(0, v);
     (*result.function)(3);
     EXPECT_EQ(0, v);
 }
 
 TEST(MakeCancellableTest, ScopeOutCancel)
 {
     int v = 0;
     auto f = bind(&add, unretained(&v));
     {
         auto result = makeCancellable(std::move(f));
         f = std::move(result.function);
 
         ScopedFunctionCanceller scopedCanceller = std::move(result.canceller);
         EXPECT_TRUE(scopedCanceller.isActive());
+        EXPECT_FALSE(f->isCancelled());
     }
 
+    EXPECT_TRUE(f->isCancelled());
     EXPECT_EQ(0, v);
     (*f)(3);
     EXPECT_EQ(0, v);
 }
 
 TEST(MakeCancellableTest, Detach)
 {
     int v = 0;
     auto f = bind(&add, unretained(&v));
     {
         auto result = makeCancellable(std::move(f));
         f = std::move(result.function);
 
         ScopedFunctionCanceller scopedCanceller = std::move(result.canceller);
         EXPECT_TRUE(scopedCanceller.isActive());
         scopedCanceller.detach();
         EXPECT_FALSE(scopedCanceller.isActive());
+        EXPECT_FALSE(f->isCancelled());
     }
 
+    EXPECT_FALSE(f->isCancelled());
     EXPECT_EQ(0, v);
     (*f)(3);
     EXPECT_EQ(3, v);
 }
 
 TEST(MakeCancellableTest, MultiCall)
 {
     int v = 0;
     auto f = bind(&add, unretained(&v));
     auto result = makeCancellable(std::move(f));
 
+    EXPECT_FALSE(result.function->isCancelled());
     EXPECT_EQ(0, v);
     (*result.function)(2);
     EXPECT_EQ(2, v);
     (*result.function)(3);
     EXPECT_EQ(5, v);
+    EXPECT_FALSE(result.function->isCancelled());
 }
 
 TEST(MakeCancellableTest, DestroyOnCancel)
 {
     int counter = 0;
     auto f = bind([](const DestructionCounter&) {}, DestructionCounter(&counter));
     auto result = makeCancellable(std::move(f));
 
+    EXPECT_FALSE(result.function->isCancelled());
     EXPECT_EQ(0, counter);
     result.canceller.cancel();
+    EXPECT_TRUE(result.function->isCancelled());
     EXPECT_EQ(1, counter);
 }
 
 TEST(MakeCancellableTest, DestroyOnWrapperDestruction)
 {
     int counter = 0;
     auto f = bind([](const DestructionCounter&) {}, DestructionCounter(&counter));
     auto result = makeCancellable(std::move(f));
 
     EXPECT_TRUE(result.canceller.isActive());
+    EXPECT_FALSE(result.function->isCancelled());
 
     EXPECT_EQ(0, counter);
     result.function = nullptr;
     EXPECT_EQ(1, counter);
 
     EXPECT_FALSE(result.canceller.isActive());
 }
 
 TEST(MakeCancellableTest, SelfAssignment)
 {
     int v = 0;
     auto f = bind(&add, unretained(&v));
     auto result = makeCancellable(std::move(f));
 
     ScopedFunctionCanceller scopedCanceller = std::move(result.canceller);
     EXPECT_TRUE(scopedCanceller.isActive());
 
 #if COMPILER(CLANG)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wself-move"
     scopedCanceller = std::move(scopedCanceller);
 #pragma clang diagnostic pop
 #else
     scopedCanceller = std::move(scopedCanceller);
 #endif
 
     EXPECT_TRUE(scopedCanceller.isActive());
+    EXPECT_FALSE(result.function->isCancelled());
     EXPECT_EQ(0, v);
     (*result.function)(1);
     EXPECT_EQ(1, v);
 }
 
 } // namespace WTF