Introduce WTF::unretained() and WTF::crossThreadUnretained()

third_party/WebKit/Source/wtf/FunctionalTest.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 174 matching lines @@
         bind(sixArgFunc, 3, 3.5);
     (*twoBound)('d', &a, &b, &c);
     assertArgs(a, b, c, 3, 3.5, 'd');
 
     std::unique_ptr<Function<void(int*, double*, char*)>> threeBound =
         bind(sixArgFunc, 4, 4.5, 'e');
     (*threeBound)(&a, &b, &c);
     assertArgs(a, b, c, 4, 4.5, 'e');
 
     std::unique_ptr<Function<void(double*, char*)>> fourBound =
-        bind(sixArgFunc, 5, 5.5, 'f', &a);
+        bind(sixArgFunc, 5, 5.5, 'f', unretained(&a));
     (*fourBound)(&b, &c);
     assertArgs(a, b, c, 5, 5.5, 'f');
 
     std::unique_ptr<Function<void(char*)>> fiveBound =
-        bind(sixArgFunc, 6, 6.5, 'g', &a, &b);
+        bind(sixArgFunc, 6, 6.5, 'g', unretained(&a), unretained(&b));
     (*fiveBound)(&c);
     assertArgs(a, b, c, 6, 6.5, 'g');
 
     std::unique_ptr<Function<void()>> sixBound =
-        bind(sixArgFunc, 7, 7.5, 'h', &a, &b, &c);
+        bind(sixArgFunc, 7, 7.5, 'h', unretained(&a), unretained(&b), unretained(&c));
     (*sixBound)();
     assertArgs(a, b, c, 7, 7.5, 'h');
 }
 
 class A {
 public:
     explicit A(int i)
         : m_i(i)
     {
     }
@@ skipping 14 matching lines @@
     }
 
     int f() { return A::f() + 1; }
     int addF(int j) { return A::addF(j) + 1; }
     int overridden() override { return 43; }
 };
 
 TEST(FunctionalTest, MemberFunctionBind)
 {
     A a(10);
-    std::unique_ptr<Function<int()>> function1 = bind(&A::f, &a);
+    std::unique_ptr<Function<int()>> function1 = bind(&A::f, unretained(&a));
     EXPECT_EQ(10, (*function1)());
 
-    std::unique_ptr<Function<int()>> function2 = bind(&A::addF, &a, 15);
+    std::unique_ptr<Function<int()>> function2 = bind(&A::addF, unretained(&a), 15);
     EXPECT_EQ(25, (*function2)());
 
-    std::unique_ptr<Function<int()>> function3 = bind(&A::overridden, &a);
+    std::unique_ptr<Function<int()>> function3 = bind(&A::overridden, unretained(&a));
     EXPECT_EQ(42, (*function3)());
 }
 
 TEST(FunctionalTest, MemberFunctionBindWithSubclassPointer)
 {
     B b(10);
-    std::unique_ptr<Function<int()>> function1 = bind(&A::f, &b);
+    std::unique_ptr<Function<int()>> function1 = bind(&A::f, unretained(&b));
     EXPECT_EQ(10, (*function1)());
 
-    std::unique_ptr<Function<int()>> function2 = bind(&A::addF, &b, 15);
+    std::unique_ptr<Function<int()>> function2 = bind(&A::addF, unretained(&b), 15);
     EXPECT_EQ(25, (*function2)());
 
-    std::unique_ptr<Function<int()>> function3 = bind(&A::overridden, &b);
+    std::unique_ptr<Function<int()>> function3 = bind(&A::overridden, unretained(&b));
     EXPECT_EQ(43, (*function3)());
 
-    std::unique_ptr<Function<int()>> function4 = bind(&B::f, &b);
+    std::unique_ptr<Function<int()>> function4 = bind(&B::f, unretained(&b));
     EXPECT_EQ(11, (*function4)());
 
-    std::unique_ptr<Function<int()>> function5 = bind(&B::addF, &b, 15);
+    std::unique_ptr<Function<int()>> function5 = bind(&B::addF, unretained(&b), 15);
     EXPECT_EQ(26, (*function5)());
 
 }
 
 TEST(FunctionalTest, MemberFunctionBindWithSubclassPointerWithCast)
 {
     B b(10);
-    std::unique_ptr<Function<int()>> function1 = bind(&A::f, static_cast<A*>(&b));
+    std::unique_ptr<Function<int()>> function1 = bind(&A::f, unretained(static_cast<A*>(&b)));
     EXPECT_EQ(10, (*function1)());
 
-    std::unique_ptr<Function<int()>> function2 = bind(&A::addF, static_cast<A*>(&b), 15);
+    std::unique_ptr<Function<int()>> function2 = bind(&A::addF, unretained(static_cast<A*>(&b)), 15);
     EXPECT_EQ(25, (*function2)());
 
-    std::unique_ptr<Function<int()>> function3 = bind(&A::overridden, static_cast<A*>(&b));
+    std::unique_ptr<Function<int()>> function3 = bind(&A::overridden, unretained(static_cast<A*>(&b)));
     EXPECT_EQ(43, (*function3)());
 }
 
 TEST(FunctionalTest, MemberFunctionPartBind)
 {
     A a(10);
     std::unique_ptr<Function<int(class A*)>> function1 = bind(&A::f);
     EXPECT_EQ(10, (*function1)(&a));
 
     std::unique_ptr<Function<int(class A*, int)>> unboundFunction2 =
         bind(&A::addF);
     EXPECT_EQ(25, (*unboundFunction2)(&a, 15));
     std::unique_ptr<Function<int(int)>> objectBoundFunction2 =
-        bind(&A::addF, &a);
+        bind(&A::addF, unretained(&a));
     EXPECT_EQ(25, (*objectBoundFunction2)(15));
 }
 
 TEST(FunctionalTest, MemberFunctionBindByUniquePtr)
 {
     std::unique_ptr<Function<int()>> function1 = WTF::bind(&A::f, wrapUnique(new A(10)));
     EXPECT_EQ(10, (*function1)());
 }
 
 TEST(FunctionalTest, MemberFunctionBindByPassedUniquePtr)
