Get rid of 'PassInType' in hash traits and containers

third_party/WebKit/Source/wtf/HashMap.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011 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 40 matching lines @@
     typedef MappedTraitsArg MappedTraits;
     typedef HashMapValueTraits<KeyTraits, MappedTraits> ValueTraits;
 
 public:
     typedef typename KeyTraits::TraitType KeyType;
     typedef const typename KeyTraits::PeekInType& KeyPeekInType;
     typedef typename MappedTraits::TraitType MappedType;
     typedef typename ValueTraits::TraitType ValueType;
 
 private:
-    typedef typename MappedTraits::PassInType MappedPassInType;
     typedef typename MappedTraits::PeekOutType MappedPeekType;
 
     typedef HashArg HashFunctions;
 
     typedef HashTable<KeyType, ValueType, KeyValuePairKeyExtractor,
         HashFunctions, ValueTraits, KeyTraits, Allocator> HashTableType;
 
     class HashMapKeysProxy;
     class HashMapValuesProxy;
 
@@ skipping 63 matching lines @@
     template <typename HashTranslator, typename T> const_iterator find(const T&) const;
     template <typename HashTranslator, typename T> bool contains(const T&) const;
 
     // An alternate version of add() that finds the object by hashing and
     // comparing with some other type, to avoid the cost of type conversion if
     // the object is already in the table. HashTranslator must have the
     // following function members:
     //   static unsigned hash(const T&);
     //   static bool equal(const ValueType&, const T&);
     //   static translate(ValueType&, const T&, unsigned hashCode);
-    template <typename HashTranslator, typename T> AddResult add(const T&, MappedPassInType);
+    template <typename HashTranslator, typename IncomingKeyType, typename IncomingMappedType>
+    AddResult add(IncomingKeyType&&, IncomingMappedType&&);
 
     static bool isValidKey(KeyPeekInType);
 
     template <typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor) { m_impl.trace(visitor); }
 
 private:
     template <typename IncomingKeyType, typename IncomingMappedType>
     AddResult inlineAdd(IncomingKeyType&&, IncomingMappedType&&);
 
@@ skipping 214 matching lines @@
         // The inlineAdd call above found an existing hash table entry; we need
         // to set the mapped value.
         //
         // It's safe to call std::forward again, because |mapped| isn't moved if there's an existing entry.
         MappedTraits::store(std::forward<IncomingMappedType>(mapped), result.storedValue->value);
     }
     return result;
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
-template <typename HashTranslator, typename TYPE>
-typename HashMap<T, U, V, W, X, Y>::AddResult
-HashMap<T, U, V, W, X, Y>::add(const TYPE& key, MappedPassInType value)
+template <typename HashTranslator, typename IncomingKeyType, typename IncomingMappedType>
+auto HashMap<T, U, V, W, X, Y>::add(IncomingKeyType&& key, IncomingMappedType&& mapped) -> AddResult
 {
-    return m_impl.template addPassingHashCode<HashMapTranslatorAdapter<ValueTraits, HashTranslator>>(key, value);
+    return m_impl.template addPassingHashCode<HashMapTranslatorAdapter<ValueTraits, HashTranslator>>(
+        std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
 template <typename IncomingKeyType, typename IncomingMappedType>
 typename HashMap<T, U, V, W, X, Y>::AddResult
 HashMap<T, U, V, W, X, Y>::add(IncomingKeyType&& key, IncomingMappedType&& mapped)
 {
     return inlineAdd(std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
 }
 
@@ skipping 102 matching lines @@
     iterator end = collection.end().values();
     for (unsigned i = 0; it != end; ++it, ++i)
         vector[i] = *it;
 }
 
 } // namespace WTF
 
 using WTF::HashMap;
 
 #endif // WTF_HashMap_h