Convert //remoting to use std::unique_ptr

remoting/host/client_session.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/host/client_session.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/logging.h"
 #include "remoting/codec/audio_encoder.h"
 #include "remoting/codec/audio_encoder_opus.h"
 #include "remoting/codec/audio_encoder_verbatim.h"
 #include "remoting/host/audio_capturer.h"
@@ skipping 14 matching lines @@
 #include "remoting/protocol/video_frame_pump.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 
 namespace remoting {
 
 namespace {
 
 // Name of command-line flag to disable use of I444 by default.
 const char kDisableI444SwitchName[] = "disable-i444";
 
-scoped_ptr<AudioEncoder> CreateAudioEncoder(
+std::unique_ptr<AudioEncoder> CreateAudioEncoder(
     const protocol::SessionConfig& config) {
   const protocol::ChannelConfig& audio_config = config.audio_config();
 
   if (audio_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
-    return make_scoped_ptr(new AudioEncoderVerbatim());
+    return base::WrapUnique(new AudioEncoderVerbatim());
   } else if (audio_config.codec == protocol::ChannelConfig::CODEC_OPUS) {
-    return make_scoped_ptr(new AudioEncoderOpus());
+    return base::WrapUnique(new AudioEncoderOpus());
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace
 
 ClientSession::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)
     : event_handler_(event_handler),
       connection_(std::move(connection)),
       client_jid_(connection_->session()->jid()),
       desktop_environment_factory_(desktop_environment_factory),
       input_tracker_(&host_input_filter_),
       remote_input_filter_(&input_tracker_),
@@ skipping 105 matching lines @@
     const protocol::Capabilities& capabilities) {
   DCHECK(CalledOnValidThread());
 
   // Ignore all the messages but the 1st one.
   if (client_capabilities_) {
     LOG(WARNING) << "protocol::Capabilities has been received already.";
     return;
   }
 
   // Compute the set of capabilities supported by both client and host.
-  client_capabilities_ = make_scoped_ptr(new std::string());
+  client_capabilities_ = base::WrapUnique(new std::string());
   if (capabilities.has_capabilities())
     *client_capabilities_ = capabilities.capabilities();
   capabilities_ = IntersectCapabilities(*client_capabilities_,
                                         host_capabilities_);
   extension_manager_->OnNegotiatedCapabilities(
       connection_->client_stub(), capabilities_);
 
   VLOG(1) << "Client capabilities: " << *client_capabilities_;
 
   // Calculate the set of capabilities enabled by both client and host and
@@ skipping 123 matching lines @@
 
   // Apply video-control parameters to the new stream.
   video_stream_->SetLosslessEncode(lossless_video_encode_);
   video_stream_->SetLosslessColor(lossless_video_color_);
 
   // Pause capturing if necessary.
   video_stream_->Pause(pause_video_);
 
   // Create an AudioPump if audio is enabled, to pump audio samples.
   if (connection_->session()->config().is_audio_enabled()) {
-    scoped_ptr<AudioEncoder> audio_encoder =
+    std::unique_ptr<AudioEncoder> audio_encoder =
         CreateAudioEncoder(connection_->session()->config());
     audio_pump_.reset(new AudioPump(
         audio_task_runner_, desktop_environment_->CreateAudioCapturer(),
         std::move(audio_encoder), connection_->audio_stub()));
   }
 
   // Notify the event handler that all our channels are now connected.
   event_handler_->OnSessionChannelsConnected(this);
 }
 
@@ skipping 71 matching lines @@
 void ClientSession::SetDisableInputs(bool disable_inputs) {
   DCHECK(CalledOnValidThread());
 
   if (disable_inputs)
     input_tracker_.ReleaseAll();
 
   disable_input_filter_.set_enabled(!disable_inputs);
   disable_clipboard_filter_.set_enabled(!disable_inputs);
 }
 
-scoped_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
+std::unique_ptr<protocol::ClipboardStub> ClientSession::CreateClipboardProxy() {
   DCHECK(CalledOnValidThread());
 
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new protocol::ClipboardThreadProxy(client_clipboard_factory_.GetWeakPtr(),
                                          base::ThreadTaskRunnerHandle::Get()));
 }
 
 void ClientSession::OnScreenSizeChanged(const webrtc::DesktopSize& size,
                                         const webrtc::DesktopVector& dpi) {
   DCHECK(CalledOnValidThread());
 
   mouse_clamping_filter_.set_input_size(size);
   mouse_clamping_filter_.set_output_size(size);
 
   if (connection_->session()->config().protocol() ==
       protocol::SessionConfig::Protocol::WEBRTC) {
     protocol::VideoLayout layout;
     protocol::VideoTrackLayout* video_track = layout.add_video_track();
     video_track->set_position_x(0);
     video_track->set_position_y(0);
     video_track->set_width(size.width() * kDefaultDpi / dpi.x());
     video_track->set_height(size.height() * kDefaultDpi / dpi.y());
     video_track->set_x_dpi(dpi.x());
     video_track->set_y_dpi(dpi.y());
     connection_->client_stub()->SetVideoLayout(layout);
   }
 }
 
 }  // namespace remoting