Replaced PassRefPtr copies with moves in Source/web and Source/wtf.

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 234 matching lines @@
 };
 
 template <typename ValueTraits, typename HashFunctions>
 struct HashMapTranslator {
     STATIC_ONLY(HashMapTranslator);
     template <typename T> static unsigned hash(const T& key) { return HashFunctions::hash(key); }
     template <typename T, typename U> static bool equal(const T& a, const U& b) { return HashFunctions::equal(a, b); }
     template <typename T, typename U, typename V> static void translate(T& location, U&& key, V&& mapped)
     {
         location.key = std::forward<U>(key);
-        ValueTraits::ValueTraits::store(std::forward<V>(mapped), location.value);
+        ValueTraits::ValueTraits::store(std::move(std::forward<V>(mapped)), location.value);

[Yuta Kitamura, 2016/09/05 06:46:09]

Nesting std::move and std::forward does not make sense; forward()
is a generalized version of move(), thus you probably don't want
to touch here.

I guess the real error is in somewhere else, likely in a call
site of HashMap::add() or the like.

[Bugs Nash, 2016/09/14 05:23:29]

Done

     }
 };
 
 template <typename ValueTraits, typename Translator>
 struct HashMapTranslatorAdapter {
     STATIC_ONLY(HashMapTranslatorAdapter);
     template <typename T> static unsigned hash(const T& key) { return Translator::hash(key); }
     template <typename T, typename U> static bool equal(const T& a, const U& b) { return Translator::equal(a, b); }
     template <typename T, typename U, typename V> static void translate(T& location, U&& key, V&& mapped, unsigned hashCode)
     {
@@ skipping 98 matching lines @@
 template <typename IncomingKeyType, typename IncomingMappedType>
 typename HashMap<T, U, V, W, X, Y>::AddResult
 HashMap<T, U, V, W, X, Y>::set(IncomingKeyType&& key, IncomingMappedType&& mapped)
 {
     AddResult result = inlineAdd(std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
     if (!result.isNewEntry) {
         // 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);
+        MappedTraits::store(std::move(std::forward<IncomingMappedType>(mapped)), result.storedValue->value);

[Yuta Kitamura, 2016/09/05 06:46:09]

Ditto.

[Bugs Nash, 2016/09/14 05:23:29]

Done

     }
     return result;
 }
 
 template <typename T, typename U, typename V, typename W, typename X, typename Y>
 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>>(
         std::forward<IncomingKeyType>(key), std::forward<IncomingMappedType>(mapped));
@@ skipping 112 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