Convert //remoting to use std::unique_ptr

remoting/host/client_session.h

 // Copyright (c) 2012 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.
 
 #ifndef REMOTING_HOST_CLIENT_SESSION_H_
 #define REMOTING_HOST_CLIENT_SESSION_H_
 
 #include <stdint.h>
 
 #include <string>
@@ skipping 69 matching lines @@
         const protocol::TransportRoute& route) = 0;
 
    protected:
     virtual ~EventHandler() {}
   };
 
   // |event_handler| and |desktop_environment_factory| must outlive |this|.
   // All |HostExtension|s in |extensions| must outlive |this|.
   ClientSession(EventHandler* event_handler,
                 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
-                scoped_ptr<protocol::ConnectionToClient> connection,
+                std::unique_ptr<protocol::ConnectionToClient> connection,
                 DesktopEnvironmentFactory* desktop_environment_factory,
                 const base::TimeDelta& max_duration,
                 scoped_refptr<protocol::PairingRegistry> pairing_registry,
                 const std::vector<HostExtension*>& extensions);
   ~ClientSession() override;
 
   // Returns the set of capabilities negotiated between client and host.
   const std::string& capabilities() const { return capabilities_; }
 
   // protocol::HostStub interface.
@@ skipping 30 matching lines @@
   protocol::ConnectionToClient* connection() const { return connection_.get(); }
 
   bool is_authenticated() { return is_authenticated_; }
 
   const std::string* client_capabilities() const {
     return client_capabilities_.get();
   }
 
  private:
   // Creates a proxy for sending clipboard events to the client.
-  scoped_ptr<protocol::ClipboardStub> CreateClipboardProxy();
+  std::unique_ptr<protocol::ClipboardStub> CreateClipboardProxy();
 
   void OnScreenSizeChanged(const webrtc::DesktopSize& size,
                            const webrtc::DesktopVector& dpi);
 
   EventHandler* event_handler_;
 
   // The connection to the client.
-  scoped_ptr<protocol::ConnectionToClient> connection_;
+  std::unique_ptr<protocol::ConnectionToClient> connection_;
 
   std::string client_jid_;
 
   // Used to create a DesktopEnvironment instance for this session.
   DesktopEnvironmentFactory* desktop_environment_factory_;
 
   // The DesktopEnvironment instance for this session.
-  scoped_ptr<DesktopEnvironment> desktop_environment_;
+  std::unique_ptr<DesktopEnvironment> desktop_environment_;
 
   // Filter used as the final element in the input pipeline.
   protocol::InputFilter host_input_filter_;
 
   // Tracker used to release pressed keys and buttons when disconnecting.
   protocol::InputEventTracker input_tracker_;
 
   // Filter used to disable remote inputs during local input activity.
   RemoteInputFilter remote_input_filter_;
 
@@ skipping 18 matching lines @@
   // There is no maximum if this value is <= 0.
   base::TimeDelta max_duration_;
 
   // A timer that triggers a disconnect when the maximum session duration
   // is reached.
   base::OneShotTimer max_duration_timer_;
 
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
 
   // Objects responsible for sending video, audio and mouse shape.
-  scoped_ptr<AudioPump> audio_pump_;
-  scoped_ptr<protocol::VideoStream> video_stream_;
-  scoped_ptr<MouseShapePump> mouse_shape_pump_;
+  std::unique_ptr<AudioPump> audio_pump_;
+  std::unique_ptr<protocol::VideoStream> video_stream_;
+  std::unique_ptr<MouseShapePump> mouse_shape_pump_;
 
   // The set of all capabilities supported by the client.
-  scoped_ptr<std::string> client_capabilities_;
+  std::unique_ptr<std::string> client_capabilities_;
 
   // The set of all capabilities supported by the host.
   std::string host_capabilities_;
 
   // The set of all capabilities negotiated between client and host.
   std::string capabilities_;
 
   // Used to inject mouse and keyboard input and handle clipboard events.
-  scoped_ptr<InputInjector> input_injector_;
+  std::unique_ptr<InputInjector> input_injector_;
 
   // Used to apply client-requested changes in screen resolution.
-  scoped_ptr<ScreenControls> screen_controls_;
+  std::unique_ptr<ScreenControls> screen_controls_;
 
   // The pairing registry for PIN-less authentication.
   scoped_refptr<protocol::PairingRegistry> pairing_registry_;
 
   // Used to manage extension functionality.
-  scoped_ptr<HostExtensionSessionManager> extension_manager_;
+  std::unique_ptr<HostExtensionSessionManager> extension_manager_;
 
   // Set to true if the client was authenticated successfully.
   bool is_authenticated_;
 
   // Used to store video channel pause & lossless parameters.
   bool pause_video_;
   bool lossless_video_encode_;
   bool lossless_video_color_;
 
   // Used to disable callbacks to |this| once DisconnectSession() has been
   // called.
   base::WeakPtrFactory<ClientSessionControl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSession);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CLIENT_SESSION_H_