Make WTF::Function be a base::Callback wrapper (5/5)

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 513 matching lines @@
 
 int takeCountCopyAsValue(CountCopy counter)
 {
     return counter.copies();
 }
 
 TEST(FunctionalTest, CountCopiesOfBoundArguments)
 {
     CountCopy lvalue;
     std::unique_ptr<Function<int()>> bound = bind(takeCountCopyAsConstReference, lvalue);
-    EXPECT_EQ(1, (*bound)()); // unwrapping.
+    EXPECT_EQ(2, (*bound)()); // wrapping and unwrapping.
 
     bound = bind(takeCountCopyAsConstReference, CountCopy()); // Rvalue.
-    EXPECT_EQ(1, (*bound)());
+    EXPECT_EQ(2, (*bound)());
 
     bound = bind(takeCountCopyAsValue, lvalue);
-    EXPECT_EQ(2, (*bound)()); // unwrapping and copying in the final function argument.
+    EXPECT_EQ(3, (*bound)()); // wrapping, unwrapping and copying in the final function argument.
 
     bound = bind(takeCountCopyAsValue, CountCopy());
-    EXPECT_EQ(2, (*bound)());
+    EXPECT_EQ(3, (*bound)());
 }
 
 TEST(FunctionalTest, MoveUnboundArgumentsByRvalueReference)
 {
     std::unique_ptr<Function<int(MoveOnly&&)>> boundSingle = bind(singleMoveOnlyByRvalueReference);
     EXPECT_EQ(1, (*boundSingle)(MoveOnly(1)));
     EXPECT_EQ(42, (*boundSingle)(MoveOnly(42)));
 
     std::unique_ptr<Function<int(MoveOnly&&, MoveOnly&&, MoveOnly&&)>> boundTriple = bind(tripleMoveOnlysByRvalueReferences);
     EXPECT_EQ(6, (*boundTriple)(MoveOnly(1), MoveOnly(2), MoveOnly(3)));
     EXPECT_EQ(666, (*boundTriple)(MoveOnly(111), MoveOnly(222), MoveOnly(333)));
 
     std::unique_ptr<Function<int(MoveOnly)>> boundSingleByValue = bind(singleMoveOnlyByValue);
     EXPECT_EQ(1, (*boundSingleByValue)(MoveOnly(1)));
 
     std::unique_ptr<Function<int(MoveOnly, MoveOnly, MoveOnly)>> boundTripleByValue = bind(tripleMoveOnlysByValues);
     EXPECT_EQ(6, (*boundTripleByValue)(MoveOnly(1), MoveOnly(2), MoveOnly(3)));
 }
 
 TEST(FunctionalTest, CountCopiesOfUnboundArguments)
 {
     CountCopy lvalue;
     std::unique_ptr<Function<int(const CountCopy&)>> bound1 = bind(takeCountCopyAsConstReference);
     EXPECT_EQ(0, (*bound1)(lvalue)); // No copies!
     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_EQ(3, (*bound2)(lvalue)); // At Function::operator(), at Callback::Run() and at the destination function.
     EXPECT_LE((*bound2)(CountCopy()), 2); // Compiler is allowed to optimize one copy away if the argument is rvalue.
 }
 
 TEST(FunctionalTest, WeakPtr)
 {
     HasWeakPtrSupport obj;
     int counter = 0;
     std::unique_ptr<WTF::SameThreadClosure> bound = WTF::bind(&HasWeakPtrSupport::increment, obj.createWeakPtr(), WTF::unretained(&counter));
 
     (*bound)();
     EXPECT_EQ(1, counter);
 
     obj.revokeAll();
     (*bound)();
     EXPECT_EQ(1, counter);
 }
 
 } // anonymous namespace
 
 } // namespace WTF