Convert //remoting to use std::unique_ptr

remoting/host/security_key/remote_security_key_message_reader_impl_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_reader.h"
+#include "remoting/host/security_key/remote_security_key_message_reader_impl.h"
 
 #include <cstdint>
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "remoting/host/security_key/remote_security_key_message_reader_impl.h"
 #include "remoting/host/security_key/security_key_message.h"
 #include "remoting/host/setup/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const remoting::RemoteSecurityKeyMessageType kTestMessageType =
     remoting::RemoteSecurityKeyMessageType::CONNECT;
 const uint32_t kMaxSecurityKeyMessageByteCount = 256 * 1024;
 }  // namespace
 
 namespace remoting {
 
 class RemoteSecurityKeyMessageReaderImplTest : public testing::Test {
  public:
   RemoteSecurityKeyMessageReaderImplTest();
   ~RemoteSecurityKeyMessageReaderImplTest() override;
 
   // SecurityKeyMessageCallback passed to the Reader. Stores |message| so it can
   // be verified by tests.
-  void OnMessage(scoped_ptr<SecurityKeyMessage> message);
+  void OnMessage(std::unique_ptr<SecurityKeyMessage> message);
 
   // Used as a callback to signal completion.
   void OperationComplete();
 
  protected:
   // testing::Test interface.
   void SetUp() override;
 
   // Runs the MessageLoop until the reader has completed and called back.
   void RunLoop();
 
   // Closes |write_file_| and runs the MessageLoop until the reader has
   // completed and called back.
   void CloseWriteFileAndRunLoop();
 
   // Writes a message (header+code+body) to the write-end of the pipe.
   void WriteMessage(RemoteSecurityKeyMessageType message_type,
                     const std::string& message_payload);
 
   // Writes some data to the write-end of the pipe.
   void WriteData(const char* data, int length);
 
-  scoped_ptr<RemoteSecurityKeyMessageReader> reader_;
+  std::unique_ptr<RemoteSecurityKeyMessageReader> reader_;
   base::File read_file_;
   base::File write_file_;
 
-  std::vector<scoped_ptr<SecurityKeyMessage>> messages_received_;
+  std::vector<std::unique_ptr<SecurityKeyMessage>> messages_received_;
 
  private:
   base::MessageLoopForIO message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteSecurityKeyMessageReaderImplTest);
 };
 
 RemoteSecurityKeyMessageReaderImplTest::RemoteSecurityKeyMessageReaderImplTest()
     : run_loop_(new base::RunLoop()) {}
 
 RemoteSecurityKeyMessageReaderImplTest::
     ~RemoteSecurityKeyMessageReaderImplTest() {}
 
@@ skipping 15 matching lines @@
   run_loop_.reset(new base::RunLoop());
 }
 
 void RemoteSecurityKeyMessageReaderImplTest::CloseWriteFileAndRunLoop() {
   write_file_.Close();
   run_loop_->Run();
   run_loop_.reset(new base::RunLoop());
 }
 
 void RemoteSecurityKeyMessageReaderImplTest::OnMessage(
-    scoped_ptr<SecurityKeyMessage> message) {
+    std::unique_ptr<SecurityKeyMessage> message) {
   messages_received_.push_back(std::move(message));
   OperationComplete();
 }
 
 void RemoteSecurityKeyMessageReaderImplTest::OperationComplete() {
   run_loop_->Quit();
 }
 
 void RemoteSecurityKeyMessageReaderImplTest::WriteMessage(
     RemoteSecurityKeyMessageType message_type,
@@ skipping 107 matching lines @@
   ASSERT_EQ(payloads.size(), messages_received_.size());
   CloseWriteFileAndRunLoop();
 
   for (size_t i = 0; i < payloads.size(); i++) {
     ASSERT_EQ(kTestMessageType, messages_received_[i]->type());
     ASSERT_EQ(payloads[i], messages_received_[i]->payload());
   }
 }
 
 }  // namespace remoting