Convert "return local_var.Pass();" to "return local_var;".

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 <map>
 #include <type_traits>
 
@@ skipping 118 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 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 117 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 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.cbegin(); it != input.cend(); ++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_