Convert //remoting to use std::unique_ptr

remoting/protocol/session_config.cc

 // 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.
 
 #include "remoting/protocol/session_config.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 bool IsChannelConfigSupported(const std::list<ChannelConfig>& list,
                               const ChannelConfig& value) {
   return std::find(list.begin(), list.end(), value) != list.end();
 }
@@ skipping 42 matching lines @@
 }
 
 bool ChannelConfig::operator==(const ChannelConfig& b) const {
   // If the transport field is set to NONE then all other fields are irrelevant.
   if (transport == ChannelConfig::TRANSPORT_NONE)
     return transport == b.transport;
   return transport == b.transport && version == b.version && codec == b.codec;
 }
 
 // static
-scoped_ptr<SessionConfig> SessionConfig::SelectCommon(
+std::unique_ptr<SessionConfig> SessionConfig::SelectCommon(
     const CandidateSessionConfig* client_config,
     const CandidateSessionConfig* host_config) {
-
   // Use WebRTC if both host and client support it.
   if (client_config->webrtc_supported() && host_config->webrtc_supported())
-    return make_scoped_ptr(new SessionConfig(Protocol::WEBRTC));
+    return base::WrapUnique(new SessionConfig(Protocol::WEBRTC));
 
   // Reject connection if ICE is not supported by either of the peers.
   if (!host_config->ice_supported() || !client_config->ice_supported())
     return nullptr;
 
-  scoped_ptr<SessionConfig> result(new SessionConfig(Protocol::ICE));
+  std::unique_ptr<SessionConfig> result(new SessionConfig(Protocol::ICE));
   ChannelConfig control_config;
   ChannelConfig event_config;
   ChannelConfig video_config;
   ChannelConfig audio_config;
 
   // If neither host nor the client have VP9 experiment enabled then remove it
   // from the list of host video configs.
   std::list<ChannelConfig> host_video_configs = host_config->video_configs();
   if (!client_config->vp9_experiment_enabled() &&
       !host_config->vp9_experiment_enabled()) {
@@ skipping 14 matching lines @@
       !SelectCommonChannelConfig(host_config->audio_configs(),
                                  client_config->audio_configs(),
                                  &result->audio_config_)) {
     return nullptr;
   }
 
   return result;
 }
 
 // static
-scoped_ptr<SessionConfig> SessionConfig::GetFinalConfig(
+std::unique_ptr<SessionConfig> SessionConfig::GetFinalConfig(
     const CandidateSessionConfig* candidate_config) {
   if (candidate_config->webrtc_supported()) {
     if (candidate_config->ice_supported()) {
       LOG(ERROR) << "Received candidate config is ambiguous.";
       return nullptr;
     }
-    return make_scoped_ptr(new SessionConfig(Protocol::WEBRTC));
+    return base::WrapUnique(new SessionConfig(Protocol::WEBRTC));
   }
 
   if (!candidate_config->ice_supported())
     return nullptr;
 
   if (candidate_config->control_configs().size() != 1 ||
       candidate_config->event_configs().size() != 1 ||
       candidate_config->video_configs().size() != 1 ||
       candidate_config->audio_configs().size() != 1) {
     return nullptr;
   }
 
-  scoped_ptr<SessionConfig> result(new SessionConfig(Protocol::ICE));
+  std::unique_ptr<SessionConfig> result(new SessionConfig(Protocol::ICE));
   result->control_config_ = candidate_config->control_configs().front();
   result->event_config_ = candidate_config->event_configs().front();
   result->video_config_ = candidate_config->video_configs().front();
   result->audio_config_ = candidate_config->audio_configs().front();
 
   return result;
 }
 
 // static
-scoped_ptr<SessionConfig> SessionConfig::ForTest() {
-  scoped_ptr<SessionConfig> result(new SessionConfig(Protocol::ICE));
+std::unique_ptr<SessionConfig> SessionConfig::ForTest() {
+  std::unique_ptr<SessionConfig> result(new SessionConfig(Protocol::ICE));
   result->control_config_ = ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                                           kControlStreamVersion,
                                           ChannelConfig::CODEC_UNDEFINED);
   result->event_config_ = ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_UNDEFINED);
   result->video_config_ = ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_VP8);
   result->audio_config_ = ChannelConfig(ChannelConfig::TRANSPORT_NONE,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_UNDEFINED);
   return result;
 }
 
