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

mojo/public/cpp/bindings/tests/sample_service_unittest.cc

 // 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.
 
 #include <algorithm>
 #include <ostream>
 #include <string>
+#include <utility>
 
 #include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 
 template <>
 struct TypeConverter<int32_t, sample::BarPtr> {
   static int32_t Convert(const sample::BarPtr& bar) {
     return static_cast<int32_t>(bar->alpha) << 16 |
@@ skipping 25 matching lines @@
 
   mojo::Array<BarPtr> extra_bars(3);
   for (size_t i = 0; i < extra_bars.size(); ++i) {
     Bar::Type type = i % 2 == 0 ? Bar::TYPE_VERTICAL : Bar::TYPE_HORIZONTAL;
     BarPtr bar(Bar::New());
     uint8_t base = static_cast<uint8_t>(i * 100);
     bar->alpha = base;
     bar->beta = base + 20;
     bar->gamma = base + 40;
     bar->type = type;
-    extra_bars[i] = bar.Pass();
+    extra_bars[i] = std::move(bar);
   }
 
   mojo::Array<uint8_t> data(10);
   for (size_t i = 0; i < data.size(); ++i)
     data[i] = static_cast<uint8_t>(data.size() - i);
 
   mojo::Array<mojo::ScopedDataPipeConsumerHandle> input_streams(2);
   mojo::Array<mojo::ScopedDataPipeProducerHandle> output_streams(2);
   for (size_t i = 0; i < input_streams.size(); ++i) {
     MojoCreateDataPipeOptions options;
     options.struct_size = sizeof(MojoCreateDataPipeOptions);
     options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
     options.element_num_bytes = 1;
     options.capacity_num_bytes = 1024;
     mojo::ScopedDataPipeProducerHandle producer;
     mojo::ScopedDataPipeConsumerHandle consumer;
     mojo::CreateDataPipe(&options, &producer, &consumer);
-    input_streams[i] = consumer.Pass();
-    output_streams[i] = producer.Pass();
+    input_streams[i] = std::move(consumer);
+    output_streams[i] = std::move(producer);
   }
 
   mojo::Array<mojo::Array<bool>> array_of_array_of_bools(2);
   for (size_t i = 0; i < 2; ++i) {
     mojo::Array<bool> array_of_bools(2);
     for (size_t j = 0; j < 2; ++j)
       array_of_bools[j] = j;
-    array_of_array_of_bools[i] = array_of_bools.Pass();
+    array_of_array_of_bools[i] = std::move(array_of_bools);
   }
 
   mojo::MessagePipe pipe;
   FooPtr foo(Foo::New());
   foo->name = name;
   foo->x = 1;
   foo->y = 2;
   foo->a = false;
   foo->b = true;
   foo->c = false;
-  foo->bar = bar.Pass();
-  foo->extra_bars = extra_bars.Pass();
-  foo->data = data.Pass();
-  foo->source = pipe.handle1.Pass();
-  foo->input_streams = input_streams.Pass();
-  foo->output_streams = output_streams.Pass();
-  foo->array_of_array_of_bools = array_of_array_of_bools.Pass();
+  foo->bar = std::move(bar);
+  foo->extra_bars = std::move(extra_bars);
+  foo->data = std::move(data);
+  foo->source = std::move(pipe.handle1);
+  foo->input_streams = std::move(input_streams);
+  foo->output_streams = std::move(output_streams);
+  foo->array_of_array_of_bools = std::move(array_of_array_of_bools);
 
-  return foo.Pass();
+  return foo;
 }
 
 // Check that the given |Foo| is identical to the one made by |MakeFoo()|.
 void CheckFoo(const Foo& foo) {
   const std::string kName("foopy");
   ASSERT_FALSE(foo.name.is_null());
   EXPECT_EQ(kName.size(), foo.name.size());
   for (size_t i = 0; i < std::min(kName.size(), foo.name.size()); i++) {
     // Test both |operator[]| and |at|.
     EXPECT_EQ(kName[i], foo.name.at(i)) << i;
@@ skipping 212 matching lines @@
   // User constructs a message to send.
 
   // Notice that it doesn't matter in what order the structs / arrays are
   // allocated. Here, the various members of Foo are allocated before Foo is
   // allocated.
 
   FooPtr foo = MakeFoo();
   CheckFoo(*foo);
 
   PortPtr port;
-  service->Frobinate(foo.Pass(), Service::BAZ_OPTIONS_EXTRA, port.Pass(),
-                     Service::FrobinateCallback());
+  service->Frobinate(std::move(foo), Service::BAZ_OPTIONS_EXTRA,
+                     std::move(port), Service::FrobinateCallback());
 
   delete service;
 }
 
 TEST_F(BindingsSampleTest, DefaultValues) {
   DefaultsTestPtr defaults(DefaultsTest::New());
   EXPECT_EQ(-12, defaults->a0);
   EXPECT_EQ(kTwelve, defaults->a1);
   EXPECT_EQ(1234, defaults->a2);
   EXPECT_EQ(34567U, defaults->a3);
@@ skipping 18 matching lines @@
   ASSERT_FALSE(defaults->a22.is_null());
   EXPECT_EQ(imported::SHAPE_RECTANGLE, defaults->a22->shape);
   EXPECT_EQ(imported::COLOR_BLACK, defaults->a22->color);
   EXPECT_EQ(0xFFFFFFFFFFFFFFFFULL, defaults->a23);
   EXPECT_EQ(0x123456789, defaults->a24);
   EXPECT_EQ(-0x123456789, defaults->a25);
 }
 
 }  // namespace
 }  // namespace sample