Convert //remoting to use std::unique_ptr

remoting/host/host_window_proxy.cc

 // Copyright 2013 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/host_window_proxy.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/host/client_session_control.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 
 namespace remoting {
 
 // Runs an instance of |HostWindow| on the |ui_task_runner_| thread.
 class HostWindowProxy::Core
     : public base::RefCountedThreadSafe<Core>,
       public ClientSessionControl {
  public:
   Core(scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
        scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-       scoped_ptr<HostWindow> host_window);
+       std::unique_ptr<HostWindow> host_window);
 
   // Starts |host_window_| on the |ui_task_runner_| thread.
   void Start(const base::WeakPtr<ClientSessionControl>& client_session_control);
 
   // Destroys |host_window_| on the |ui_task_runner_| thread.
   void Stop();
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
   ~Core() override;
@@ skipping 15 matching lines @@
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
 
   // Stores the client's JID so it can be read on the |ui_task_runner_| thread.
   std::string client_jid_;
 
   // Used to notify the caller about the local user's actions on
   // the |caller_task_runner| thread.
   base::WeakPtr<ClientSessionControl> client_session_control_;
 
   // The wrapped |HostWindow| instance running on the |ui_task_runner_| thread.
-  scoped_ptr<HostWindow> host_window_;
+  std::unique_ptr<HostWindow> host_window_;
 
   // Used to create the control pointer passed to |host_window_|.
   base::WeakPtrFactory<ClientSessionControl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 HostWindowProxy::HostWindowProxy(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    scoped_ptr<HostWindow> host_window) {
+    std::unique_ptr<HostWindow> host_window) {
   DCHECK(caller_task_runner->BelongsToCurrentThread());
 
   // Detach |host_window| from the calling thread so that |Core| could run it on
   // the |ui_task_runner_| thread.
   host_window->DetachFromThread();
   core_ = new Core(caller_task_runner, ui_task_runner, std::move(host_window));
 }
 
 HostWindowProxy::~HostWindowProxy() {
   DCHECK(CalledOnValidThread());
 
   core_->Stop();
 }
 
 void HostWindowProxy::Start(
     const base::WeakPtr<ClientSessionControl>& client_session_control) {
   DCHECK(CalledOnValidThread());
 
   core_->Start(client_session_control);
 }
 
 HostWindowProxy::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    scoped_ptr<HostWindow> host_window)
+    std::unique_ptr<HostWindow> host_window)
     : caller_task_runner_(caller_task_runner),
       ui_task_runner_(ui_task_runner),
       host_window_(std::move(host_window)),
       weak_factory_(this) {
   DCHECK(caller_task_runner->BelongsToCurrentThread());
 }
 
 void HostWindowProxy::Core::Start(
     const base::WeakPtr<ClientSessionControl>& client_session_control) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ skipping 64 matching lines @@
     caller_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::SetDisableInputs, this, disable_inputs));
     return;
   }
 
   if (client_session_control_.get())
     client_session_control_->SetDisableInputs(disable_inputs);
 }
 
 }  // namespace remoting