-scoped_ptr<SessionConfig> SessionConfig::ForTestWithVerbatimVideo() {
-  scoped_ptr<SessionConfig> result = ForTest();
+std::unique_ptr<SessionConfig> SessionConfig::ForTestWithVerbatimVideo() {
+  std::unique_ptr<SessionConfig> result = ForTest();
   result->video_config_ = ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_VERBATIM);
   return result;
 }
 
-scoped_ptr<SessionConfig> SessionConfig::ForTestWithWebrtc() {
-  return make_scoped_ptr(new SessionConfig(Protocol::WEBRTC));
+std::unique_ptr<SessionConfig> SessionConfig::ForTestWithWebrtc() {
+  return base::WrapUnique(new SessionConfig(Protocol::WEBRTC));
 }
 
 const ChannelConfig& SessionConfig::control_config() const {
   DCHECK(protocol_ == Protocol::ICE);
   return control_config_;
 }
 const ChannelConfig& SessionConfig::event_config() const {
   DCHECK(protocol_ == Protocol::ICE);
   return event_config_;
 }
@@ skipping 24 matching lines @@
              IsChannelConfigSupported(audio_configs_, config.audio_config());
 
     case SessionConfig::Protocol::WEBRTC:
       return webrtc_supported();
   }
 
   NOTREACHED();
   return false;
 }
 
-scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::Clone() const {
-  return make_scoped_ptr(new CandidateSessionConfig(*this));
+std::unique_ptr<CandidateSessionConfig> CandidateSessionConfig::Clone() const {
+  return base::WrapUnique(new CandidateSessionConfig(*this));
 }
 
 // static
-scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateEmpty() {
-  return make_scoped_ptr(new CandidateSessionConfig());
+std::unique_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateEmpty() {
+  return base::WrapUnique(new CandidateSessionConfig());
 }
 
 // static
-scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateFrom(
+std::unique_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateFrom(
     const SessionConfig& config) {
-  scoped_ptr<CandidateSessionConfig> result = CreateEmpty();
+  std::unique_ptr<CandidateSessionConfig> result = CreateEmpty();
 
   switch (config.protocol()) {
     case SessionConfig::Protocol::WEBRTC:
       result->set_webrtc_supported(true);
       result->set_ice_supported(false);
       break;
 
     case SessionConfig::Protocol::ICE:
       result->set_webrtc_supported(false);
       result->set_ice_supported(true);
       result->mutable_control_configs()->push_back(config.control_config());
       result->mutable_event_configs()->push_back(config.event_config());
       result->mutable_video_configs()->push_back(config.video_config());
       result->mutable_audio_configs()->push_back(config.audio_config());
       break;
   }
 
   return result;
 }
 
 // static
-scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateDefault() {
-  scoped_ptr<CandidateSessionConfig> result = CreateEmpty();
+std::unique_ptr<CandidateSessionConfig>
+CandidateSessionConfig::CreateDefault() {
+  std::unique_ptr<CandidateSessionConfig> result = CreateEmpty();
 
   result->set_ice_supported(true);
 
   // Control channel.
   result->mutable_control_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                     kControlStreamVersion,
                     ChannelConfig::CODEC_UNDEFINED));
 
   // Event channel.
@@ skipping 30 matching lines @@
 void CandidateSessionConfig::PreferTransport(
     ChannelConfig::TransportType transport) {
   UpdateConfigListToPreferTransport(&control_configs_, transport);
   UpdateConfigListToPreferTransport(&event_configs_, transport);
   UpdateConfigListToPreferTransport(&video_configs_, transport);
   UpdateConfigListToPreferTransport(&audio_configs_, transport);
 }
 
 }  // namespace protocol
 }  // namespace remoting