Convert //remoting to use std::unique_ptr

remoting/protocol/connection_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 <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/fake_session.h"
 #include "remoting/protocol/fake_video_renderer.h"
 #include "remoting/protocol/ice_connection_to_client.h"
 #include "remoting/protocol/ice_connection_to_host.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/video_stream.h"
@@ skipping 45 matching lines @@
  public:
   TestScreenCapturer() {}
   ~TestScreenCapturer() override {}
 
   // webrtc::DesktopCapturer interface.
   void Start(Callback* callback) override {
     callback_ = callback;
   }
   void Capture(const webrtc::DesktopRegion& region) override {
     // Return black 10x10 frame.
-    scoped_ptr<webrtc::DesktopFrame> frame(
+    std::unique_ptr<webrtc::DesktopFrame> frame(
         new webrtc::BasicDesktopFrame(webrtc::DesktopSize(100, 100)));
     memset(frame->data(), 0, frame->stride() * frame->size().height());
     frame->mutable_updated_region()->SetRect(
         webrtc::DesktopRect::MakeSize(frame->size()));
     callback_->OnCaptureCompleted(frame.release());
   }
 
  private:
   Callback* callback_ = nullptr;
 };
@@ skipping 10 matching lines @@
 
   void SetUp() override {
     // Create fake sessions.
     host_session_ = new FakeSession();
     owned_client_session_.reset(new FakeSession());
     client_session_ = owned_client_session_.get();
 
     // Create Connection objects.
     if (is_using_webrtc()) {
       host_connection_.reset(new WebrtcConnectionToClient(
-          make_scoped_ptr(host_session_),
+          base::WrapUnique(host_session_),
           TransportContext::ForTests(protocol::TransportRole::SERVER)));
       client_connection_.reset(new WebrtcConnectionToHost());
 
     } else {
       host_connection_.reset(new IceConnectionToClient(
-          make_scoped_ptr(host_session_),
+          base::WrapUnique(host_session_),
           TransportContext::ForTests(protocol::TransportRole::SERVER),
           message_loop_.task_runner()));
       client_connection_.reset(new IceConnectionToHost());
     }
 
     // Setup host side.
     host_connection_->SetEventHandler(&host_event_handler_);
     host_connection_->set_clipboard_stub(&host_clipboard_stub_);
     host_connection_->set_host_stub(&host_stub_);
     host_connection_->set_input_stub(&host_input_stub_);
@@ skipping 58 matching lines @@
       run_loop_->Quit();
   }
 
   void OnClientConnected() {
     client_connected_ = true;
     if (host_connected_ && run_loop_)
       run_loop_->Quit();
   }
 
   base::MessageLoopForIO message_loop_;
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   MockConnectionToClientEventHandler host_event_handler_;
   MockClipboardStub host_clipboard_stub_;
   MockHostStub host_stub_;
   MockInputStub host_input_stub_;
-  scoped_ptr<ConnectionToClient> host_connection_;
+  std::unique_ptr<ConnectionToClient> host_connection_;
   FakeSession* host_session_;  // Owned by |host_connection_|.
   bool host_connected_ = false;
 
   MockConnectionToHostEventCallback client_event_handler_;
   MockClientStub client_stub_;
   MockClipboardStub client_clipboard_stub_;
   FakeVideoRenderer client_video_renderer_;
-  scoped_ptr<ConnectionToHost> client_connection_;
+  std::unique_ptr<ConnectionToHost> client_connection_;
   FakeSession* client_session_;  // Owned by |client_connection_|.
-  scoped_ptr<FakeSession> owned_client_session_;
+  std::unique_ptr<FakeSession> owned_client_session_;
   bool client_connected_ = false;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConnectionTest);
 };
 
 INSTANTIATE_TEST_CASE_P(Ice, ConnectionTest, ::testing::Values(false));
 INSTANTIATE_TEST_CASE_P(Webrtc, ConnectionTest, ::testing::Values(true));
 
 TEST_P(ConnectionTest, RejectConnection) {
@@ skipping 55 matching lines @@
 
   // Send capabilities from the client.
   client_connection_->input_stub()->InjectKeyEvent(event);
 
   run_loop.Run();
 }
 
 TEST_P(ConnectionTest, Video) {
   Connect();
 
-  scoped_ptr<VideoStream> video_stream = host_connection_->StartVideoStream(
-      make_scoped_ptr(new TestScreenCapturer()));
+  std::unique_ptr<VideoStream> video_stream =
+      host_connection_->StartVideoStream(
+          base::WrapUnique(new TestScreenCapturer()));
 
   base::RunLoop run_loop;
 
   // Expect frames to be passed to FrameConsumer when WebRTC is used, or to
   // VideoStub otherwise.
   if (is_using_webrtc()) {
     client_video_renderer_.GetFrameConsumer()->set_on_frame_callback(
         base::Bind(&base::RunLoop::Quit, base::Unretained(&run_loop)));
   } else {
     client_video_renderer_.GetVideoStub()->set_on_frame_callback(
@@ skipping 13 matching lines @@
         client_video_renderer_.GetFrameConsumer()->received_frames().size(),
         0U);
     EXPECT_EQ(client_video_renderer_.GetVideoStub()->received_packets().size(),
               1U);
   }
 
 }
 
 }  // namespace protocol
 }  // namespace remoting