Convert //remoting to use std::unique_ptr

remoting/host/mouse_cursor_monitor_proxy_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/mouse_cursor_monitor_proxy.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 38 matching lines @@
     EXPECT_FALSE(callback_);
     EXPECT_TRUE(callback);
 
     callback_ = callback;
   }
 
   void Capture() override {
     EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
     ASSERT_TRUE(callback_);
 
-    scoped_ptr<webrtc::MouseCursor> mouse_cursor(new webrtc::MouseCursor(
+    std::unique_ptr<webrtc::MouseCursor> mouse_cursor(new webrtc::MouseCursor(
         new webrtc::BasicDesktopFrame(
             webrtc::DesktopSize(kCursorWidth, kCursorHeight)),
         webrtc::DesktopVector(kHotspotX, kHotspotY)));
 
     callback_->OnMouseCursor(mouse_cursor.release());
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
@@ skipping 17 matching lines @@
 
   // webrtc::MouseCursorMonitor::Callback implementation.
   void OnMouseCursor(webrtc::MouseCursor* mouse_cursor) override;
   void OnMouseCursorPosition(webrtc::MouseCursorMonitor::CursorState state,
                              const webrtc::DesktopVector& position) override;
 
  protected:
   base::MessageLoop message_loop_;
   base::RunLoop run_loop_;
   base::Thread capture_thread_;
-  scoped_ptr<MouseCursorMonitorProxy> proxy_;
+  std::unique_ptr<MouseCursorMonitorProxy> proxy_;
 
   MockClientStub client_stub_;
 };
 
 void MouseCursorMonitorProxyTest::OnMouseCursor(
     webrtc::MouseCursor* mouse_cursor) {
   DCHECK(message_loop_.task_runner()->BelongsToCurrentThread());
 
   EXPECT_EQ(kCursorWidth, mouse_cursor->image()->size().width());
   EXPECT_EQ(kCursorHeight, mouse_cursor->image()->size().height());
   EXPECT_EQ(kHotspotX, mouse_cursor->hotspot().x());
   EXPECT_EQ(kHotspotY, mouse_cursor->hotspot().y());
   delete mouse_cursor;
 
   run_loop_.Quit();
 }
 
 void MouseCursorMonitorProxyTest::OnMouseCursorPosition(
     webrtc::MouseCursorMonitor::CursorState state,
     const webrtc::DesktopVector& position) {
   NOTREACHED();
 }
 
 TEST_F(MouseCursorMonitorProxyTest, CursorShape) {
-  scoped_ptr<ThreadCheckMouseCursorMonitor> cursor_monitor(
+  std::unique_ptr<ThreadCheckMouseCursorMonitor> cursor_monitor(
       new ThreadCheckMouseCursorMonitor(capture_thread_.task_runner()));
 
   // Initialize the proxy.
   proxy_.reset(new MouseCursorMonitorProxy(capture_thread_.task_runner(),
                                            std::move(cursor_monitor)));
   proxy_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
   proxy_->Capture();
 
   // |run_loop_| will be stopped when the first cursor is received.
   run_loop_.Run();
 }
 
 }  // namespace remoting