Convert Pass()→std::move() in //mojo/public/

mojo/public/cpp/bindings/lib/map_internal.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_
 
 #include <map>
+#include <utility>
 
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 
 namespace mojo {
 namespace internal {
 
 template <typename Key, typename Value, bool kValueIsMoveOnlyType>
 struct MapTraits {};
 
@@ skipping 118 matching lines @@
                                mojo::Array<Key>* keys,
                                mojo::Array<Value>* values) {
     keys->resize(m->size());
     values->resize(m->size());
     int i = 0;
     for (typename std::map<KeyStorageType, ValueStorageType>::iterator
              it = m->begin();
          it != m->end();
          ++it, ++i) {
       (*keys)[i] = it->first;
-      (*values)[i] = GetValue(it).Pass();
+      (*values)[i] = std::move(GetValue(it));
     }
   }
   static inline void Finalize(std::map<KeyStorageType, ValueStorageType>* m) {
     for (auto& pair : *m)
       reinterpret_cast<Value*>(pair.second.buf)->~Value();
   }
   static inline ValueRefType at(std::map<KeyStorageType, ValueStorageType>* m,
                                 KeyForwardType key) {
     // We don't have C++11 library support yet, so we have to emulate the crash
     // on a non-existent key.
@@ skipping 23 matching lines @@
     return GetValue(it);
   }
   static inline void Insert(std::map<KeyStorageType, ValueStorageType>* m,
                             KeyForwardType key,
                             ValueRefType value) {
     // STL insert() doesn't insert |value| if |key| is already part of |m|. We
     // have to use operator[] to initialize into the storage buffer, but we
     // have to do a manual check so that we don't overwrite an existing object.
     auto it = m->find(key);
     if (it == m->end())
-      new ((*m)[key].buf) Value(value.Pass());
+      new ((*m)[key].buf) Value(std::move(value));
   }
   static inline KeyConstRefType GetKey(
       const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
           it) {
     return it->first;
   }
   static inline ValueConstRefType GetValue(
       const typename std::map<KeyStorageType, ValueStorageType>::const_iterator&
           it) {
     return *reinterpret_cast<const Value*>(it->second.buf);
   }
   static inline ValueRefType GetValue(
       const typename std::map<KeyStorageType, ValueStorageType>::iterator& it) {
     return *reinterpret_cast<Value*>(it->second.buf);
   }
   static inline void Clone(
       const std::map<KeyStorageType, ValueStorageType>& src,
       std::map<KeyStorageType, ValueStorageType>* dst) {
     Finalize(dst);
     dst->clear();
     for (auto it = src.begin(); it != src.end(); ++it)
       new ((*dst)[it->first].buf) Value(GetValue(it).Clone());
   }
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_MAP_INTERNAL_H_