Convert Pass()→std::move() in //device

device/serial/serial_connection_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 "device/serial/serial_connection.h"
+
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "device/serial/data_receiver.h"
 #include "device/serial/data_sender.h"
 #include "device/serial/data_stream.mojom.h"
 #include "device/serial/serial.mojom.h"
-#include "device/serial/serial_connection.h"
 #include "device/serial/serial_service_impl.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 namespace {
 
 class FakeSerialDeviceEnumerator : public SerialDeviceEnumerator {
   mojo::Array<serial::DeviceInfoPtr> GetDevices() override {
     mojo::Array<serial::DeviceInfoPtr> devices(1);
     devices[0] = serial::DeviceInfo::New();
     devices[0]->path = "device";
-    return devices.Pass();
+    return devices;
   }
 };
 
 }  // namespace
 
 class SerialConnectionTest : public testing::Test {
  public:
   enum Event {
     EVENT_NONE,
     EVENT_GOT_INFO,
@@ skipping 32 matching lines @@
         mojo::GetProxy(&service));
     service.set_connection_error_handler(base::Bind(
         &SerialConnectionTest::OnConnectionError, base::Unretained(this)));
     mojo::InterfacePtr<serial::DataSink> sink;
     mojo::InterfacePtr<serial::DataSource> source;
     mojo::InterfacePtr<serial::DataSourceClient> source_client;
     mojo::InterfaceRequest<serial::DataSourceClient> source_client_request =
         mojo::GetProxy(&source_client);
     service->Connect("device", serial::ConnectionOptions::New(),
                      mojo::GetProxy(&connection_), mojo::GetProxy(&sink),
-                     mojo::GetProxy(&source), source_client.Pass());
-    sender_.reset(new DataSender(sink.Pass(), kBufferSize,
+                     mojo::GetProxy(&source), std::move(source_client));
+    sender_.reset(new DataSender(std::move(sink), kBufferSize,
                                  serial::SEND_ERROR_DISCONNECTED));
     receiver_ =
-        new DataReceiver(source.Pass(), source_client_request.Pass(),
+        new DataReceiver(std::move(source), std::move(source_client_request),
                          kBufferSize, serial::RECEIVE_ERROR_DISCONNECTED);
     connection_.set_connection_error_handler(base::Bind(
         &SerialConnectionTest::OnConnectionError, base::Unretained(this)));
     connection_->GetInfo(
         base::Bind(&SerialConnectionTest::StoreInfo, base::Unretained(this)));
     WaitForEvent(EVENT_GOT_INFO);
     ASSERT_TRUE(io_handler_.get());
   }
 
   void StoreInfo(serial::ConnectionInfoPtr options) {
-    info_ = options.Pass();
+    info_ = std::move(options);
     EventReceived(EVENT_GOT_INFO);
   }
 
   void StoreControlSignals(serial::DeviceControlSignalsPtr signals) {
-    signals_ = signals.Pass();
+    signals_ = std::move(signals);
     EventReceived(EVENT_GOT_CONTROL_SIGNALS);
   }
 
   void StoreSuccess(Event event_to_report, bool success) {
     success_ = success;
     EventReceived(event_to_report);
   }
 
   void Send(const base::StringPiece& data) {
     ASSERT_TRUE(sender_->Send(
@@ skipping 94 matching lines @@
   EXPECT_EQ(serial::STOP_BITS_ONE, info_->stop_bits);
   EXPECT_FALSE(info_->cts_flow_control);
 }
 
 TEST_F(SerialConnectionTest, SetOptions) {
   serial::ConnectionOptionsPtr options(serial::ConnectionOptions::New());
   options->bitrate = 12345;
   options->data_bits = serial::DATA_BITS_SEVEN;
   options->has_cts_flow_control = true;
   options->cts_flow_control = true;
-  connection_->SetOptions(options.Pass(),
-                          base::Bind(&SerialConnectionTest::StoreSuccess,
-                                     base::Unretained(this),
-                                     EVENT_SET_OPTIONS));
+  connection_->SetOptions(
+      std::move(options),
+      base::Bind(&SerialConnectionTest::StoreSuccess, base::Unretained(this),
+                 EVENT_SET_OPTIONS));
   WaitForEvent(EVENT_SET_OPTIONS);
   ASSERT_TRUE(success_);
   serial::ConnectionInfo* info = io_handler_->connection_info();
   EXPECT_EQ(12345u, info->bitrate);
   EXPECT_EQ(serial::DATA_BITS_SEVEN, info->data_bits);
   EXPECT_EQ(serial::PARITY_BIT_NO, info->parity_bit);
   EXPECT_EQ(serial::STOP_BITS_ONE, info->stop_bits);
   EXPECT_TRUE(info->cts_flow_control);
 }
 
@@ skipping 12 matching lines @@
   EXPECT_TRUE(signals_->dsr);
 }
 
 TEST_F(SerialConnectionTest, SetControlSignals) {
   serial::HostControlSignalsPtr signals(serial::HostControlSignals::New());
   signals->has_dtr = true;
   signals->dtr = true;
   signals->has_rts = true;
   signals->rts = true;
 
-  connection_->SetControlSignals(signals.Pass(),
-                                 base::Bind(&SerialConnectionTest::StoreSuccess,
-                                            base::Unretained(this),
-                                            EVENT_SET_CONTROL_SIGNALS));
+  connection_->SetControlSignals(
+      std::move(signals),
+      base::Bind(&SerialConnectionTest::StoreSuccess, base::Unretained(this),
+                 EVENT_SET_CONTROL_SIGNALS));
   WaitForEvent(EVENT_SET_CONTROL_SIGNALS);
   ASSERT_TRUE(success_);
   EXPECT_TRUE(io_handler_->dtr());
   EXPECT_TRUE(io_handler_->rts());
 }
 
 TEST_F(SerialConnectionTest, Flush) {
   ASSERT_EQ(0, io_handler_->flushes());
   connection_->Flush(base::Bind(&SerialConnectionTest::StoreSuccess,
                                 base::Unretained(this),
@@ skipping 57 matching lines @@
   WaitForEvent(EVENT_DATA_SENT);
   EXPECT_EQ(serial::SEND_ERROR_NONE, send_error_);
   EXPECT_EQ(4, bytes_sent_);
   ASSERT_NO_FATAL_FAILURE(Receive());
   WaitForEvent(EVENT_DATA_RECEIVED);
   EXPECT_EQ("data", data_received_);
   EXPECT_EQ(serial::RECEIVE_ERROR_NONE, receive_error_);
 }
 
 }  // namespace device