Remove stl_util's deletion functions from remoting/.

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>
 
 #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/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 #include "remoting/protocol/message_serialization.h"
 #include "remoting/protocol/p2p_stream_socket.h"
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 const int kChannelIdUnknown = -1;
@@ skipping 55 matching lines @@
                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_;
-  std::list<PendingPacket*> pending_packets_;
+  std::list<std::unique_ptr<PendingPacket>> pending_packets_;
 
   DISALLOW_COPY_AND_ASSIGN(MuxChannel);
 };
 
 class ChannelMultiplexer::MuxSocket : public P2PStreamSocket,
                                       public base::NonThreadSafe,
                                       public base::SupportsWeakPtr<MuxSocket> {
  public:
   MuxSocket(MuxChannel* channel);
   ~MuxSocket() override;
@@ skipping 33 matching lines @@
       name_(name),
       send_id_(send_id),
       id_sent_(false),
       receive_id_(kChannelIdUnknown),
       socket_(nullptr) {
 }
 
 ChannelMultiplexer::MuxChannel::~MuxChannel() {
   // Socket must be destroyed before the channel.
   DCHECK(!socket_);
-  base::STLDeleteElements(&pending_packets_);
 }
 
 std::unique_ptr<P2PStreamSocket>
 ChannelMultiplexer::MuxChannel::CreateSocket() {
   DCHECK(!socket_);  // Can't create more than one socket per channel.
   std::unique_ptr<MuxSocket> result(new MuxSocket(this));
   socket_ = result.get();
   return std::move(result);
 }
 
 void ChannelMultiplexer::MuxChannel::OnIncomingPacket(
     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)));
+    pending_packets_.push_back(
+        base::MakeUnique<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);
@@ skipping 19 matching lines @@
     const scoped_refptr<net::IOBuffer>& buffer,
     int buffer_len) {
   int pos = 0;
   while (buffer_len > 0 && !pending_packets_.empty()) {
     DCHECK(!pending_packets_.front()->is_empty());
     int result = pending_packets_.front()->Read(
         buffer->data() + pos, buffer_len);
     DCHECK_LE(result, buffer_len);
     pos += result;
     buffer_len -= pos;
-    if (pending_packets_.front()->is_empty()) {
-      delete pending_packets_.front();
-      pending_packets_.erase(pending_packets_.begin());
-    }
+    if (pending_packets_.front()->is_empty())
+      pending_packets_.pop_front();
   }
   return pos;
 }
 
 ChannelMultiplexer::MuxSocket::MuxSocket(MuxChannel* channel)
     : channel_(channel),
       read_buffer_size_(0),
       write_pending_(false),
       write_result_(0) {
 }
@@ skipping 86 matching lines @@
 
 ChannelMultiplexer::ChannelMultiplexer(StreamChannelFactory* factory,
                                        const std::string& base_channel_name)
     : base_channel_factory_(factory),
       base_channel_name_(base_channel_name),
       next_channel_id_(0),
       weak_factory_(this) {}
 
 ChannelMultiplexer::~ChannelMultiplexer() {
   DCHECK(pending_channels_.empty());
-  base::STLDeleteValues(&channels_);
 
   // Cancel creation of the base channel if it hasn't finished.
   if (base_channel_factory_)
     base_channel_factory_->CancelChannelCreation(base_channel_name_);
 }
 
 void ChannelMultiplexer::CreateChannel(const std::string& name,
                                        const ChannelCreatedCallback& callback) {
   if (base_channel_.get()) {
     // Already have |base_channel_|. Create new multiplexed channel
@@ skipping 62 matching lines @@
   PendingChannel c = pending_channels_.front();
   pending_channels_.erase(pending_channels_.begin());
   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())
-    return it->second;
+  std::unique_ptr<MuxChannel>& channel = channels_[name];
+  if (!channel) {
+    // Create a new channel if we haven't found existing one.
+    channel = base::MakeUnique<MuxChannel>(this, name, next_channel_id_);
+    ++next_channel_id_;
+  }
 
-  // Create a new channel if we haven't found existing one.
-  MuxChannel* channel = new MuxChannel(this, name, next_channel_id_);
-  ++next_channel_id_;
-  channels_[channel->name()] = channel;
-  return channel;
+  return channel.get();
 }
 
 
 void ChannelMultiplexer::OnBaseChannelError(int error) {
-  for (std::map<std::string, MuxChannel*>::iterator it = channels_.begin();
-       it != channels_.end(); ++it) {
+  for (auto it = channels_.begin(); it != channels_.end(); ++it) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&ChannelMultiplexer::NotifyBaseChannelError,
                    weak_factory_.GetWeakPtr(), it->second->name(), error));
   }
 }
 
 void ChannelMultiplexer::NotifyBaseChannelError(const std::string& name,
                                                 int error) {
-  std::map<std::string, MuxChannel*>::iterator it = channels_.find(name);
+  auto it = channels_.find(name);
   if (it != channels_.end())
     it->second->OnBaseChannelError(error);
 }
 
 void ChannelMultiplexer::OnIncomingPacket(
     std::unique_ptr<CompoundBuffer> buffer) {
   std::unique_ptr<MultiplexPacket> packet =
       ParseMessage<MultiplexPacket>(buffer.get());
   if (!packet)
     return;
@@ skipping 25 matching lines @@
   channel->OnIncomingPacket(std::move(packet));
 }
 
 void ChannelMultiplexer::DoWrite(std::unique_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting