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

BUG=555865

Review-Url: https://codereview.chromium.org/2389613002
Cr-Commit-Position: refs/heads/master@{#437655}

net/dns/dns_session_unittest.cc

@@ -9,8 +9,8 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
-#include "base/stl_util.h"
 #include "net/base/ip_address.h"
 #include "net/dns/dns_protocol.h"
 #include "net/dns/dns_socket_pool.h"
@@ -56,7 +56,7 @@ class TestClientSocketFactory : public ClientSocketFactory {
   void ClearSSLSessionCache() override { NOTIMPLEMENTED(); }
 
  private:
-  std::list<SocketDataProvider*> data_providers_;
+  std::list<std::unique_ptr<SocketDataProvider>> data_providers_;
 };
 
 struct PoolEvent {
@@ -187,14 +187,13 @@ TestClientSocketFactory::CreateDatagramClientSocket(
   // We're not actually expecting to send or receive any data, so use the
   // simplest SocketDataProvider with no data supplied.
   SocketDataProvider* data_provider = new StaticSocketDataProvider();
-  data_providers_.push_back(data_provider);
+  data_providers_.push_back(base::WrapUnique(data_provider));
   std::unique_ptr<MockUDPClientSocket> socket(
       new MockUDPClientSocket(data_provider, net_log));
   return std::move(socket);
 }
 
 TestClientSocketFactory::~TestClientSocketFactory() {
-  base::STLDeleteElements(&data_providers_);
 }
 
 TEST_F(DnsSessionTest, AllocateFree) {

net/dns/dns_socket_pool.cc

@@ -6,8 +6,8 @@
 
 #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"
@@ -146,7 +146,7 @@ class DefaultDnsSocketPool : public DnsSocketPool {
  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_;
 
@@ -176,11 +176,6 @@ void DefaultDnsSocketPool::Initialize(
 }
 
 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(
@@ -201,11 +196,11 @@ std::unique_ptr<DatagramClientSocket> DefaultDnsSocketPool::AllocateSocket(
   }
 
   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(
@@ -218,11 +213,11 @@ 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));
   }
 }
 

net/dns/host_resolver_impl.cc

@@ -30,7 +30,6 @@
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -1896,9 +1895,9 @@ HostResolverImpl::HostResolverImpl(const Options& options, NetLog* net_log)
 HostResolverImpl::~HostResolverImpl() {
   // Prevent the dispatcher from starting new jobs.
   dispatcher_->SetLimitsToZero();
-  // It's now safe for Jobs to call KillDsnTask on destruction, because
+  // It's now safe for Jobs to call KillDnsTask on destruction, because
   // OnJobComplete will not start any new jobs.
-  base::STLDeleteValues(&jobs_);
+  jobs_.clear();
 
   NetworkChangeNotifier::RemoveIPAddressObserver(this);
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
@@ -1949,7 +1948,7 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
   // Next we need to attach our request to a "job". This job is responsible for
   // calling "getaddrinfo(hostname)" on a worker thread.
 
-  JobMap::iterator jobit = jobs_.find(key);
+  auto jobit = jobs_.find(key);
   Job* job;
   if (jobit == jobs_.end()) {
     job = new Job(weak_ptr_factory_.GetWeakPtr(), key, priority,
@@ -1967,14 +1966,14 @@ int HostResolverImpl::Resolve(const RequestInfo& info,
         return rv;
       }
     }
-    jobs_.insert(jobit, std::make_pair(key, job));
+    jobs_[key] = base::WrapUnique(job);
   } else {
-    job = jobit->second;
+    job = jobit->second.get();
   }
 
   // Can't complete synchronously. Create and attach request.
-  std::unique_ptr<RequestImpl> req(new RequestImpl(
-      source_net_log, info, priority, callback, addresses, job));
+  auto req = base::MakeUnique<RequestImpl>(source_net_log, info, priority,
+                                           callback, addresses, job);
   job->AddRequest(req.get());
   *out_req = std::move(req);
 
@@ -2303,9 +2302,11 @@ void HostResolverImpl::CacheResult(const Key& key,
 
 void HostResolverImpl::RemoveJob(Job* job) {
   DCHECK(job);
-  JobMap::iterator it = jobs_.find(job->key());
-  if (it != jobs_.end() && it->second == job)
+  auto it = jobs_.find(job->key());
+  if (it != jobs_.end() && it->second.get() == job) {
+    it->second.release();
     jobs_.erase(it);
+  }
 }
 
 HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
@@ -2359,10 +2360,10 @@ void HostResolverImpl::AbortAllInProgressJobs() {
   // In Abort, a Request callback could spawn new Jobs with matching keys, so
   // first collect and remove all running jobs from |jobs_|.
   std::vector<std::unique_ptr<Job>> jobs_to_abort;
-  for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ) {
-    Job* job = it->second;
+  for (auto it = jobs_.begin(); it != jobs_.end();) {
+    Job* job = it->second.get();
     if (job->is_running()) {
-      jobs_to_abort.push_back(base::WrapUnique(job));
+      jobs_to_abort.push_back(std::move(it->second));
       jobs_.erase(it++);
     } else {
       DCHECK(job->is_queued());
@@ -2399,7 +2400,7 @@ void HostResolverImpl::AbortDnsTasks() {
   dispatcher_->SetLimits(
       PrioritizedDispatcher::Limits(limits.reserved_slots.size(), 0));
 
-  for (JobMap::iterator it = jobs_.begin(); it != jobs_.end(); ++it)
+  for (auto it = jobs_.begin(); it != jobs_.end(); ++it)
     it->second->AbortDnsTask();
   dispatcher_->SetLimits(limits);
 }
@@ -2414,8 +2415,8 @@ void HostResolverImpl::TryServingAllJobsFromHosts() {
   // Life check to bail once |this| is deleted.
   base::WeakPtr<HostResolverImpl> self = weak_ptr_factory_.GetWeakPtr();
 
-  for (JobMap::iterator it = jobs_.begin(); self.get() && it != jobs_.end();) {
-    Job* job = it->second;
+  for (auto it = jobs_.begin(); self.get() && it != jobs_.end();) {
+    Job* job = it->second.get();
     ++it;
     // This could remove |job| from |jobs_|, but iterator will remain valid.
     job->ServeFromHosts();

net/dns/host_resolver_impl.h

@@ -179,8 +179,8 @@ class NET_EXPORT HostResolverImpl
   class LoopbackProbeJob;
   class DnsTask;
   class RequestImpl;
-  typedef HostCache::Key Key;
-  typedef std::map<Key, Job*> JobMap;
+  using Key = HostCache::Key;
+  using JobMap = std::map<Key, std::unique_ptr<Job>>;
 
   // Number of consecutive failures of DnsTask (with successful fallback to
   // ProcTask) before the DnsClient is disabled until the next DNS change.
@@ -263,7 +263,7 @@ class NET_EXPORT HostResolverImpl
                    const HostCache::Entry& entry,
                    base::TimeDelta ttl);
 
-  // Removes |job| from |jobs_|, only if it exists.
+  // Removes |job| from |jobs_|, only if it exists, but does not delete it.
   void RemoveJob(Job* job);
 
   // Aborts all in progress jobs with ERR_NETWORK_CHANGED and notifies their

net/dns/mdns_client_impl.cc

@@ -12,7 +12,6 @@
 #include "base/location.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 "base/time/clock.h"
 #include "base/time/default_clock.h"
@@ -208,7 +207,6 @@ MDnsClientImpl::Core::Core(base::Clock* clock, base::Timer* timer)
 }
 
 MDnsClientImpl::Core::~Core() {
-  base::STLDeleteValues(&listeners_);
 }
 
 bool MDnsClientImpl::Core::Init(MDnsSocketFactory* socket_factory) {
@@ -348,17 +346,12 @@ void MDnsClientImpl::Core::AlertListeners(
 void MDnsClientImpl::Core::AddListener(
     MDnsListenerImpl* listener) {
   ListenerKey key(listener->GetName(), listener->GetType());
-  std::pair<ListenerMap::iterator, bool> observer_insert_result =
-      listeners_.insert(make_pair(
-          key, static_cast<base::ObserverList<MDnsListenerImpl>*>(NULL)));
 
-  // If an equivalent key does not exist, actually create the observer list.
-  if (observer_insert_result.second)
-    observer_insert_result.first->second =
-        new base::ObserverList<MDnsListenerImpl>();
+  std::unique_ptr<base::ObserverList<MDnsListenerImpl>>& observer_list =
+      listeners_[key];
 
-  base::ObserverList<MDnsListenerImpl>* observer_list =
-      observer_insert_result.first->second;
+  if (!observer_list)
+    observer_list = base::MakeUnique<base::ObserverList<MDnsListenerImpl>>();
 
   observer_list->AddObserver(listener);
 }
@@ -385,7 +378,6 @@ void MDnsClientImpl::Core::RemoveListener(MDnsListenerImpl* listener) {
 void MDnsClientImpl::Core::CleanupObserverList(const ListenerKey& key) {
   ListenerMap::iterator found = listeners_.find(key);
   if (found != listeners_.end() && !found->second->might_have_observers()) {
-    delete found->second;
     listeners_.erase(found);
   }
 }

net/dns/mdns_client_impl.h

@@ -148,7 +148,8 @@ class NET_EXPORT_PRIVATE MDnsClientImpl : public MDnsClient {
     FRIEND_TEST_ALL_PREFIXES(MDnsTest, CacheCleanupWithShortTTL);
 
     typedef std::pair<std::string, uint16_t> ListenerKey;
-    typedef std::map<ListenerKey, base::ObserverList<MDnsListenerImpl>*>
+    typedef std::map<ListenerKey,
+                     std::unique_ptr<base::ObserverList<MDnsListenerImpl>>>
         ListenerMap;
 
     // Alert listeners of an update to the cache.