Convert //remoting to use std::unique_ptr

remoting/protocol/webrtc_data_stream_adapter.cc

 // Copyright 2015 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/webrtc_data_stream_adapter.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "remoting/base/compound_buffer.h"
 #include "remoting/protocol/message_pipe.h"
 #include "remoting/protocol/message_serialization.h"
 
 namespace remoting {
 namespace protocol {
 
 class WebrtcDataStreamAdapter::Channel : public MessagePipe,
@@ skipping 113 matching lines @@
   state_ = State::CLOSED;
 
   // Notify the adapter about the error asychronously.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WebrtcDataStreamAdapter::OnChannelError, adapter_));
 }
 
 void WebrtcDataStreamAdapter::Channel::OnMessage(
     const webrtc::DataBuffer& rtc_buffer) {
-  scoped_ptr<CompoundBuffer> buffer(new CompoundBuffer());
+  std::unique_ptr<CompoundBuffer> buffer(new CompoundBuffer());
   buffer->AppendCopyOf(reinterpret_cast<const char*>(rtc_buffer.data.data()),
                        rtc_buffer.data.size());
   buffer->Lock();
   message_received_callback_.Run(std::move(buffer));
 }
 
 struct WebrtcDataStreamAdapter::PendingChannel {
   PendingChannel() {}
-  PendingChannel(scoped_ptr<Channel> channel,
+  PendingChannel(std::unique_ptr<Channel> channel,
                  const ChannelCreatedCallback& connected_callback)
       : channel(std::move(channel)), connected_callback(connected_callback) {}
   PendingChannel(PendingChannel&& other)
       : channel(std::move(other.channel)),
         connected_callback(std::move(other.connected_callback)) {}
   PendingChannel& operator=(PendingChannel&& other) {
     channel = std::move(other.channel);
     connected_callback = std::move(other.connected_callback);
     return *this;
   }
 
-  scoped_ptr<Channel> channel;
+  std::unique_ptr<Channel> channel;
   ChannelCreatedCallback connected_callback;
 };
 
 WebrtcDataStreamAdapter::WebrtcDataStreamAdapter(
     bool outgoing,
     const ErrorCallback& error_callback)
     : outgoing_(outgoing),
       error_callback_(error_callback),
       weak_factory_(this) {}
 
@@ skipping 18 matching lines @@
   it->second.channel->Start(data_channel);
 }
 
 void WebrtcDataStreamAdapter::CreateChannel(
     const std::string& name,
     const ChannelCreatedCallback& callback) {
   DCHECK(peer_connection_);
   DCHECK(pending_channels_.find(name) == pending_channels_.end());
 
   Channel* channel = new Channel(weak_factory_.GetWeakPtr());
-  pending_channels_[name] = PendingChannel(make_scoped_ptr(channel), callback);
+  pending_channels_[name] = PendingChannel(base::WrapUnique(channel), callback);
 
   if (outgoing_) {
     webrtc::DataChannelInit config;
     config.reliable = true;
     channel->Start(peer_connection_->CreateDataChannel(name, &config));
   }
 }
 
 void WebrtcDataStreamAdapter::CancelChannelCreation(const std::string& name) {
   auto it = pending_channels_.find(name);
@@ skipping 11 matching lines @@
   // |connected_callback|.
   pending_channel.connected_callback.Run(std::move(pending_channel.channel));
 }
 
 void WebrtcDataStreamAdapter::OnChannelError() {
   error_callback_.Run(CHANNEL_CONNECTION_ERROR);
 }
 
 }  // namespace protocol
 }  // namespace remoting