Readd base::UnwrapTraits to support rvalue-reference wrappers

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 60 matching lines @@
         : 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;
 };
 
 class HasWeakPtrSupport {
 public:
     HasWeakPtrSupport() : m_weakPtrFactory(this) {}
 
     WTF::WeakPtr<HasWeakPtrSupport> createWeakPtr() {
         return m_weakPtrFactory.createWeakPtr();
     }
 
     void revokeAll()
     {
         m_weakPtrFactory.revokeAll();
     }
 
     void increment(int* counter)
     {
         ++*counter;
     }
 
 private:
     WTF::WeakPtrFactory<HasWeakPtrSupport> m_weakPtrFactory;
 };
 
+} // namespace WTF
+
+namespace base {
+
+template <>
+struct BindUnwrapTraits<WTF::WrappedClass> {
+    static WTF::UnwrappedClass Unwrap(const WTF::WrappedClass& wrapped)
+    {
+        return wrapped.unwrap();
+    }
+};
+
+} // namespace base
+
+namespace WTF {
 namespace {
 
 int returnFortyTwo()
 {
     return 42;
 }
 
 TEST(FunctionalTest, Basic)
 {
     std::unique_ptr<Function<int()>> returnFortyTwoFunction = bind(returnFortyTwo);
@@ skipping 460 matching lines @@
     EXPECT_EQ(1, counter);
 
     obj.revokeAll();
     (*bound)();
     EXPECT_EQ(1, counter);
 }
 
 } // anonymous namespace
 
 } // namespace WTF