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

mojo/public/cpp/bindings/array.h

 // Copyright 2013 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_ARRAY_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_
 
 #include <stddef.h>
 #include <string.h>
-
 #include <algorithm>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/lib/value_traits.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 
@@ skipping 26 matching lines @@
   // Moves the contents of |other| into this array.
   Array(Array&& other) : is_null_(true) { Take(&other); }
   Array& operator=(Array&& other) {
     Take(&other);
     return *this;
   }
 
   // Creates a non-null array of the specified size. The elements will be
   // value-initialized (meaning that they will be initialized by their default
   // constructor, if any, or else zero-initialized).
-  static Array New(size_t size) { return Array(size).Pass(); }
+  static Array New(size_t size) { return std::move(Array(size)); }
 
   // Creates a new array with a copy of the contents of |other|.
   template <typename U>
   static Array From(const U& other) {
     return TypeConverter<Array, U>::Convert(other);
   }
 
   // Copies the contents of this array to a new object of type |U|.
   template <typename U>
   U To() const {
@@ skipping 68 matching lines @@
   // calling the |Clone| method of the source element, which should make a copy
   // of the element.
   //
   // Please note that calling this method will fail compilation if the element
   // type cannot be cloned (which usually means that it is a Mojo handle type or
   // a type contains Mojo handles).
   Array Clone() const {
     Array result;
     result.is_null_ = is_null_;
     Traits::Clone(vec_, &result.vec_);
-    return result.Pass();
+    return std::move(result);
   }
 
   // Indicates whether the contents of this array are equal to |other|. A null
   // array is only equal to another null array. Elements are compared using the
   // |ValueTraits::Equals| method, which in most cases calls the |Equals| method
   // of the element.
   bool Equals(const Array& other) const {
     if (is_null() != other.is_null())
       return false;
     if (size() != other.size())
@@ skipping 30 matching lines @@
 
 // A |TypeConverter| that will create an |Array<T>| containing a copy of the
 // contents of an |std::vector<E>|, using |TypeConverter<T, E>| to copy each
 // element. The returned array will always be non-null.
 template <typename T, typename E>
 struct TypeConverter<Array<T>, std::vector<E>> {
   static Array<T> Convert(const std::vector<E>& input) {
     Array<T> result(input.size());
     for (size_t i = 0; i < input.size(); ++i)
       result[i] = TypeConverter<T, E>::Convert(input[i]);
-    return result.Pass();
+    return std::move(result);
   }
 };
 
 // A |TypeConverter| that will create an |std::vector<E>| containing a copy of
 // the contents of an |Array<T>|, using |TypeConverter<E, T>| to copy each
 // element. If the input array is null, the output vector will be empty.
 template <typename E, typename T>
 struct TypeConverter<std::vector<E>, Array<T>> {
   static std::vector<E> Convert(const Array<T>& input) {
     std::vector<E> result;
     if (!input.is_null()) {
       result.resize(input.size());
       for (size_t i = 0; i < input.size(); ++i)
         result[i] = TypeConverter<E, T>::Convert(input[i]);
     }
     return result;
   }
 };
 
 // A |TypeConverter| that will create an |Array<T>| containing a copy of the
 // contents of an |std::set<E>|, using |TypeConverter<T, E>| to copy each
 // element. The returned array will always be non-null.
 template <typename T, typename E>
 struct TypeConverter<Array<T>, std::set<E>> {
   static Array<T> Convert(const std::set<E>& input) {
     Array<T> result(0u);
     for (auto i : input)
       result.push_back(TypeConverter<T, E>::Convert(i));
-    return result.Pass();
+    return std::move(result);
   }
 };
 
 // A |TypeConverter| that will create an |std::set<E>| containing a copy of
 // the contents of an |Array<T>|, using |TypeConverter<E, T>| to copy each
 // element. If the input array is null, the output set will be empty.
 template <typename E, typename T>
 struct TypeConverter<std::set<E>, Array<T>> {
   static std::set<E> Convert(const Array<T>& input) {
     std::set<E> result;
     if (!input.is_null()) {
       for (size_t i = 0; i < input.size(); ++i)
         result.insert(TypeConverter<E, T>::Convert(input[i]));
     }
     return result;
   }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_