Remove some uses of stl_util's STLDeleteContainerPointers.

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 <algorithm>
+
 #include "base/bind.h"
+#include "base/memory/ptr_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 95 matching lines @@
       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.
   sockets_.clear();
 
-  base::STLDeleteContainerPointers(dns_requests_.begin(), dns_requests_.end());
   dns_requests_.clear();
 
   if (monitoring_networks_) {
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
     monitoring_networks_ = false;
   }
 }
 
 void P2PSocketDispatcherHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
@@ skipping 83 matching lines @@
 
 void P2PSocketDispatcherHost::OnStopNetworkNotifications() {
   if (monitoring_networks_) {
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
     monitoring_networks_ = false;
   }
 }
 
 void P2PSocketDispatcherHost::OnGetHostAddress(const std::string& host_name,
                                                int32_t request_id) {
-  DnsRequest* request = new DnsRequest(request_id,
-                                       resource_context_->GetHostResolver());
-  dns_requests_.insert(request);
-  request->Resolve(host_name, base::Bind(
-      &P2PSocketDispatcherHost::OnAddressResolved,
-      base::Unretained(this), request));
+  std::unique_ptr<DnsRequest> request = base::MakeUnique<DnsRequest>(
+      request_id, resource_context_->GetHostResolver());
+  DnsRequest* request_ptr = request.get();
+  dns_requests_.insert(std::move(request));
+  request_ptr->Resolve(host_name,
+                       base::Bind(&P2PSocketDispatcherHost::OnAddressResolved,
+                                  base::Unretained(this), request_ptr));
 }
 
 void P2PSocketDispatcherHost::OnCreateSocket(
     P2PSocketType type,
     int socket_id,
     const net::IPEndPoint& local_address,
     const P2PPortRange& port_range,
     const P2PHostAndIPEndPoint& remote_address) {
   if (port_range.min_port > port_range.max_port ||
       (port_range.min_port == 0 && port_range.max_port != 0)) {
@@ skipping 141 matching lines @@
     return net::IPAddress();
 
   return local_address.address();
 }
 
 void P2PSocketDispatcherHost::OnAddressResolved(
     DnsRequest* request,
     const net::IPAddressList& addresses) {
   Send(new P2PMsg_GetHostAddressResult(request->request_id(), addresses));
 
-  dns_requests_.erase(request);
-  delete request;
+  dns_requests_.erase(
+      std::find_if(dns_requests_.begin(), dns_requests_.end(),
+                   [request](const std::unique_ptr<DnsRequest>& ptr) {
+                     return ptr.get() == request;
+                   }));
 }
 
 void P2PSocketDispatcherHost::StopRtpDumpOnIOThread(bool incoming,
                                                     bool outgoing) {
   if ((dump_incoming_rtp_packet_ && incoming) ||
       (dump_outgoing_rtp_packet_ && outgoing)) {
     if (incoming)
       dump_incoming_rtp_packet_ = false;
 
     if (outgoing)
       dump_outgoing_rtp_packet_ = false;
 
     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