Convert //remoting to use std::unique_ptr

remoting/protocol/session_config.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_PROTOCOL_SESSION_CONFIG_H_
 #define REMOTING_PROTOCOL_SESSION_CONFIG_H_
 
 #include <list>
+#include <memory>
 #include <string>
 
-#include "base/memory/scoped_ptr.h"
 
 namespace remoting {
 namespace protocol {
 
 extern const int kDefaultStreamVersion;
 
 // Struct for configuration parameters of a single channel.
 // Some channels (like video) may have multiple underlying sockets that need
 // to be configured simultaneously.
 struct ChannelConfig {
@@ skipping 46 matching lines @@
     ICE,
 
     // New WebRTC-based protocol.
     WEBRTC,
   };
 
   // Selects session configuration that is supported by both participants.
   // nullptr is returned if such configuration doesn't exist. When selecting
   // channel configuration priority is given to the configs listed first
   // in |client_config|.
-  static scoped_ptr<SessionConfig> SelectCommon(
+  static std::unique_ptr<SessionConfig> SelectCommon(
       const CandidateSessionConfig* client_config,
       const CandidateSessionConfig* host_config);
 
   // Extracts final protocol configuration. Must be used for the description
   // received in the session-accept stanza. If the selection is ambiguous
   // (e.g. there is more than one configuration for one of the channel)
   // or undefined (e.g. no configurations for a channel) then nullptr is
   // returned.
-  static scoped_ptr<SessionConfig> GetFinalConfig(
+  static std::unique_ptr<SessionConfig> GetFinalConfig(
       const CandidateSessionConfig* candidate_config);
 
   // Returns a suitable session configuration for use in tests.
-  static scoped_ptr<SessionConfig> ForTest();
-  static scoped_ptr<SessionConfig> ForTestWithVerbatimVideo();
-  static scoped_ptr<SessionConfig> ForTestWithWebrtc();
+  static std::unique_ptr<SessionConfig> ForTest();
+  static std::unique_ptr<SessionConfig> ForTestWithVerbatimVideo();
+  static std::unique_ptr<SessionConfig> ForTestWithWebrtc();
 
   Protocol protocol() const { return protocol_; }
 
   // All fields below should be ignored when protocol() is set to WEBRTC.
   const ChannelConfig& control_config() const;
   const ChannelConfig& event_config() const;
   const ChannelConfig& video_config() const;
   const ChannelConfig& audio_config() const;
 
   bool is_audio_enabled() const {
     return audio_config_.transport != ChannelConfig::TRANSPORT_NONE;
   }
 
  private:
   SessionConfig(Protocol protocol);
 
   const Protocol protocol_;
 
   ChannelConfig control_config_;
   ChannelConfig event_config_;
   ChannelConfig video_config_;
   ChannelConfig audio_config_;
 };
 
 // Defines session description that is sent from client to the host in the
 // session-initiate message. It is different from the regular Config
 // because it allows one to specify multiple configurations for each channel.
 class CandidateSessionConfig {
  public:
-  static scoped_ptr<CandidateSessionConfig> CreateEmpty();
-  static scoped_ptr<CandidateSessionConfig> CreateFrom(
+  static std::unique_ptr<CandidateSessionConfig> CreateEmpty();
+  static std::unique_ptr<CandidateSessionConfig> CreateFrom(
       const SessionConfig& config);
-  static scoped_ptr<CandidateSessionConfig> CreateDefault();
+  static std::unique_ptr<CandidateSessionConfig> CreateDefault();
 
   ~CandidateSessionConfig();
 
   bool webrtc_supported() const { return webrtc_supported_; }
   void set_webrtc_supported(bool webrtc_supported) {
     webrtc_supported_ = webrtc_supported;
   }
 
   bool ice_supported() const { return ice_supported_; }
   void set_ice_supported(bool ice_supported) { ice_supported_ = ice_supported; }
@@ skipping 38 matching lines @@
   //
   // TODO(sergeyu): Remove this kludge as soon as VP9 is enabled by default.
   bool vp9_experiment_enabled() const { return vp9_experiment_enabled_; }
   void set_vp9_experiment_enabled(bool value) {
     vp9_experiment_enabled_ = value;
   }
 
   // Returns true if |config| is supported.
   bool IsSupported(const SessionConfig& config) const;
 
-  scoped_ptr<CandidateSessionConfig> Clone() const;
+  std::unique_ptr<CandidateSessionConfig> Clone() const;
 
   // Helpers for enabling/disabling specific features.
   void DisableAudioChannel();
   void PreferTransport(ChannelConfig::TransportType transport);
 
  private:
   CandidateSessionConfig();
   explicit CandidateSessionConfig(const CandidateSessionConfig& config);
   CandidateSessionConfig& operator=(const CandidateSessionConfig& b);
 
   bool webrtc_supported_ = false;
   bool ice_supported_ = false;
 
   std::list<ChannelConfig> control_configs_;
   std::list<ChannelConfig> event_configs_;
   std::list<ChannelConfig> video_configs_;
   std::list<ChannelConfig> audio_configs_;
 
   bool vp9_experiment_enabled_ = false;
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_SESSION_CONFIG_H_