Convert //components/proximity_auth from scoped_ptr to std::unique_ptr

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/ptr_util.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"
 #include "components/proximity_auth/secure_context.h"
 #include "components/proximity_auth/wire_message.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 55 matching lines @@
   const ScopedVector<WireMessage>& message_buffer() { return message_buffer_; }
 
   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 {
+  void SendMessageImpl(std::unique_ptr<WireMessage> message) override {
     const WireMessage& message_alias = *message;
     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)
+      std::unique_ptr<SecureMessageDelegate> secure_message_delegate)
       : DeviceToDeviceAuthenticator(connection,
                                     kAccountId,
                                     std::move(secure_message_delegate)),
         timer_(nullptr) {}
   ~DeviceToDeviceAuthenticatorForTest() override {}
 
   base::MockTimer* timer() { return timer_; }
 
  private:
   // DeviceToDeviceAuthenticator:
-  scoped_ptr<base::Timer> CreateTimer() override {
+  std::unique_ptr<base::Timer> CreateTimer() override {
     bool retain_user_task = false;
     bool is_repeating = false;
 
-    scoped_ptr<base::MockTimer> timer(
+    std::unique_ptr<base::MockTimer> timer(
         new base::MockTimer(retain_user_task, is_repeating));
 
     timer_ = timer.get();
     return std::move(timer);
   }
 
   // This instance is owned by the super class.
   base::MockTimer* timer_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceToDeviceAuthenticatorForTest);
 };
 
 }  // namespace
 
 class ProximityAuthDeviceToDeviceAuthenticatorTest : public testing::Test {
  public:
   ProximityAuthDeviceToDeviceAuthenticatorTest()
       : remote_device_(CreateClassicRemoteDeviceForTest()),
         connection_(remote_device_),
         secure_message_delegate_(new FakeSecureMessageDelegate),
         authenticator_(&connection_,
-                       make_scoped_ptr(secure_message_delegate_)) {}
+                       base::WrapUnique(secure_message_delegate_)) {}
   ~ProximityAuthDeviceToDeviceAuthenticatorTest() override {}
 
   void SetUp() override {
     // Set up the session asymmetric keys for both the local and remote devices.
     ASSERT_TRUE(
         base::Base64UrlDecode(kInitiatorSessionPublicKeyBase64,
                               base::Base64UrlDecodePolicy::REQUIRE_PADDING,
                               &local_session_public_key_));
     ASSERT_TRUE(
         base::Base64UrlDecode(kResponderSessionPublicKeyBase64,
@@ skipping 52 matching lines @@
         base::Bind(&SaveStringResult, &responder_auth_message));
     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) {
+                              std::unique_ptr<SecureContext> secure_context) {
     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_;
 
   // The SecureMessageDelegate used by the authenticator.
   // Owned by |authenticator_|.
   FakeSecureMessageDelegate* secure_message_delegate_;
 
   // The DeviceToDeviceAuthenticator under test.
   DeviceToDeviceAuthenticatorForTest authenticator_;
 
   // The session keys in play during authentication.
   std::string local_session_public_key_;
   std::string remote_session_public_key_;
   std::string remote_session_private_key_;
   std::string session_symmetric_key_;
 
   // Stores the SecureContext returned after authentication succeeds.
-  scoped_ptr<SecureContext> secure_context_;
+  std::unique_ptr<SecureContext> secure_context_;
 
   DISALLOW_COPY_AND_ASSIGN(ProximityAuthDeviceToDeviceAuthenticatorTest);
 };
 
 TEST_F(ProximityAuthDeviceToDeviceAuthenticatorTest, AuthenticateSucceeds) {
   // Starts the authentication protocol and grab [Hello] message.
   std::string hello_message = BeginAuthentication();
 
   // Simulate receiving a valid [Responder Auth] from the remote device.
   EXPECT_CALL(*this,
@@ skipping 79 matching lines @@
        SendMessagesAfterAuthenticationSuccess) {
   std::string hello_message = BeginAuthentication();
   EXPECT_CALL(*this,
               OnAuthenticationResultProxy(Authenticator::Result::SUCCESS));
   SimulateResponderAuth(hello_message);
 
   // Test that the authenticator is properly cleaned up after authentication
   // completes.
   WireMessage wire_message(base::RandBytesAsString(300u));
   connection_.SendMessage(
-      make_scoped_ptr(new WireMessage(base::RandBytesAsString(300u))));
+      base::WrapUnique(new WireMessage(base::RandBytesAsString(300u))));
   connection_.OnBytesReceived(wire_message.Serialize());
   connection_.SendMessage(
-      make_scoped_ptr(new WireMessage(base::RandBytesAsString(300u))));
+      base::WrapUnique(new WireMessage(base::RandBytesAsString(300u))));
   connection_.OnBytesReceived(wire_message.Serialize());
 }
 
 }  // namespace proximity_auth