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

mojo/public/cpp/bindings/lib/array_serialization.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_ARRAY_SERIALIZATION_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_
 
 #include <stddef.h>
 #include <string.h>  // For |memcpy()|.
 
@@ skipping 147 matching lines @@
       size += GetSerializedSize_(input[i]);
     return size;
   }
 
   static void SerializeElements(Array<S> input,
                                 Buffer* buf,
                                 Array_Data<S_Data*>* output,
                                 const ArrayValidateParams* validate_params) {
     for (size_t i = 0; i < input.size(); ++i) {
       S_Data* element;
-      SerializeCaller<S>::Run(input[i].Pass(), buf, &element,
+      SerializeCaller<S>::Run(std::move(input[i]), buf, &element,
                               validate_params->element_validate_params);
       output->at(i) = element;
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && !element,
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid pointers",
                                     input.size(), i));
     }
   }
   static bool DeserializeElements(Array_Data<S_Data*>* input,
@@ skipping 25 matching lines @@
       Serialize_(input.Pass(), buf, output);
     }
   };
 
   template <typename T>
   struct SerializeCaller<Array<T>> {
     static void Run(Array<T> input,
                     Buffer* buf,
                     typename Array<T>::Data_** output,
                     const ArrayValidateParams* validate_params) {
-      SerializeArray_(input.Pass(), buf, output, validate_params);
+      SerializeArray_(std::move(input), buf, output, validate_params);
     }
   };
 
   template <typename T, typename U>
   struct SerializeCaller<Map<T, U>> {
     static void Run(Map<T, U> input,
                     Buffer* buf,
                     typename Map<T, U>::Data_** output,
                     const ArrayValidateParams* validate_params) {
-      SerializeMap_(input.Pass(), buf, output, validate_params);
+      SerializeMap_(std::move(input), buf, output, validate_params);
     }
   };
 };
 
 // Handles serialization and deserialization of arrays of unions.
 template <typename U, typename U_Data>
 struct ArraySerializer<U, U_Data, true> {
   static size_t GetSerializedSize(const Array<U>& input) {
     size_t size = sizeof(Array_Data<U_Data>);
     for (size_t i = 0; i < input.size(); ++i) {
       // GetSerializedSize_ will account for both the data in the union and the
       // space in the array used to hold the union.
       size += GetSerializedSize_(input[i], false);
     }
     return size;
   }
 
   static void SerializeElements(Array<U> input,
                                 Buffer* buf,
                                 Array_Data<U_Data>* output,
                                 const ArrayValidateParams* validate_params) {
     for (size_t i = 0; i < input.size(); ++i) {
       U_Data* result = output->storage() + i;
-      SerializeUnion_(input[i].Pass(), buf, &result, true);
+      SerializeUnion_(std::move(input[i]), buf, &result, true);
       MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
           !validate_params->element_is_nullable && output->at(i).is_null(),
           VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
           MakeMessageWithArrayIndex("null in array expecting valid unions",
                                     input.size(), i));
     }
   }
 
   static bool DeserializeElements(Array_Data<U_Data>* input,
                                   Array<U>* output,
@@ skipping 107 matching lines @@
     }
   } else {
     output->reset();
   }
   return true;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_ARRAY_SERIALIZATION_H_