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 <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)); }

[Ken Rockot(use gerrit already), 2015/12/21 18:49:22]

Shouldn't clang complain that moving a temporary prevents copy elision (here and
elsewhere)? Why is this necessary? I remember we were calling Pass() before
because MSVC choked otherwise, but I didn't know if that was still an issue.

[dcheng, 2015/12/21 19:27:27]

It does in many instances: you'll notice that some of the diffs just deleted
Pass() instead of changing it to std::move().

However, I'm not sure why this particular instance didn't trigger the warning:
it certainly looks like it should. We had similar issues with scoped_ptr.h which
were diagnosed as a failure to have an actual move constructor, but that doesn't
appear to be the case here.

As these patches are largely automated, I'd prefer not to fix things the
compiler doesn't warn about (though this particular instance is quite odd, and
I'll be follow up on it separately anyway).

 
   // 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_