Remove ParamStorageTraits::wrap and move unwrap to global scope (3/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 27 matching lines @@
         : m_value(value)
     {
     }
 
     int value() const { return m_value; }
 
 private:
     int m_value;
 };
 
-class WrappedClass {
-public:
-    explicit WrappedClass(int value)
-        : m_value(value)
-    {
-    }
-
-    UnwrappedClass unwrap() const { return UnwrappedClass(m_value); }
-
-private:
-    int m_value;
-};
-
 // This class must be wrapped in bind() and unwrapped in closure execution.
 class ClassToBeWrapped {
     WTF_MAKE_NONCOPYABLE(ClassToBeWrapped);
 public:
     explicit ClassToBeWrapped(int value)
         : m_value(value)
     {
     }
 
-    WrappedClass wrap() const { return WrappedClass(m_value); }
+    int value() const { return m_value; }
 
 private:
     int m_value;
 };
 
+class WrappedClass {
+public:
+    WrappedClass(const ClassToBeWrapped& to_be_wrapped)
+        : m_value(to_be_wrapped.value())
+    {
+    }
+
+    explicit WrappedClass(int value)
+        : m_value(value)
+    {
+    }
+
+    UnwrappedClass unwrap() const { return UnwrappedClass(m_value); }
+
+private:
+    int m_value;
+};
+
+UnwrappedClass Unwrap(const WrappedClass& wrapped)
+{
+    return wrapped.unwrap();
+}
+
 template<> struct ParamStorageTraits<ClassToBeWrapped> {
     using StorageType = WrappedClass;
-    static StorageType wrap(const ClassToBeWrapped& value) { return value.wrap(); }
-    static UnwrappedClass unwrap(const StorageType& value) { return value.unwrap(); }
 };
 
 class HasWeakPtrSupport {
 public:
     HasWeakPtrSupport() : m_weakPtrFactory(this) {}
 
     WTF::WeakPtr<HasWeakPtrSupport> createWeakPtr() {
         return m_weakPtrFactory.createWeakPtr();
     }
 
@@ skipping 426 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(2, (*bound)()); // wrapping and unwrapping.
+    EXPECT_EQ(1, (*bound)()); // unwrapping.
 
     bound = bind(takeCountCopyAsConstReference, CountCopy()); // Rvalue.
-    EXPECT_EQ(2, (*bound)());
+    EXPECT_EQ(1, (*bound)());
 
     bound = bind(takeCountCopyAsValue, lvalue);
-    EXPECT_EQ(3, (*bound)()); // wrapping, unwrapping and copying in the final function argument.
+    EXPECT_EQ(2, (*bound)()); // unwrapping and copying in the final function argument.
 
     bound = bind(takeCountCopyAsValue, CountCopy());
-    EXPECT_EQ(3, (*bound)());
+    EXPECT_EQ(2, (*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)));
@@ skipping 28 matching lines @@
     EXPECT_EQ(1, counter);
 
     obj.revokeAll();
     (*bound)();
     EXPECT_EQ(1, counter);
 }
 
 } // anonymous namespace
 
 } // namespace WTF