Convert //remoting to use std::unique_ptr

remoting/host/security_key/remote_security_key_message_handler_unittest.cc

 // Copyright 2016 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 "remoting/host/security_key/remote_security_key_message_handler.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "remoting/host/security_key/fake_remote_security_key_ipc_client.h"
 #include "remoting/host/security_key/fake_remote_security_key_message_reader.h"
 #include "remoting/host/security_key/fake_remote_security_key_message_writer.h"
 #include "remoting/host/security_key/remote_security_key_ipc_constants.h"
 #include "remoting/host/security_key/security_key_message.h"
 #include "remoting/host/setup/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 21 matching lines @@
                             const std::string& message_payload);
 
   bool last_operation_failed_ = false;
   RemoteSecurityKeyMessageType last_message_type_received_ =
       RemoteSecurityKeyMessageType::INVALID;
   std::string last_message_payload_received_;
 
   base::WeakPtr<FakeRemoteSecurityKeyIpcClient> ipc_client_weak_ptr_;
   base::WeakPtr<FakeRemoteSecurityKeyMessageReader> reader_weak_ptr_;
   base::WeakPtr<FakeRemoteSecurityKeyMessageWriter> writer_weak_ptr_;
-  scoped_ptr<RemoteSecurityKeyMessageHandler> message_handler_;
+  std::unique_ptr<RemoteSecurityKeyMessageHandler> message_handler_;
 
  private:
   base::MessageLoopForIO message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteSecurityKeyMessageHandlerTest);
 };
 
 RemoteSecurityKeyMessageHandlerTest::RemoteSecurityKeyMessageHandlerTest() {}
 
 RemoteSecurityKeyMessageHandlerTest::~RemoteSecurityKeyMessageHandlerTest() {}
 
 void RemoteSecurityKeyMessageHandlerTest::OperationComplete() {
   run_loop_->Quit();
 }
 
 void RemoteSecurityKeyMessageHandlerTest::SetUp() {
   run_loop_.reset(new base::RunLoop());
   message_handler_.reset(new RemoteSecurityKeyMessageHandler());
 
-  scoped_ptr<FakeRemoteSecurityKeyIpcClient> ipc_client(
+  std::unique_ptr<FakeRemoteSecurityKeyIpcClient> ipc_client(
       new FakeRemoteSecurityKeyIpcClient(
           base::Bind(&RemoteSecurityKeyMessageHandlerTest::OperationComplete,
                      base::Unretained(this))));
   ipc_client_weak_ptr_ = ipc_client->AsWeakPtr();
 
-  scoped_ptr<FakeRemoteSecurityKeyMessageReader> reader(
+  std::unique_ptr<FakeRemoteSecurityKeyMessageReader> reader(
       new FakeRemoteSecurityKeyMessageReader());
   reader_weak_ptr_ = reader->AsWeakPtr();
 
-  scoped_ptr<FakeRemoteSecurityKeyMessageWriter> writer(
+  std::unique_ptr<FakeRemoteSecurityKeyMessageWriter> writer(
       new FakeRemoteSecurityKeyMessageWriter(
           base::Bind(&RemoteSecurityKeyMessageHandlerTest::OperationComplete,
                      base::Unretained(this))));
   writer_weak_ptr_ = writer->AsWeakPtr();
 
   message_handler_->SetRemoteSecurityKeyMessageReaderForTest(std::move(reader));
 
   message_handler_->SetRemoteSecurityKeyMessageWriterForTest(std::move(writer));
 
   base::File read_file;
@@ skipping 196 matching lines @@
   reader_weak_ptr_->message_callback().Run(
       SecurityKeyMessage::CreateMessageForTest(
           RemoteSecurityKeyMessageType::UNKNOWN_ERROR, std::string()));
   WaitForOperationComplete();
 
   ASSERT_EQ(RemoteSecurityKeyMessageType::UNKNOWN_COMMAND,
             writer_weak_ptr_->last_message_type());
 }
 
 }  // namespace remoting