Remove use of stl_util's STLDeleteContainerPairSecondPointers from content/.

content/browser/renderer_host/p2p/socket_dispatcher_host.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_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
-#include "base/stl_util.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/renderer_host/p2p/socket_host.h"
 #include "content/common/p2p_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_context.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/sys_addrinfo.h"
@@ skipping 93 matching lines @@
     : BrowserMessageFilter(P2PMsgStart),
       resource_context_(resource_context),
       url_context_(url_context),
       monitoring_networks_(false),
       dump_incoming_rtp_packet_(false),
       dump_outgoing_rtp_packet_(false) {
 }
 
 void P2PSocketDispatcherHost::OnChannelClosing() {
   // Since the IPC sender is gone, close pending connections.
-  base::STLDeleteContainerPairSecondPointers(sockets_.begin(), sockets_.end());
   sockets_.clear();
 
   base::STLDeleteContainerPointers(dns_requests_.begin(), dns_requests_.end());
   dns_requests_.clear();
 
   if (monitoring_networks_) {
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
     monitoring_networks_ = false;
   }
 }
@@ skipping 63 matching lines @@
 P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
   DCHECK(sockets_.empty());
   DCHECK(dns_requests_.empty());
 
   if (monitoring_networks_)
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 P2PSocketHost* P2PSocketDispatcherHost::LookupSocket(int socket_id) {
   SocketsMap::iterator it = sockets_.find(socket_id);
-  return (it == sockets_.end()) ? NULL : it->second;
+  return (it == sockets_.end()) ? nullptr : it->second.get();
 }
 
 void P2PSocketDispatcherHost::OnStartNetworkNotifications() {
   if (!monitoring_networks_) {
     net::NetworkChangeNotifier::AddIPAddressObserver(this);
     monitoring_networks_ = true;
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE, base::Bind(
@@ skipping 38 matching lines @@
   std::unique_ptr<P2PSocketHost> socket(P2PSocketHost::Create(
       this, socket_id, type, url_context_.get(), &throttler_));
 
   if (!socket) {
     Send(new P2PMsg_OnError(socket_id));
     return;
   }
 
   if (socket->Init(local_address, port_range.min_port, port_range.max_port,
                    remote_address)) {
-    sockets_[socket_id] = socket.release();
+    sockets_[socket_id] = std::move(socket);
 
     if (dump_incoming_rtp_packet_ || dump_outgoing_rtp_packet_) {
       sockets_[socket_id]->StartRtpDump(dump_incoming_rtp_packet_,
                                         dump_outgoing_rtp_packet_,
                                         packet_callback_);
     }
   }
 }
 
 void P2PSocketDispatcherHost::OnAcceptIncomingTcpConnection(
     int listen_socket_id, const net::IPEndPoint& remote_address,
     int connected_socket_id) {
   P2PSocketHost* socket = LookupSocket(listen_socket_id);
   if (!socket) {
     LOG(ERROR) << "Received P2PHostMsg_AcceptIncomingTcpConnection "
         "for invalid listen_socket_id.";
     return;
   }
-  if (LookupSocket(connected_socket_id) != NULL) {
+  if (LookupSocket(connected_socket_id) != nullptr) {
     LOG(ERROR) << "Received P2PHostMsg_AcceptIncomingTcpConnection "
         "for duplicated connected_socket_id.";
     return;
   }
 
-  P2PSocketHost* accepted_connection =
-      socket->AcceptIncomingTcpConnection(remote_address, connected_socket_id);
+  std::unique_ptr<P2PSocketHost> accepted_connection(
+      socket->AcceptIncomingTcpConnection(remote_address, connected_socket_id));
   if (accepted_connection) {
-    sockets_[connected_socket_id] = accepted_connection;
+    sockets_[connected_socket_id] = std::move(accepted_connection);
   }
 }
 
 void P2PSocketDispatcherHost::OnSend(int socket_id,
                                      const net::IPEndPoint& socket_address,
                                      const std::vector<char>& data,
                                      const rtc::PacketOptions& options,
                                      uint64_t packet_id) {
   P2PSocketHost* socket = LookupSocket(socket_id);
   if (!socket) {
     LOG(ERROR) << "Received P2PHostMsg_Send for invalid socket_id.";
     return;
   }
 
   if (data.size() > kMaximumPacketSize) {
     LOG(ERROR) << "Received P2PHostMsg_Send with a packet that is too big: "
                << data.size();
     Send(new P2PMsg_OnError(socket_id));
-    delete socket;
-    sockets_.erase(socket_id);
+    sockets_.erase(socket_id);  // deletes the socket
     return;
   }
 
   socket->Send(socket_address, data, options, packet_id);
 }
 
 void P2PSocketDispatcherHost::OnSetOption(int socket_id,
                                           P2PSocketOption option,
                                           int value) {
   P2PSocketHost* socket = LookupSocket(socket_id);
   if (!socket) {
     LOG(ERROR) << "Received P2PHostMsg_SetOption for invalid socket_id.";
     return;
   }
 
   socket->SetOption(option, value);
 }
 
 void P2PSocketDispatcherHost::OnDestroySocket(int socket_id) {
   SocketsMap::iterator it = sockets_.find(socket_id);
   if (it != sockets_.end()) {
-    delete it->second;
-    sockets_.erase(it);
+    sockets_.erase(it);  // deletes the socket
   } else {
     LOG(ERROR) << "Received P2PHostMsg_DestroySocket for invalid socket_id.";
   }
 }
 
 void P2PSocketDispatcherHost::DoGetNetworkList() {
   net::NetworkInterfaceList list;
   if (!net::GetNetworkList(&list, net::EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES)) {
     LOG(ERROR) << "GetNetworkList failed.";
     return;
@@ skipping 15 matching lines @@
 }
 
 net::IPAddress P2PSocketDispatcherHost::GetDefaultLocalAddress(int family) {
   DCHECK(family == AF_INET || family == AF_INET6);
 
   // Creation and connection of a UDP socket might be janky.
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::unique_ptr<net::DatagramClientSocket> socket(
       net::ClientSocketFactory::GetDefaultFactory()->CreateDatagramClientSocket(
-          net::DatagramSocket::DEFAULT_BIND, net::RandIntCallback(), NULL,
+          net::DatagramSocket::DEFAULT_BIND, net::RandIntCallback(), nullptr,
           net::NetLog::Source()));
 
   net::IPAddress ip_address;
   if (family == AF_INET) {
     ip_address = net::IPAddress(kPublicIPv4Host);
   } else {
     ip_address = net::IPAddress(kPublicIPv6Host);
   }
 
   if (socket->Connect(net::IPEndPoint(ip_address, kPublicPort)) != net::OK) {
@@ skipping 28 matching lines @@
 
     if (!dump_incoming_rtp_packet_ && !dump_outgoing_rtp_packet_)
       packet_callback_.Reset();
 
     for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
       it->second->StopRtpDump(incoming, outgoing);
   }
 }
 
 }  // namespace content