Convert Pass()→std::move() in //components/[n-z]*

components/proximity_auth/device_to_device_authenticator_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 "components/proximity_auth/device_to_device_authenticator.h"
 
+#include <utility>
+
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
 #include "base/timer/mock_timer.h"
 #include "components/proximity_auth/connection.h"
 #include "components/proximity_auth/cryptauth/fake_secure_message_delegate.h"
 #include "components/proximity_auth/device_to_device_responder_operations.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
@@ skipping 60 matching lines @@
   void set_connection_blocked(bool connection_blocked) {
     connection_blocked_ = connection_blocked;
   }
 
   bool connection_blocked() { return connection_blocked_; }
 
  protected:
   // Connection:
   void SendMessageImpl(scoped_ptr<WireMessage> message) override {
     const WireMessage& message_alias = *message;
-    message_buffer_.push_back(message.Pass());
+    message_buffer_.push_back(std::move(message));
     OnDidSendMessage(message_alias, !connection_blocked_);
   }
 
  private:
   ScopedVector<WireMessage> message_buffer_;
 
   bool connection_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeConnection);
 };
 
 // Harness for testing DeviceToDeviceAuthenticator.
 class DeviceToDeviceAuthenticatorForTest : public DeviceToDeviceAuthenticator {
  public:
   DeviceToDeviceAuthenticatorForTest(
       Connection* connection,
       scoped_ptr<SecureMessageDelegate> secure_message_delegate)
       : DeviceToDeviceAuthenticator(connection,
                                     kAccountId,
-                                    secure_message_delegate.Pass()),
+                                    std::move(secure_message_delegate)),
         timer_(nullptr) {}
   ~DeviceToDeviceAuthenticatorForTest() override {}
 
   base::MockTimer* timer() { return timer_; }
 
  private:
   // DeviceToDeviceAuthenticator:
   scoped_ptr<base::Timer> CreateTimer() override {
     bool retain_user_task = false;
     bool is_repeating = false;
 
     scoped_ptr<base::MockTimer> timer(
         new base::MockTimer(retain_user_task, is_repeating));
 
     timer_ = timer.get();
-    return timer.Pass();
+    return std::move(timer);
   }
 
   // This instance is owned by the super class.
   base::MockTimer* timer_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceToDeviceAuthenticatorForTest);
 };
 
 }  // namespace
 
@@ skipping 71 matching lines @@
     EXPECT_FALSE(responder_auth_message.empty());
 
     WireMessage wire_message(responder_auth_message);
     connection_.OnBytesReceived(wire_message.Serialize());
 
     return responder_auth_message;
   }
 
   void OnAuthenticationResult(Authenticator::Result result,
                               scoped_ptr<SecureContext> secure_context) {
-    secure_context_ = secure_context.Pass();
+    secure_context_ = std::move(secure_context);
     OnAuthenticationResultProxy(result);
   }
 
   MOCK_METHOD1(OnAuthenticationResultProxy, void(Authenticator::Result result));
 
   // Contains information about the remote device.
   const RemoteDevice remote_device_;
 
   // Simulates the connection to the remote device.
   FakeConnection connection_;
@@ skipping 113 matching lines @@
   WireMessage wire_message(base::RandBytesAsString(300u));
   connection_.SendMessage(
       make_scoped_ptr(new WireMessage(base::RandBytesAsString(300u))));
   connection_.OnBytesReceived(wire_message.Serialize());
   connection_.SendMessage(
       make_scoped_ptr(new WireMessage(base::RandBytesAsString(300u))));
   connection_.OnBytesReceived(wire_message.Serialize());
 }
 
 }  // namespace proximity_auth