Convert //remoting to use std::unique_ptr

remoting/protocol/webrtc_transport_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 "remoting/protocol/webrtc_transport.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 76 matching lines @@
 
   void TearDown() override {
     run_loop_.reset();
     client_message_pipe_.reset();
     client_transport_.reset();
     host_message_pipe_.reset();
     host_transport_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
-  void ProcessTransportInfo(scoped_ptr<WebrtcTransport>* target_transport,
+  void ProcessTransportInfo(std::unique_ptr<WebrtcTransport>* target_transport,
                             bool normalize_line_endings,
-                            scoped_ptr<buzz::XmlElement> transport_info) {
+                            std::unique_ptr<buzz::XmlElement> transport_info) {
     ASSERT_TRUE(target_transport);
 
     // Reformat the message to normalize line endings by removing CR symbol.
     if (normalize_line_endings) {
       std::string xml = transport_info->Str();
       base::ReplaceChars(xml, "\r", std::string(), &xml);
       transport_info.reset(buzz::XmlElement::ForStr(xml));
     }
 
     EXPECT_TRUE(
@@ skipping 64 matching lines @@
         kChannelName, base::Bind(&WebrtcTransportTest::OnClientChannelCreated,
                                  base::Unretained(this)));
   }
 
   void CreateHostDataStream() {
     host_transport_->outgoing_channel_factory()->CreateChannel(
         kChannelName, base::Bind(&WebrtcTransportTest::OnHostChannelCreated,
                                  base::Unretained(this)));
   }
 
-  void OnClientChannelCreated(scoped_ptr<MessagePipe> pipe) {
+  void OnClientChannelCreated(std::unique_ptr<MessagePipe> pipe) {
     client_message_pipe_ = std::move(pipe);
     if (run_loop_ && host_message_pipe_)
       run_loop_->Quit();
   }
 
-  void OnHostChannelCreated(scoped_ptr<MessagePipe> pipe) {
+  void OnHostChannelCreated(std::unique_ptr<MessagePipe> pipe) {
     host_message_pipe_ = std::move(pipe);
     if (run_loop_ && client_message_pipe_)
       run_loop_->Quit();
   }
 
   void OnSessionError(TransportRole role, ErrorCode error) {
     if (role == TransportRole::SERVER) {
       host_error_ = error;
       if (destroy_on_error_) {
         host_message_pipe_.reset();
@@ skipping 11 matching lines @@
   }
 
   void QuitRunLoopOnCounter(int* counter) {
     --(*counter);
     if (*counter == 0)
       run_loop_->Quit();
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   NetworkSettings network_settings_;
 
-  scoped_ptr<WebrtcTransport> host_transport_;
+  std::unique_ptr<WebrtcTransport> host_transport_;
   TestTransportEventHandler host_event_handler_;
-  scoped_ptr<FakeAuthenticator> host_authenticator_;
+  std::unique_ptr<FakeAuthenticator> host_authenticator_;
 
-  scoped_ptr<WebrtcTransport> client_transport_;
+  std::unique_ptr<WebrtcTransport> client_transport_;
   TestTransportEventHandler client_event_handler_;
-  scoped_ptr<FakeAuthenticator> client_authenticator_;
+  std::unique_ptr<FakeAuthenticator> client_authenticator_;
 
-  scoped_ptr<MessagePipe> client_message_pipe_;
-  scoped_ptr<MessagePipe> host_message_pipe_;
+  std::unique_ptr<MessagePipe> client_message_pipe_;
+  std::unique_ptr<MessagePipe> host_message_pipe_;
 
   ErrorCode client_error_ = OK;
   ErrorCode host_error_ = OK;
 
   bool destroy_on_error_ = false;
 };
 
 TEST_F(WebrtcTransportTest, Connects) {
   InitializeConnection();
   StartConnection();
@@ skipping 73 matching lines @@
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
   // Check that OnSessionError() has been called.
   EXPECT_EQ(CHANNEL_CONNECTION_ERROR, host_error_);
   EXPECT_FALSE(host_transport_);
 }
 
 }  // namespace protocol
 }  // namespace remoting