@@ skipping 26 matching lines @@
 };
 
 int multiplyNumberByTwo(Number* number)
 {
     return number->value() * 2;
 }
 
 TEST(FunctionalTest, RefCountedStorage)
 {
     RefPtr<Number> five = Number::create(5);
+    EXPECT_EQ(1, five->refCount());
     std::unique_ptr<Function<int()>> multiplyFiveByTwoFunction = bind(multiplyNumberByTwo, five);
+    EXPECT_EQ(2, five->refCount());
     EXPECT_EQ(10, (*multiplyFiveByTwoFunction)());
+    EXPECT_EQ(2, five->refCount());
 
     std::unique_ptr<Function<int()>> multiplyFourByTwoFunction = bind(multiplyNumberByTwo, Number::create(4));
     EXPECT_EQ(8, (*multiplyFourByTwoFunction)());
 
     RefPtr<Number> six = Number::create(6);
     std::unique_ptr<Function<int()>> multiplySixByTwoFunction = bind(multiplyNumberByTwo, six.release());
     EXPECT_FALSE(six);
     EXPECT_EQ(12, (*multiplySixByTwoFunction)());
 }
 
+TEST(FunctionalTest, UnretainedWithRefCounted)
+{
+    RefPtr<Number> five = Number::create(5);
+    EXPECT_EQ(1, five->refCount());
+    std::unique_ptr<Function<int()>> multiplyFiveByTwoFunction = bind(multiplyNumberByTwo, unretained(five.get()));
+    EXPECT_EQ(1, five->refCount());
+    EXPECT_EQ(10, (*multiplyFiveByTwoFunction)());
+    EXPECT_EQ(1, five->refCount());
+}
+
 int processUnwrappedClass(const UnwrappedClass& u, int v)
 {
     return u.value() * v;
 }
 
 // Tests that:
 // - ParamStorageTraits's wrap()/unwrap() are called, and
 // - bind()'s arguments are passed as references to ParamStorageTraits::wrap()
 //   with no additional copies.
 // This test would fail in compile if something is wrong,
@@ skipping 162 matching lines @@
     EXPECT_EQ(0, (*bound1)(CountCopy()));
 
     std::unique_ptr<Function<int(CountCopy)>> bound2 = bind(takeCountCopyAsValue);
     EXPECT_EQ(2, (*bound2)(lvalue)); // At PartBoundFunctionImpl::operator() and at the destination function.
     EXPECT_LE((*bound2)(CountCopy()), 2); // Compiler is allowed to optimize one copy away if the argument is rvalue.
 }
 
 } // anonymous namespace
 
 } // namespace WTF