Convert //remoting to use std::unique_ptr

remoting/protocol/channel_multiplexer.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/channel_multiplexer.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 12 matching lines @@
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 const int kChannelIdUnknown = -1;
 const int kMaxPacketSize = 1024;
 
 class PendingPacket {
  public:
-  PendingPacket(scoped_ptr<MultiplexPacket> packet)
+  PendingPacket(std::unique_ptr<MultiplexPacket> packet)
       : packet(std::move(packet)) {}
   ~PendingPacket() {}
 
   bool is_empty() { return pos >= packet->data().size(); }
 
   int Read(char* buffer, size_t size) {
     size = std::min(size, packet->data().size() - pos);
     memcpy(buffer, packet->data().data() + pos, size);
     pos += size;
     return size;
   }
 
  private:
-  scoped_ptr<MultiplexPacket> packet;
+  std::unique_ptr<MultiplexPacket> packet;
   size_t pos = 0U;
 
   DISALLOW_COPY_AND_ASSIGN(PendingPacket);
 };
 
 }  // namespace
 
 const char ChannelMultiplexer::kMuxChannelName[] = "mux";
 
 struct ChannelMultiplexer::PendingChannel {
   PendingChannel(const std::string& name,
                  const ChannelCreatedCallback& callback)
       : name(name), callback(callback) {
   }
   std::string name;
   ChannelCreatedCallback callback;
 };
 
 class ChannelMultiplexer::MuxChannel {
  public:
   MuxChannel(ChannelMultiplexer* multiplexer, const std::string& name,
              int send_id);
   ~MuxChannel();
 
   const std::string& name() { return name_; }
   int receive_id() { return receive_id_; }
   void set_receive_id(int id) { receive_id_ = id; }
 
   // Called by ChannelMultiplexer.
-  scoped_ptr<P2PStreamSocket> CreateSocket();
-  void OnIncomingPacket(scoped_ptr<MultiplexPacket> packet);
+  std::unique_ptr<P2PStreamSocket> CreateSocket();
+  void OnIncomingPacket(std::unique_ptr<MultiplexPacket> packet);
   void OnBaseChannelError(int error);
 
   // Called by MuxSocket.
   void OnSocketDestroyed();
-  void DoWrite(scoped_ptr<MultiplexPacket> packet,
+  void DoWrite(std::unique_ptr<MultiplexPacket> packet,
                const base::Closure& done_task);
   int DoRead(const scoped_refptr<net::IOBuffer>& buffer, int buffer_len);
 
  private:
   ChannelMultiplexer* multiplexer_;
   std::string name_;
   int send_id_;
   bool id_sent_;
   int receive_id_;
   MuxSocket* socket_;
@@ skipping 47 matching lines @@
       receive_id_(kChannelIdUnknown),
       socket_(nullptr) {
 }
 
 ChannelMultiplexer::MuxChannel::~MuxChannel() {
   // Socket must be destroyed before the channel.
   DCHECK(!socket_);
   STLDeleteElements(&pending_packets_);
 }
 
-scoped_ptr<P2PStreamSocket> ChannelMultiplexer::MuxChannel::CreateSocket() {
+std::unique_ptr<P2PStreamSocket>
+ChannelMultiplexer::MuxChannel::CreateSocket() {
   DCHECK(!socket_);  // Can't create more than one socket per channel.
-  scoped_ptr<MuxSocket> result(new MuxSocket(this));
+  std::unique_ptr<MuxSocket> result(new MuxSocket(this));
   socket_ = result.get();
   return std::move(result);
 }
 
 void ChannelMultiplexer::MuxChannel::OnIncomingPacket(
-    scoped_ptr<MultiplexPacket> packet) {
+    std::unique_ptr<MultiplexPacket> packet) {
   DCHECK_EQ(packet->channel_id(), receive_id_);
   if (packet->data().size() > 0) {
     pending_packets_.push_back(new PendingPacket(std::move(packet)));
     if (socket_) {
       // Notify the socket that we have more data.
       socket_->OnPacketReceived();
     }
   }
 }
 
 void ChannelMultiplexer::MuxChannel::OnBaseChannelError(int error) {
   if (socket_)
     socket_->OnBaseChannelError(error);
 }
 
 void ChannelMultiplexer::MuxChannel::OnSocketDestroyed() {
   DCHECK(socket_);
   socket_ = nullptr;
 }
 
 void ChannelMultiplexer::MuxChannel::DoWrite(
-    scoped_ptr<MultiplexPacket> packet,
+    std::unique_ptr<MultiplexPacket> packet,
     const base::Closure& done_task) {
   packet->set_channel_id(send_id_);
   if (!id_sent_) {
     packet->set_channel_name(name_);
     id_sent_ = true;
   }
   multiplexer_->DoWrite(std::move(packet), done_task);
 }
 
 int ChannelMultiplexer::MuxChannel::DoRead(
@@ skipping 47 matching lines @@
 
 int ChannelMultiplexer::MuxSocket::Write(
     const scoped_refptr<net::IOBuffer>& buffer, int buffer_len,
     const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(write_callback_.is_null());
 
   if (base_channel_error_ != net::OK)
     return base_channel_error_;
 
-  scoped_ptr<MultiplexPacket> packet(new MultiplexPacket());
+  std::unique_ptr<MultiplexPacket> packet(new MultiplexPacket());
   size_t size = std::min(kMaxPacketSize, buffer_len);
   packet->mutable_data()->assign(buffer->data(), size);
 
   write_pending_ = true;
   channel_->DoWrite(std::move(packet), base::Bind(
       &ChannelMultiplexer::MuxSocket::OnWriteComplete, AsWeakPtr()));
 
   // OnWriteComplete() might be called above synchronously.
   if (write_pending_) {
     DCHECK(write_callback_.is_null());
@@ skipping 83 matching lines @@
   for (std::list<PendingChannel>::iterator it = pending_channels_.begin();
        it != pending_channels_.end(); ++it) {
     if (it->name == name) {
       pending_channels_.erase(it);
       return;
     }
   }
 }
 
 void ChannelMultiplexer::OnBaseChannelReady(
-    scoped_ptr<P2PStreamSocket> socket) {
+    std::unique_ptr<P2PStreamSocket> socket) {
   base_channel_factory_ = nullptr;
   base_channel_ = std::move(socket);
 
   if (base_channel_.get()) {
     // Initialize reader and writer.
     reader_.StartReading(base_channel_.get(),
                          base::Bind(&ChannelMultiplexer::OnIncomingPacket,
                                     base::Unretained(this)),
                          base::Bind(&ChannelMultiplexer::OnBaseChannelError,
                                     base::Unretained(this)));
@@ skipping 13 matching lines @@
   // Every time this function is called it connects a single channel and posts a
   // separate task to connect other channels. This is necessary because the
   // callback may destroy the multiplexer or somehow else modify
   // |pending_channels_| list (e.g. call CancelChannelCreation()).
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ChannelMultiplexer::DoCreatePendingChannels,
                             weak_factory_.GetWeakPtr()));
 
   PendingChannel c = pending_channels_.front();
   pending_channels_.erase(pending_channels_.begin());
-  scoped_ptr<P2PStreamSocket> socket;
+  std::unique_ptr<P2PStreamSocket> socket;
   if (base_channel_.get())
     socket = GetOrCreateChannel(c.name)->CreateSocket();
   c.callback.Run(std::move(socket));
 }
 
 ChannelMultiplexer::MuxChannel* ChannelMultiplexer::GetOrCreateChannel(
     const std::string& name) {
   // Check if we already have a channel with the requested name.
   std::map<std::string, MuxChannel*>::iterator it = channels_.find(name);
   if (it != channels_.end())
@@ skipping 17 matching lines @@
   }
 }
 
 void ChannelMultiplexer::NotifyBaseChannelError(const std::string& name,
                                                 int error) {
   std::map<std::string, MuxChannel*>::iterator it = channels_.find(name);
   if (it != channels_.end())
     it->second->OnBaseChannelError(error);
 }
 
-void ChannelMultiplexer::OnIncomingPacket(scoped_ptr<CompoundBuffer> buffer) {
-  scoped_ptr<MultiplexPacket> packet =
+void ChannelMultiplexer::OnIncomingPacket(
+    std::unique_ptr<CompoundBuffer> buffer) {
+  std::unique_ptr<MultiplexPacket> packet =
       ParseMessage<MultiplexPacket>(buffer.get());
   if (!packet)
     return;
 
   DCHECK(packet->has_channel_id());
   if (!packet->has_channel_id()) {
     LOG(ERROR) << "Received packet without channel_id.";
     return;
   }
 
@@ skipping 11 matching lines @@
       return;
     }
     channel = GetOrCreateChannel(packet->channel_name());
     channel->set_receive_id(receive_id);
     channels_by_receive_id_[receive_id] = channel;
   }
 
   channel->OnIncomingPacket(std::move(packet));
 }
 
-void ChannelMultiplexer::DoWrite(scoped_ptr<MultiplexPacket> packet,
+void ChannelMultiplexer::DoWrite(std::unique_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting