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

net/dns/mojo_host_resolver_impl.cc

 // Copyright 2015 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/mojo_host_resolver_impl.h"
 
 #include <utility>
 
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 #include "net/dns/host_resolver.h"
 
 namespace net {
 
 // Handles host resolution for a single request and sends a response when done.
 // Also detects connection errors for HostResolverRequestClient and cancels the
 // outstanding resolve request. Owned by MojoHostResolverImpl.
@@ skipping 24 matching lines @@
   AddressList result_;
   base::ThreadChecker thread_checker_;
 };
 
 MojoHostResolverImpl::MojoHostResolverImpl(net::HostResolver* resolver,
                                            const NetLogWithSource& net_log)
     : resolver_(resolver), net_log_(net_log) {}
 
 MojoHostResolverImpl::~MojoHostResolverImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  base::STLDeleteElements(&pending_jobs_);
 }
 
 void MojoHostResolverImpl::Resolve(
     std::unique_ptr<HostResolver::RequestInfo> request_info,
     interfaces::HostResolverRequestClientPtr client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (request_info->is_my_ip_address()) {
     // The proxy resolver running inside a sandbox may not be able to get the
     // correct host name. Instead, fill it ourself if the request is for our own
     // IP address.
     request_info->set_host_port_pair(HostPortPair(GetHostName(), 80));
   }
   Job* job =
       new Job(this, resolver_, *request_info, net_log_, std::move(client));
-  pending_jobs_.insert(job);
+  pending_jobs_.insert(base::WrapUnique(job));
   job->Start();
 }
 
 void MojoHostResolverImpl::DeleteJob(Job* job) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  size_t num_erased = pending_jobs_.erase(job);
-  DCHECK(num_erased);
-  delete job;
+  auto it = std::find_if(
+      pending_jobs_.begin(), pending_jobs_.end(),
+      [job](const std::unique_ptr<Job>& ptr) { return ptr.get() == job; });

[davidben, 2016/11/09 22:22:03]

Same issue as always. :-) std::find_if on a std::set is the worst of all worlds.
std::find_if on a std::vector or std::map<T*, std::unique_ptr<T>> are both
strictly better than this pattern.

But, try jobs willing, I propose we use this pattern (and probably fix all the
old instances prior CLs left around). The one nuisance is this pattern can't
temporarily orphan jobs as HostResolverImpl does. But I feel like most of the
time, this works fine:

https://codereview.chromium.org/2489113002

+  DCHECK(it != pending_jobs_.end());
+  pending_jobs_.erase(it);
 }
 
 MojoHostResolverImpl::Job::Job(
     MojoHostResolverImpl* resolver_service,
     net::HostResolver* resolver,
     const net::HostResolver::RequestInfo& request_info,
     const NetLogWithSource& net_log,
     interfaces::HostResolverRequestClientPtr client)
     : resolver_service_(resolver_service),
       resolver_(resolver),
@@ skipping 35 matching lines @@
 void MojoHostResolverImpl::Job::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // |resolver_service_| should always outlive us.
   DCHECK(resolver_service_);
   DVLOG(1) << "Connection error on request for "
            << request_info_.host_port_pair().ToString();
   resolver_service_->DeleteJob(this);
 }
 
 }  // namespace net