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

device/devices_app/usb/device_impl_unittest.cc

 // Copyright 2015 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/devices_app/usb/device_impl.h"
+
 #include <stddef.h>
 #include <stdint.h>
-
 #include <map>
 #include <queue>
 #include <set>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
-#include "device/devices_app/usb/device_impl.h"
 #include "device/devices_app/usb/fake_permission_provider.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace device {
@@ skipping 121 matching lines @@
                                const std::string& manufacturer,
                                const std::string& product,
                                const std::string& serial) {
     mock_device_ =
         new MockUsbDevice(vendor_id, product_id, manufacturer, product, serial);
     mock_handle_ = new MockUsbDeviceHandle(mock_device_.get());
 
     PermissionProviderPtr permission_provider;
     permission_provider_.Bind(mojo::GetProxy(&permission_provider));
     DevicePtr proxy;
-    new DeviceImpl(mock_device_, permission_provider.Pass(),
+    new DeviceImpl(mock_device_, std::move(permission_provider),
                    mojo::GetProxy(&proxy));
 
     // Set up mock handle calls to respond based on mock device configs
     // established by the test.
     ON_CALL(mock_device(), Open(_))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::OpenMockHandle));
     ON_CALL(mock_device(), GetActiveConfiguration())
         .WillByDefault(
             Invoke(this, &USBDeviceImplTest::GetActiveConfiguration));
     ON_CALL(mock_handle(), Close())
         .WillByDefault(Invoke(this, &USBDeviceImplTest::CloseMockHandle));
     ON_CALL(mock_handle(), SetConfiguration(_, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::SetConfiguration));
     ON_CALL(mock_handle(), ClaimInterface(_, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::ClaimInterface));
     ON_CALL(mock_handle(), ReleaseInterface(_))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::ReleaseInterface));
     ON_CALL(mock_handle(), SetInterfaceAlternateSetting(_, _, _))
         .WillByDefault(
             Invoke(this, &USBDeviceImplTest::SetInterfaceAlternateSetting));
     ON_CALL(mock_handle(), ResetDevice(_))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::ResetDevice));
     ON_CALL(mock_handle(), ControlTransfer(_, _, _, _, _, _, _, _, _, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::ControlTransfer));
     ON_CALL(mock_handle(), GenericTransfer(_, _, _, _, _, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::GenericTransfer));
     ON_CALL(mock_handle(), IsochronousTransfer(_, _, _, _, _, _, _, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::IsochronousTransfer));
 
-    return proxy.Pass();
+    return proxy;
   }
 
   DevicePtr GetMockDeviceProxy() {
     return GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
   }
 
   void AddMockConfig(const ConfigBuilder& builder) {
     const UsbConfigDescriptor& config = builder.config();
     DCHECK(!ContainsKey(mock_configs_, config.configuration_value));
     mock_configs_[config.configuration_value] = config;
@@ skipping 454 matching lines @@
 
   {
     auto params = ControlTransferParams::New();
     params->type = CONTROL_TRANSFER_TYPE_STANDARD;
     params->recipient = CONTROL_TRANSFER_RECIPIENT_DEVICE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferIn(
-        params.Pass(), static_cast<uint32_t>(fake_data.size()), 0,
+        std::move(params), static_cast<uint32_t>(fake_data.size()), 0,
         base::Bind(&ExpectTransferInAndThen, TRANSFER_STATUS_COMPLETED,
                    fake_data, loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockOutboundData(fake_data);
 
   EXPECT_CALL(mock_device(), GetActiveConfiguration());
   EXPECT_CALL(mock_handle(),
               ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
 
   {
     auto params = ControlTransferParams::New();
     params->type = CONTROL_TRANSFER_TYPE_STANDARD;
     params->recipient = CONTROL_TRANSFER_RECIPIENT_INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
-        params.Pass(), mojo::Array<uint8_t>::From(fake_data), 0,
+        std::move(params), mojo::Array<uint8_t>::From(fake_data), 0,
         base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, GenericTransfer) {
   DevicePtr device = GetMockDeviceProxy();
@@ skipping 80 matching lines @@
     base::RunLoop loop;
     mojo::Array<mojo::Array<uint8_t>> packets =
         mojo::Array<mojo::Array<uint8_t>>::New(4);
     for (size_t i = 0; i < 4; ++i) {
       std::vector<uint8_t> bytes(8);
       std::copy(outbound_packet_data.begin() + i * 8,
                 outbound_packet_data.begin() + i * 8 + 8, bytes.begin());
       packets[i].Swap(&bytes);
     }
     device->IsochronousTransferOut(
-        1, packets.Pass(), 0,
+        1, std::move(packets), 0,
         base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(),
               IsochronousTransfer(USB_DIRECTION_INBOUND, 0x81, _,
                                   fake_inbound_packets.size(), 4, 8, 0, _));
 
   {
     base::RunLoop loop;
     std::vector<std::vector<uint8_t>> packets(4);
     for (size_t i = 0; i < 4; ++i) {
       packets[i].resize(8);
       std::copy(inbound_packet_data.begin() + i * 8,
                 inbound_packet_data.begin() + i * 8 + 8, packets[i].begin());
     }
     device->IsochronousTransferIn(
         1, 4, 8, 0, base::Bind(&ExpectPacketsAndThen, TRANSFER_STATUS_COMPLETED,
                                packets, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device