Remove stl_util's deletion functions from net/dns/.

net/dns/dns_socket_pool.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 "net/dns/dns_socket_pool.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
-#include "base/stl_util.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log_source.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/stream_socket.h"
 #include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
@@ skipping 118 matching lines @@
 
   std::unique_ptr<DatagramClientSocket> AllocateSocket(
       unsigned server_index) override;
 
   void FreeSocket(unsigned server_index,
                   std::unique_ptr<DatagramClientSocket> socket) override;
 
  private:
   void FillPool(unsigned server_index, unsigned size);
 
-  typedef std::vector<DatagramClientSocket*> SocketVector;
+  typedef std::vector<std::unique_ptr<DatagramClientSocket>> SocketVector;
 
   std::vector<SocketVector> pools_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultDnsSocketPool);
 };
 
 // static
 std::unique_ptr<DnsSocketPool> DnsSocketPool::CreateDefault(
     ClientSocketFactory* factory,
     const RandIntCallback& rand_int_callback) {
   return std::unique_ptr<DnsSocketPool>(
       new DefaultDnsSocketPool(factory, rand_int_callback));
 }
 
 void DefaultDnsSocketPool::Initialize(
     const std::vector<IPEndPoint>* nameservers,
     NetLog* net_log) {
   InitializeInternal(nameservers, net_log);
 
   DCHECK(pools_.empty());
   const unsigned num_servers = nameservers->size();
   pools_.resize(num_servers);
   for (unsigned server_index = 0; server_index < num_servers; ++server_index)
     FillPool(server_index, kInitialPoolSize);
 }
 
 DefaultDnsSocketPool::~DefaultDnsSocketPool() {
-  unsigned num_servers = pools_.size();
-  for (unsigned server_index = 0; server_index < num_servers; ++server_index) {
-    SocketVector& pool = pools_[server_index];
-    base::STLDeleteElements(&pool);
-  }
 }
 
 std::unique_ptr<DatagramClientSocket> DefaultDnsSocketPool::AllocateSocket(
     unsigned server_index) {
   DCHECK_LT(server_index, pools_.size());
   SocketVector& pool = pools_[server_index];
 
   FillPool(server_index, kAllocateMinSize);
   if (pool.size() == 0) {
     DVLOG(1) << "No DNS sockets available in pool " << server_index << "!";
     return std::unique_ptr<DatagramClientSocket>();
   }
 
   if (pool.size() < kAllocateMinSize) {
     DVLOG(1) << "Low DNS port entropy: wanted " << kAllocateMinSize
              << " sockets to choose from, but only have " << pool.size()
              << " in pool " << server_index << ".";
   }
 
   unsigned socket_index = GetRandomInt(0, pool.size() - 1);
-  DatagramClientSocket* socket = pool[socket_index];
-  pool[socket_index] = pool.back();
+  std::unique_ptr<DatagramClientSocket> socket = std::move(pool[socket_index]);
+  pool[socket_index] = std::move(pool.back());
   pool.pop_back();
 
-  return std::unique_ptr<DatagramClientSocket>(socket);
+  return socket;
 }
 
 void DefaultDnsSocketPool::FreeSocket(
     unsigned server_index,
     std::unique_ptr<DatagramClientSocket> socket) {
   DCHECK_LT(server_index, pools_.size());
 }
 
 void DefaultDnsSocketPool::FillPool(unsigned server_index, unsigned size) {
   SocketVector& pool = pools_[server_index];
 
   for (unsigned pool_index = pool.size(); pool_index < size; ++pool_index) {
-    DatagramClientSocket* socket =
-        CreateConnectedSocket(server_index).release();
+    std::unique_ptr<DatagramClientSocket> socket =
+        CreateConnectedSocket(server_index);
     if (!socket)
       break;
-    pool.push_back(socket);
+    pool.push_back(std::move(socket));
   }
 }
 
 } // namespace net