Convert //remoting to use std::unique_ptr

remoting/test/test_video_renderer.cc

Index: remoting/test/test_video_renderer.cc
diff --git a/remoting/test/test_video_renderer.cc b/remoting/test/test_video_renderer.cc
index 00a4bf7f6d179c427f52bf6b323804ed44f1f554..44690a7dd622f858153bc0f861d72f712eaa2278 100644
--- a/remoting/test/test_video_renderer.cc
+++ b/remoting/test/test_video_renderer.cc
@@ -10,6 +10,7 @@
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
@@ -44,14 +45,14 @@ class TestVideoRenderer::Core {
   void Initialize();
 
   // Used to decode video packets.
-  void ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
+  void ProcessVideoPacket(std::unique_ptr<VideoPacket> packet,
                           const base::Closure& done);
 
   // Initialize a decoder to decode video packets.
   void SetCodecForDecoding(const protocol::ChannelConfig::Codec codec);
 
   // Returns a copy of the current frame.
-  scoped_ptr<webrtc::DesktopFrame> GetCurrentFrameForTest() const;
+  std::unique_ptr<webrtc::DesktopFrame> GetCurrentFrameForTest() const;
 
   // Set expected image pattern for comparison and the callback will be called
   // when the pattern is matched.
@@ -78,7 +79,7 @@ class TestVideoRenderer::Core {
   base::ThreadChecker thread_checker_;
 
   // Used to decode video packets.
-  scoped_ptr<VideoDecoder> decoder_;
+  std::unique_ptr<VideoDecoder> decoder_;
 
   // Used to post tasks back to main thread.
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
@@ -87,7 +88,7 @@ class TestVideoRenderer::Core {
   mutable base::Lock lock_;
 
   // Used to store decoded video frame.
-  scoped_ptr<webrtc::SharedDesktopFrame> frame_;
+  std::unique_ptr<webrtc::SharedDesktopFrame> frame_;
 
   // Used to store the expected image pattern.
   webrtc::DesktopRect expected_rect_;
@@ -149,15 +150,16 @@ void TestVideoRenderer::Core::SetCodecForDecoding(
   }
 }
 
-scoped_ptr<webrtc::DesktopFrame>
+std::unique_ptr<webrtc::DesktopFrame>
 TestVideoRenderer::Core::GetCurrentFrameForTest() const {
   base::AutoLock auto_lock(lock_);
   DCHECK(frame_);
-  return make_scoped_ptr(webrtc::BasicDesktopFrame::CopyOf(*frame_));
+  return base::WrapUnique(webrtc::BasicDesktopFrame::CopyOf(*frame_));
 }
 
-void TestVideoRenderer::Core::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
-                                                 const base::Closure& done) {
+void TestVideoRenderer::Core::ProcessVideoPacket(
+    std::unique_ptr<VideoPacket> packet,
+    const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(decoder_);
   DCHECK(packet);
@@ -180,7 +182,7 @@ void TestVideoRenderer::Core::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
   // Render the result into a new DesktopFrame instance that shares buffer with
   // |frame_|. updated_region() will be updated for |new_frame|, but not for
   // |frame_|.
-  scoped_ptr<webrtc::DesktopFrame> new_frame(frame_->Share());
+  std::unique_ptr<webrtc::DesktopFrame> new_frame(frame_->Share());
 
   {
     base::AutoLock auto_lock(lock_);
@@ -193,7 +195,7 @@ void TestVideoRenderer::Core::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
   main_task_runner_->PostTask(FROM_HERE, done);
 
   if (save_frame_data_to_disk_) {
-    scoped_ptr<webrtc::DesktopFrame> frame(
+    std::unique_ptr<webrtc::DesktopFrame> frame(
         webrtc::BasicDesktopFrame::CopyOf(*frame_));
     video_frame_writer.HighlightRectInFrame(frame.get(), expected_rect_);
     video_frame_writer.WriteFrameToDefaultPath(*frame);
@@ -313,8 +315,9 @@ protocol::FrameConsumer* TestVideoRenderer::GetFrameConsumer() {
   return nullptr;
 }
 
-void TestVideoRenderer::ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
-                                           const base::Closure& done) {
+void TestVideoRenderer::ProcessVideoPacket(
+    std::unique_ptr<VideoPacket> video_packet,
+    const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(video_decode_task_runner_) << "Failed to start video decode thread";
 
@@ -345,8 +348,8 @@ void TestVideoRenderer::SetCodecForDecoding(
                             codec));
 }
 
-scoped_ptr<webrtc::DesktopFrame> TestVideoRenderer::GetCurrentFrameForTest()
-    const {
+std::unique_ptr<webrtc::DesktopFrame>
+TestVideoRenderer::GetCurrentFrameForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return core_->GetCurrentFrameForTest();