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

mojo/public/cpp/bindings/map.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_MAP_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_MAP_H_
 
 #include <stddef.h>
-
 #include <map>
+#include <utility>
 
 #include "mojo/public/cpp/bindings/lib/map_internal.h"
 #include "mojo/public/cpp/bindings/lib/value_traits.h"
 
 namespace mojo {
 
 // A move-only map that can handle move-only values. Map has the following
 // characteristics:
 //   - The map itself can be null, and this is distinct from empty.
 //   - Keys must not be move-only.
@@ skipping 27 matching lines @@
   typedef internal::Map_Data<typename internal::WrapperTraits<Key>::DataType,
                              typename internal::WrapperTraits<Value>::DataType>
       Data_;
 
   Map() : is_null_(true) {}
 
   // Constructs a non-null Map containing the specified |keys| mapped to the
   // corresponding |values|.
   Map(mojo::Array<Key> keys, mojo::Array<Value> values) : is_null_(false) {
     MOJO_DCHECK(keys.size() == values.size());
-    Traits::InitializeFrom(&map_, keys.Pass(), values.Pass());
+    Traits::InitializeFrom(&map_, std::move(keys), std::move(values));
   }
 
   ~Map() { Traits::Finalize(&map_); }
 
   Map(Map&& other) : is_null_(true) { Take(&other); }
   Map& operator=(Map&& other) {
     Take(&other);
     return *this;
   }
 
@@ skipping 82 matching lines @@
 
   // Returns a new Map that contains a copy of the contents of this map.  If the
   // values are of a type that is designated move-only, they will be cloned
   // using the Clone() method of the type. Please note that calling this method
   // will fail compilation if the value type cannot be cloned (which usually
   // means that it is a Mojo handle type or a type that contains Mojo handles).
   Map Clone() const {
     Map result;
     result.is_null_ = is_null_;
     Traits::Clone(map_, &result.map_);
-    return result.Pass();
+    return std::move(result);
   }
 
   // Indicates whether the contents of this map are equal to those of another
   // Map (including nullness). Keys are compared by the != operator. Values are
   // compared as follows:
   //   - Map, Array, Struct, or StructPtr values are compared by their Equals()
   //     method.
   //   - ScopedHandleBase-derived types are compared by their handles.
   //   - Values of other types are compared by their "==" operator.
   bool Equals(const Map& other) const {
@@ skipping 89 matching lines @@
           typename STLValue>
 struct TypeConverter<Map<MojoKey, MojoValue>, std::map<STLKey, STLValue>> {
   static Map<MojoKey, MojoValue> Convert(
       const std::map<STLKey, STLValue>& input) {
     Map<MojoKey, MojoValue> result;
     result.mark_non_null();
     for (auto& pair : input) {
       result.insert(TypeConverter<MojoKey, STLKey>::Convert(pair.first),
                     TypeConverter<MojoValue, STLValue>::Convert(pair.second));
     }
-    return result.Pass();
+    return std::move(result);
   }
 };
 
 // Copies the contents of a Map to an std::map, optionally changing the types of
 // the keys and values along the way using TypeConverter.
 template <typename MojoKey,
           typename MojoValue,
           typename STLKey,
           typename STLValue>
 struct TypeConverter<std::map<STLKey, STLValue>, Map<MojoKey, MojoValue>> {
   static std::map<STLKey, STLValue> Convert(
       const Map<MojoKey, MojoValue>& input) {
     std::map<STLKey, STLValue> result;
     if (!input.is_null()) {
       for (auto it = input.begin(); it != input.end(); ++it) {
         result.insert(std::make_pair(
             TypeConverter<STLKey, MojoKey>::Convert(it.GetKey()),
             TypeConverter<STLValue, MojoValue>::Convert(it.GetValue())));
       }
     }
     return result;
   }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_MAP_H_