Remove use of stl_util's STLDeleteContainerPairSecondPointers from content/.

content/browser/renderer_host/p2p/socket_host_tcp_server.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 "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/common/p2p_messages.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 namespace {
 const int kListenBacklog = 5;
 }  // namespace
 
 namespace content {
 
 P2PSocketHostTcpServer::P2PSocketHostTcpServer(IPC::Sender* message_sender,
                                                int socket_id,
                                                P2PSocketType client_type)
     : P2PSocketHost(message_sender, socket_id, P2PSocketHost::TCP),
       client_type_(client_type),
-      socket_(new net::TCPServerSocket(NULL, net::NetLog::Source())),
+      socket_(new net::TCPServerSocket(nullptr, net::NetLog::Source())),
       accept_callback_(base::Bind(&P2PSocketHostTcpServer::OnAccepted,
                                   base::Unretained(this))) {
 }
 
 P2PSocketHostTcpServer::~P2PSocketHostTcpServer() {
-  base::STLDeleteContainerPairSecondPointers(accepted_sockets_.begin(),
-                                             accepted_sockets_.end());
-
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
 // TODO(guidou): Add support for port range.
 bool P2PSocketHostTcpServer::Init(const net::IPEndPoint& local_address,
                                   uint16_t min_port,
                                   uint16_t max_port,
@@ skipping 51 matching lines @@
       OnError();
     return;
   }
 
   net::IPEndPoint address;
   if (accept_socket_->GetPeerAddress(&address) != net::OK) {
     LOG(ERROR) << "Failed to get address of an accepted socket.";
     accept_socket_.reset();
     return;
   }
-  AcceptedSocketsMap::iterator it = accepted_sockets_.find(address);
-  if (it != accepted_sockets_.end())
-    delete it->second;
-
-  accepted_sockets_[address] = accept_socket_.release();
+  accepted_sockets_[address] = std::move(accept_socket_);
   message_sender_->Send(
       new P2PMsg_OnIncomingTcpConnection(id_, address));
 }
 
 void P2PSocketHostTcpServer::OnAccepted(int result) {
   HandleAcceptResult(result);
   if (result == net::OK)
     DoAccept();
 }
 
 void P2PSocketHostTcpServer::Send(const net::IPEndPoint& to,
                                   const std::vector<char>& data,
                                   const rtc::PacketOptions& options,
                                   uint64_t packet_id) {
   NOTREACHED();
   OnError();
 }
 
-P2PSocketHost* P2PSocketHostTcpServer::AcceptIncomingTcpConnection(
-    const net::IPEndPoint& remote_address, int id) {
-  AcceptedSocketsMap::iterator it = accepted_sockets_.find(remote_address);
+std::unique_ptr<P2PSocketHost>
+P2PSocketHostTcpServer::AcceptIncomingTcpConnection(
+    const net::IPEndPoint& remote_address,
+    int id) {
+  auto it = accepted_sockets_.find(remote_address);
   if (it == accepted_sockets_.end())
-    return NULL;
+    return nullptr;
 
-  net::StreamSocket* socket = it->second;
+  std::unique_ptr<net::StreamSocket> socket = std::move(it->second);
   accepted_sockets_.erase(it);
 
   std::unique_ptr<P2PSocketHostTcpBase> result;
   if (client_type_ == P2P_SOCKET_TCP_CLIENT) {
-    result.reset(new P2PSocketHostTcp(message_sender_, id, client_type_, NULL));
+    result.reset(
+        new P2PSocketHostTcp(message_sender_, id, client_type_, nullptr));
   } else {
     result.reset(
-        new P2PSocketHostStunTcp(message_sender_, id, client_type_, NULL));
+        new P2PSocketHostStunTcp(message_sender_, id, client_type_, nullptr));
   }
-  if (!result->InitAccepted(remote_address, socket))
-    return NULL;
-  return result.release();
+  if (!result->InitAccepted(remote_address, std::move(socket)))
+    return nullptr;
+  return std::move(result);
 }
 
 bool P2PSocketHostTcpServer::SetOption(P2PSocketOption option,
                                        int value) {
   // Currently we don't have use case tcp server sockets are used for p2p.
   return false;
 }
 
 }  // namespace content