WTF::HashTable: Implement move semantics for keys and values.

third_party/WebKit/Source/wtf/HashTraits.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 89 matching lines @@
     typedef T* IteratorGetType;
     typedef const T* IteratorConstGetType;
     typedef T& IteratorReferenceType;
     typedef const T& IteratorConstReferenceType;
     static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return *x; }
     static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return *x; }
     // Type for functions that take ownership, such as add.
     // The store function either not be called or called once to store something
     // passed in.  The value passed to the store function will be PassInType.
     typedef const T& PassInType;
-    static void store(const T& value, T& storage) { storage = value; }
+    template <typename IncomingValueType>
+    static void store(IncomingValueType&& value, T& storage) { storage = std::forward<IncomingValueType>(value); }
 
     // Type for return value of functions that transfer ownership, such as take.
     typedef T PassOutType;
-    static const T& passOut(const T& value) { return value; }
+    static T&& passOut(T& value) { return std::move(value); }

[Mikhail, 2016/03/04 12:58:02]

do we still need 'passOut'? can std::move be called directly?

[Yuta Kitamura, 2016/03/04 13:55:37]

Other specializations (for e.g. PassRefPtr) still require it.

Eventually we could get rid of this, though, after PassOwnPtr
and PassRefPtr acquire proper move semantics instead of copying.

+    static T&& passOut(T&& value) { return std::move(value); }
 
     // Type for return value of functions that do not transfer ownership, such
     // as get.
     // FIXME: We could change this type to const T& for better performance if we
     // figured out a way to handle the return value from emptyValue, which is a
     // temporary.
     typedef T PeekOutType;
     static const T& peek(const T& value) { return value; }
 };
 
@@ skipping 132 matching lines @@
     static bool isDeletedValue(const TraitType& value) { return FirstTraits::isDeletedValue(value.first); }
 };
 
 template <typename First, typename Second>
 struct HashTraits<std::pair<First, Second>> : public PairHashTraits<HashTraits<First>, HashTraits<Second>> { };
 
 template <typename KeyTypeArg, typename ValueTypeArg>
 struct KeyValuePair {
     typedef KeyTypeArg KeyType;
 
-    KeyValuePair(const KeyTypeArg& _key, const ValueTypeArg& _value)
-        : key(_key)
-        , value(_value)
+    template <typename IncomingKeyType, typename IncomingValueType>
+    KeyValuePair(IncomingKeyType&& key, IncomingValueType&& value)
+        : key(std::forward<IncomingKeyType>(key))
+        , value(std::forward<IncomingValueType>(value))
     {
     }
 
     template <typename OtherKeyType, typename OtherValueType>
     KeyValuePair(KeyValuePair<OtherKeyType, OtherValueType>&& other)
         : key(std::move(other.key))
         , value(std::move(other.value))
     {
     }
 
@@ skipping 55 matching lines @@
 struct TraceInCollectionTrait;
 
 } // namespace WTF
 
 using WTF::HashTraits;
 using WTF::PairHashTraits;
 using WTF::NullableHashTraits;
 using WTF::SimpleClassHashTraits;
 
 #endif // WTF_HashTraits_h