Convert //remoting to use std::unique_ptr

remoting/test/app_remoting_latency_test_fixture.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/test/app_remoting_latency_test_fixture.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/run_loop.h"
@@ skipping 11 matching lines @@
 namespace test {
 
 AppRemotingLatencyTestFixture::AppRemotingLatencyTestFixture()
     : timer_(new base::Timer(true, false)) {
   // NOTE: Derived fixture must initialize application details in constructor.
 }
 
 AppRemotingLatencyTestFixture::~AppRemotingLatencyTestFixture() {}
 
 void AppRemotingLatencyTestFixture::SetUp() {
-  scoped_ptr<TestVideoRenderer> test_video_renderer(new TestVideoRenderer());
+  std::unique_ptr<TestVideoRenderer> test_video_renderer(
+      new TestVideoRenderer());
   test_video_renderer_ = test_video_renderer->GetWeakPtr();
 
-  scoped_ptr<TestChromotingClient> test_chromoting_client(
+  std::unique_ptr<TestChromotingClient> test_chromoting_client(
       new TestChromotingClient(std::move(test_video_renderer)));
 
   test_chromoting_client->AddRemoteConnectionObserver(this);
 
   connection_helper_.reset(
       new AppRemotingConnectionHelper(GetApplicationDetails()));
   connection_helper_->Initialize(std::move(test_chromoting_client));
 
   if (!connection_helper_->StartConnection()) {
     LOG(ERROR) << "Remote host connection could not be established.";
@@ skipping 14 matching lines @@
 
   connection_helper_->test_chromoting_client()->RemoveRemoteConnectionObserver(
       this);
   connection_helper_.reset();
 }
 
 WaitForImagePatternMatchCallback
 AppRemotingLatencyTestFixture::SetExpectedImagePattern(
     const webrtc::DesktopRect& expected_rect,
     const RGBValue& expected_color) {
-  scoped_ptr<base::RunLoop> run_loop(new base::RunLoop());
+  std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop());
 
   test_video_renderer_->ExpectAverageColorInRect(expected_rect, expected_color,
                                                  run_loop->QuitClosure());
 
   return base::Bind(&AppRemotingLatencyTestFixture::WaitForImagePatternMatch,
                     base::Unretained(this), base::Passed(&run_loop));
 }
 
 void AppRemotingLatencyTestFixture::SaveFrameDataToDisk(
     bool save_frame_data_to_disk) {
   test_video_renderer_->SaveFrameDataToDisk(save_frame_data_to_disk);
 }
 
 bool AppRemotingLatencyTestFixture::WaitForImagePatternMatch(
-    scoped_ptr<base::RunLoop> run_loop,
+    std::unique_ptr<base::RunLoop> run_loop,
     const base::TimeDelta& max_wait_time) {
   DCHECK(run_loop);
   DCHECK(!timer_->IsRunning());
 
   timer_->Start(FROM_HERE, max_wait_time, run_loop->QuitClosure());
 
   run_loop->Run();
 
   // Image pattern is matched if we stopped because of the reply not the timer.
   bool image_pattern_is_matched = (timer_->IsRunning());
@@ skipping 70 matching lines @@
 
   run_loop_.reset(new base::RunLoop());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, run_loop_->QuitClosure(), base::TimeDelta::FromSeconds(2));
   run_loop_->Run();
   run_loop_.reset();
 }
 
 }  // namespace test
 }  // namespace remoting