BASELINE: Update Chromium to 57.0.2987.144

Change-Id: I29db402ff696c71a04c4dbaec822c2e53efe0267
Reviewed-by: Peter Varga <pvarga@inf.u-szeged.hu>

39 files changed, 247 insertions, 157 deletions

diff --git a/chromium/net/dns/address_sorter_posix.cc b/chromium/net/dns/address_sorter_posix.cc
index 965543c0a27..e354de20223 100644
--- a/chromium/net/dns/address_sorter_posix.cc
+++ b/chromium/net/dns/address_sorter_posix.cc
@@ -397,4 +397,3 @@ std::unique_ptr<AddressSorter> AddressSorter::CreateAddressSorter() {
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/address_sorter_unittest.cc b/chromium/net/dns/address_sorter_unittest.cc
index 6c023997a33..b9069df0c80 100644
--- a/chromium/net/dns/address_sorter_unittest.cc
+++ b/chromium/net/dns/address_sorter_unittest.cc
@@ -10,6 +10,8 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/test/scoped_task_scheduler.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_address.h"
 #include "net/base/test_completion_callback.h"
@@ -38,6 +40,8 @@ void OnSortComplete(AddressList* result_buf,
 }
 
 TEST(AddressSorterTest, Sort) {
+  base::test::ScopedTaskScheduler scoped_task_scheduler(
+      base::MessageLoop::current());
   int expected_result = OK;
 #if defined(OS_WIN)
   EnsureWinsockInit();
diff --git a/chromium/net/dns/address_sorter_win.cc b/chromium/net/dns/address_sorter_win.cc
index 71ad0c0b71d..a085af5c3e2 100644
--- a/chromium/net/dns/address_sorter_win.cc
+++ b/chromium/net/dns/address_sorter_win.cc
@@ -13,7 +13,7 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/free_deleter.h"
-#include "base/threading/worker_pool.h"
+#include "base/task_scheduler/post_task.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
@@ -39,7 +39,7 @@ class AddressSorterWin : public AddressSorter {
   }
 
  private:
-  // Executes the SIO_ADDRESS_LIST_SORT ioctl on the WorkerPool, and
+  // Executes the SIO_ADDRESS_LIST_SORT ioctl asynchronously, and
   // performs the necessary conversions to/from AddressList.
   class Job : public base::RefCountedThreadSafe<Job> {
    public:
@@ -73,21 +73,19 @@ class AddressSorterWin : public AddressSorter {
         input_buffer_->Address[i].iSockaddrLength = addr_len;
       }
 
-      if (!base::WorkerPool::PostTaskAndReply(
-          FROM_HERE,
-          base::Bind(&Job::Run, this),
-          base::Bind(&Job::OnComplete, this),
-          false /* task is slow */)) {
-        LOG(ERROR) << "WorkerPool::PostTaskAndReply failed";
-        OnComplete();
-      }
+      base::PostTaskWithTraitsAndReply(
+          FROM_HERE, base::TaskTraits()
+                         .WithShutdownBehavior(
+                             base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
+                         .MayBlock(),
+          base::Bind(&Job::Run, this), base::Bind(&Job::OnComplete, this));
     }
 
    private:
     friend class base::RefCountedThreadSafe<Job>;
     ~Job() {}
 
-    // Executed on the WorkerPool.
+    // Executed asynchronously in TaskScheduler.
     void Run() {
       SOCKET sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
       if (sock == INVALID_SOCKET)
@@ -147,4 +145,3 @@ std::unique_ptr<AddressSorter> AddressSorter::CreateAddressSorter() {
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_client.cc b/chromium/net/dns/dns_client.cc
index 109c3af1e69..883eb01c357 100644
--- a/chromium/net/dns/dns_client.cc
+++ b/chromium/net/dns/dns_client.cc
@@ -103,4 +103,3 @@ std::unique_ptr<DnsClient> DnsClient::CreateClientForTesting(
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_client.h b/chromium/net/dns/dns_client.h
index 303d68e6775..7809a9103d6 100644
--- a/chromium/net/dns/dns_client.h
+++ b/chromium/net/dns/dns_client.h
@@ -61,4 +61,3 @@ class NET_EXPORT DnsClient {
 }  // namespace net
 
 #endif  // NET_DNS_DNS_CLIENT_H_
-
diff --git a/chromium/net/dns/dns_config_service.cc b/chromium/net/dns/dns_config_service.cc
index 0f839478a4c..1a7a59d5df4 100644
--- a/chromium/net/dns/dns_config_service.cc
+++ b/chromium/net/dns/dns_config_service.cc
@@ -233,4 +233,3 @@ void DnsConfigService::OnCompleteConfig() {
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_config_service.h b/chromium/net/dns/dns_config_service.h
index 5c372262a6c..e0fd54a6f3b 100644
--- a/chromium/net/dns/dns_config_service.h
+++ b/chromium/net/dns/dns_config_service.h
@@ -28,8 +28,6 @@ class Value;
 
 namespace net {
 
-class IPAddress;
-
 // Default to 1 second timeout (before exponential backoff).
 const int64_t kDnsDefaultTimeoutMs = 1000;
 
diff --git a/chromium/net/dns/dns_config_service_posix.cc b/chromium/net/dns/dns_config_service_posix.cc
index ba8a3691331..c9c9d9231af 100644
--- a/chromium/net/dns/dns_config_service_posix.cc
+++ b/chromium/net/dns/dns_config_service_posix.cc
@@ -31,6 +31,8 @@
 
 #if defined(OS_ANDROID)
 #include <sys/system_properties.h>
+#include "base/android/build_info.h"
+#include "net/android/network_library.h"
 #include "net/base/network_change_notifier.h"
 #endif
 
@@ -170,6 +172,14 @@ ConfigParsePosixResult ReadDnsConfig(DnsConfig* config) {
 // TODO(juliatuttle): Depend on libcutils, then switch this (and other uses of
 //                    __system_property_get) to property_get.
 ConfigParsePosixResult ReadDnsConfig(DnsConfig* dns_config) {
+  if (base::android::BuildInfo::GetInstance()->sdk_int() >=
+      base::android::SDK_VERSION_MARSHMALLOW) {
+    dns_config->nameservers.clear();
+    net::android::GetDnsServers(&dns_config->nameservers);
+    if (dns_config->nameservers.empty())
+      return CONFIG_PARSE_POSIX_NO_NAMESERVERS;
+    return CONFIG_PARSE_POSIX_OK;
+  }
   char property_value[PROP_VALUE_MAX];
   __system_property_get("net.dns1", property_value);
   std::string dns1_string = property_value;
diff --git a/chromium/net/dns/dns_config_service_unittest.cc b/chromium/net/dns/dns_config_service_unittest.cc
index 99c29e5445a..351830963ff 100644
--- a/chromium/net/dns/dns_config_service_unittest.cc
+++ b/chromium/net/dns/dns_config_service_unittest.cc
@@ -244,4 +244,3 @@ TEST_F(DnsConfigServiceTest, WatchFailure) {
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_config_service_win.h b/chromium/net/dns/dns_config_service_win.h
index 47a1c05e165..96870e9f18c 100644
--- a/chromium/net/dns/dns_config_service_win.h
+++ b/chromium/net/dns/dns_config_service_win.h
@@ -148,4 +148,3 @@ class NET_EXPORT_PRIVATE DnsConfigServiceWin : public DnsConfigService {
 }  // namespace net
 
 #endif  // NET_DNS_DNS_CONFIG_SERVICE_WIN_H_
-
diff --git a/chromium/net/dns/dns_config_service_win_unittest.cc b/chromium/net/dns/dns_config_service_win_unittest.cc
index 5975e88a3b4..091c090a918 100644
--- a/chromium/net/dns/dns_config_service_win_unittest.cc
+++ b/chromium/net/dns/dns_config_service_win_unittest.cc
@@ -443,4 +443,3 @@ TEST(DnsConfigServiceWinTest, HaveNRPT) {
 }  // namespace
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_config_watcher_mac.h b/chromium/net/dns/dns_config_watcher_mac.h
index d3e9924626c..3ff44d908be 100644
--- a/chromium/net/dns/dns_config_watcher_mac.h
+++ b/chromium/net/dns/dns_config_watcher_mac.h
@@ -2,6 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#ifndef NET_DNS_DNS_CONFIG_WATCHER_MAC_H_
+#define NET_DNS_DNS_CONFIG_WATCHER_MAC_H_
+
 #include "base/callback_forward.h"
 #include "net/dns/dns_config_service_posix.h"
 #include "net/dns/notify_watcher_mac.h"
@@ -24,3 +27,5 @@ class DnsConfigWatcher {
 
 }  // namespace internal
 }  // namespace net
+
+#endif  // NET_DNS_DNS_CONFIG_WATCHER_MAC_H_
diff --git a/chromium/net/dns/dns_hosts.cc b/chromium/net/dns/dns_hosts.cc
index 568a9ce5558..7d45711372a 100644
--- a/chromium/net/dns/dns_hosts.cc
+++ b/chromium/net/dns/dns_hosts.cc
@@ -215,4 +215,3 @@ bool ParseHostsFile(const base::FilePath& path, DnsHosts* dns_hosts) {
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_hosts.h b/chromium/net/dns/dns_hosts.h
index e55772b7e35..423258ba2dc 100644
--- a/chromium/net/dns/dns_hosts.h
+++ b/chromium/net/dns/dns_hosts.h
@@ -75,4 +75,3 @@ bool NET_EXPORT_PRIVATE ParseHostsFile(const base::FilePath& path,
 }  // namespace net
 
 #endif  // NET_DNS_DNS_HOSTS_H_
-
diff --git a/chromium/net/dns/dns_hosts_unittest.cc b/chromium/net/dns/dns_hosts_unittest.cc
index 72722017206..e2729f6e1f4 100644
--- a/chromium/net/dns/dns_hosts_unittest.cc
+++ b/chromium/net/dns/dns_hosts_unittest.cc
@@ -183,4 +183,3 @@ TEST(DnsHostsTest, HostsParser_EndsWithNewlineAndToken) {
 }  // namespace
 
 }  // namespace net
-
diff --git a/chromium/net/dns/dns_protocol.h b/chromium/net/dns/dns_protocol.h
index f80886338ac..416738a2bed 100644
--- a/chromium/net/dns/dns_protocol.h
+++ b/chromium/net/dns/dns_protocol.h
@@ -128,7 +128,6 @@ static const uint16_t kTypeNSEC = 47;
 // DNS reply codes (RCODEs).
 //
 // https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6
-static const uint8_t kRcodeMask = 0xf;
 static const uint8_t kRcodeNOERROR = 0;
 static const uint8_t kRcodeFORMERR = 1;
 static const uint8_t kRcodeSERVFAIL = 2;
diff --git a/chromium/net/dns/dns_response.cc b/chromium/net/dns/dns_response.cc
index 98967899156..f168a255f39 100644
--- a/chromium/net/dns/dns_response.cc
+++ b/chromium/net/dns/dns_response.cc
@@ -19,6 +19,12 @@
 
 namespace net {
 
+namespace {
+
+const uint8_t kRcodeMask = 0xf;
+
+}  // namespace
+
 DnsResourceRecord::DnsResourceRecord() {
 }
 
@@ -221,12 +227,12 @@ bool DnsResponse::IsValid() const {
 
 uint16_t DnsResponse::flags() const {
   DCHECK(parser_.IsValid());
-  return base::NetToHost16(header()->flags) & ~(dns_protocol::kRcodeMask);
+  return base::NetToHost16(header()->flags) & ~(kRcodeMask);
 }
 
 uint8_t DnsResponse::rcode() const {
   DCHECK(parser_.IsValid());
-  return base::NetToHost16(header()->flags) & dns_protocol::kRcodeMask;
+  return base::NetToHost16(header()->flags) & kRcodeMask;
 }
 
 unsigned DnsResponse::answer_count() const {
diff --git a/chromium/net/dns/dns_session.h b/chromium/net/dns/dns_session.h
index 1ffa40c219d..a97132eec0e 100644
--- a/chromium/net/dns/dns_session.h
+++ b/chromium/net/dns/dns_session.h
@@ -23,12 +23,10 @@
 
 namespace base {
 class BucketRanges;
-class SampleVector;
 }
 
 namespace net {
 
-class ClientSocketFactory;
 class DatagramClientSocket;
 class NetLog;
 struct NetLogSource;
diff --git a/chromium/net/dns/dns_session_unittest.cc b/chromium/net/dns/dns_session_unittest.cc
index c75e30e98cb..d228556f427 100644
--- a/chromium/net/dns/dns_session_unittest.cc
+++ b/chromium/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) {
diff --git a/chromium/net/dns/dns_socket_pool.cc b/chromium/net/dns/dns_socket_pool.cc
index bf90c28c573..1070953ec49 100644
--- a/chromium/net/dns/dns_socket_pool.cc
+++ b/chromium/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));
   }
 }
 
diff --git a/chromium/net/dns/dns_test_util.cc b/chromium/net/dns/dns_test_util.cc
index 24ce6fbb375..2de2c69bdd4 100644
--- a/chromium/net/dns/dns_test_util.cc
+++ b/chromium/net/dns/dns_test_util.cc
@@ -57,6 +57,13 @@ class MockTransaction : public DnsTransaction,
           (hostname.compare(0, prefix.size(), prefix) == 0)) {
         result_ = rules[i].result;
         delayed_ = rules[i].delay;
+
+        // Fill in an IP address for the result if one was not specified.
+        if (result_.ip.empty() && result_.type == MockDnsClientRule::OK) {
+          result_.ip = qtype_ == dns_protocol::kTypeA
+                           ? IPAddress::IPv4Localhost()
+                           : IPAddress::IPv6Localhost();
+        }
         break;
       }
     }
@@ -86,7 +93,7 @@ class MockTransaction : public DnsTransaction,
 
  private:
   void Finish() {
-    switch (result_) {
+    switch (result_.type) {
       case MockDnsClientRule::EMPTY:
       case MockDnsClientRule::OK: {
         std::string qname;
@@ -101,22 +108,21 @@ class MockTransaction : public DnsTransaction,
             reinterpret_cast<dns_protocol::Header*>(buffer);
         header->flags |= dns_protocol::kFlagResponse;
 
-        if (MockDnsClientRule::OK == result_) {
+        if (MockDnsClientRule::OK == result_.type) {
           const uint16_t kPointerToQueryName =
               static_cast<uint16_t>(0xc000 | sizeof(*header));
 
           const uint32_t kTTL = 86400;  // One day.
 
           // Size of RDATA which is a IPv4 or IPv6 address.
-          size_t rdata_size = qtype_ == dns_protocol::kTypeA
-                                  ? IPAddress::kIPv4AddressSize
-                                  : IPAddress::kIPv6AddressSize;
+          EXPECT_TRUE(result_.ip.IsValid());
+          size_t rdata_size = result_.ip.size();
 
           // 12 is the sum of sizes of the compressed name reference, TYPE,
           // CLASS, TTL and RDLENGTH.
           size_t answer_size = 12 + rdata_size;
 
-          // Write answer with loopback IP address.
+          // Write the answer using the expected IP address.
           header->ancount = base::HostToNet16(1);
           base::BigEndianWriter writer(buffer + nbytes, answer_size);
           writer.WriteU16(kPointerToQueryName);
@@ -124,14 +130,7 @@ class MockTransaction : public DnsTransaction,
           writer.WriteU16(dns_protocol::kClassIN);
           writer.WriteU32(kTTL);
           writer.WriteU16(static_cast<uint16_t>(rdata_size));
-          if (qtype_ == dns_protocol::kTypeA) {
-            char kIPv4Loopback[] = { 0x7f, 0, 0, 1 };
-            writer.WriteBytes(kIPv4Loopback, sizeof(kIPv4Loopback));
-          } else {
-            char kIPv6Loopback[] = { 0, 0, 0, 0, 0, 0, 0, 0,
-                                     0, 0, 0, 0, 0, 0, 0, 1 };
-            writer.WriteBytes(kIPv6Loopback, sizeof(kIPv6Loopback));
-          }
+          writer.WriteBytes(result_.ip.bytes().data(), rdata_size);
           nbytes += answer_size;
         }
         EXPECT_TRUE(response.InitParse(nbytes, query));
diff --git a/chromium/net/dns/dns_test_util.h b/chromium/net/dns/dns_test_util.h
index 21769fc1231..133c33fa978 100644
--- a/chromium/net/dns/dns_test_util.h
+++ b/chromium/net/dns/dns_test_util.h
@@ -158,18 +158,27 @@ class DnsClient;
 class MockTransactionFactory;
 
 struct MockDnsClientRule {
-  enum Result {
+  enum ResultType {
     FAIL,     // Fail asynchronously with ERR_NAME_NOT_RESOLVED.
     TIMEOUT,  // Fail asynchronously with ERR_DNS_TIMEOUT.
     EMPTY,    // Return an empty response.
-    OK,       // Return a response with loopback address.
+    OK,       // Return an IP address (the accompanying IP is an argument in the
+              // Result structure, or understood as localhost when unspecified).
+  };
+
+  struct Result {
+    explicit Result(const IPAddress& ip) : type(OK), ip(ip) {}
+    explicit Result(ResultType type) : type(type) {}
+
+    ResultType type;
+    IPAddress ip;
   };
 
   // If |delay| is true, matching transactions will be delayed until triggered
   // by the consumer.
   MockDnsClientRule(const std::string& prefix_arg,
                     uint16_t qtype_arg,
-                    Result result_arg,
+                    const Result& result_arg,
                     bool delay)
       : result(result_arg),
         prefix(prefix_arg),
diff --git a/chromium/net/dns/dns_transaction.h b/chromium/net/dns/dns_transaction.h
index f81cc554086..cd56fc46ef5 100644
--- a/chromium/net/dns/dns_transaction.h
+++ b/chromium/net/dns/dns_transaction.h
@@ -77,4 +77,3 @@ class NET_EXPORT_PRIVATE DnsTransactionFactory {
 }  // namespace net
 
 #endif  // NET_DNS_DNS_TRANSACTION_H_
-
diff --git a/chromium/net/dns/fuzzed_host_resolver.h b/chromium/net/dns/fuzzed_host_resolver.h
index 945225b7a67..cc14578be32 100644
--- a/chromium/net/dns/fuzzed_host_resolver.h
+++ b/chromium/net/dns/fuzzed_host_resolver.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef NET_DNS_FUZZED_HOST_RESOLVER_
-#define NET_DNS_FUZZED_HOST_RESOLVER_
+#ifndef NET_DNS_FUZZED_HOST_RESOLVER_H_
+#define NET_DNS_FUZZED_HOST_RESOLVER_H_
 
 #include <stdint.h>
 
@@ -23,10 +23,8 @@ class FuzzedDataProvider;
 namespace net {
 
 class AddressList;
-class ClientSocketFactory;
 class DnsClient;
 class NetLog;
-class ScopedDefaultHostResolverProc;
 
 // HostResolver that uses a fuzzer to determine what results to return. It
 // inherits from HostResolverImpl, unlike MockHostResolver, so more closely
@@ -80,4 +78,4 @@ class FuzzedHostResolver : public HostResolverImpl {
 
 }  // namespace net
 
-#endif  // NET_DNS_FUZZED_HOST_RESOLVER_
+#endif  // NET_DNS_FUZZED_HOST_RESOLVER_H_
diff --git a/chromium/net/dns/host_cache.cc b/chromium/net/dns/host_cache.cc
index 881f5140b6f..1ff1755e8b1 100644
--- a/chromium/net/dns/host_cache.cc
+++ b/chromium/net/dns/host_cache.cc
@@ -11,6 +11,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "net/base/net_errors.h"
+#include "net/base/trace_constants.h"
 #include "net/dns/dns_util.h"
 
 namespace net {
@@ -162,7 +163,7 @@ void HostCache::Set(const Key& key,
                     const Entry& entry,
                     base::TimeTicks now,
                     base::TimeDelta ttl) {
-  TRACE_EVENT0("net", "HostCache::Set");
+  TRACE_EVENT0(kNetTracingCategory, "HostCache::Set");
   DCHECK(CalledOnValidThread());
   if (caching_is_disabled())
     return;
diff --git a/chromium/net/dns/host_resolver_impl.cc b/chromium/net/dns/host_resolver_impl.cc
index fceb67e33a5..c078986f251 100644
--- a/chromium/net/dns/host_resolver_impl.cc
+++ b/chromium/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"
@@ -44,6 +43,7 @@
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
+#include "net/base/trace_constants.h"
 #include "net/base/url_util.h"
 #include "net/dns/address_sorter.h"
 #include "net/dns/dns_client.h"
@@ -182,6 +182,16 @@ enum DnsResolveStatus {
 // For more details: https://www.icann.org/news/announcement-2-2014-08-01-en
 const uint8_t kIcanNameCollisionIp[] = {127, 0, 53, 53};
 
+bool ContainsIcannNameCollisionIp(const AddressList& addr_list) {
+  for (const auto& endpoint : addr_list) {
+    const IPAddress& addr = endpoint.address();
+    if (addr.IsIPv4() && IPAddressStartsWith(addr, kIcanNameCollisionIp)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 void UmaAsyncDnsResolveStatus(DnsResolveStatus result) {
   UMA_HISTOGRAM_ENUMERATION("AsyncDNS.ResolveStatus",
                             result,
@@ -738,16 +748,6 @@ class HostResolverImpl::ProcTask
                                                &results,
                                                &os_error);
 
-    // Fail the resolution if the result contains 127.0.53.53. See the comment
-    // block of kIcanNameCollisionIp for details on why.
-    for (const auto& it : results) {
-      const IPAddress& cur = it.address();
-      if (cur.IsIPv4() && IPAddressStartsWith(cur, kIcanNameCollisionIp)) {
-        error = ERR_ICANN_NAME_COLLISION;
-        break;
-      }
-    }
-
     network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ProcTask::OnLookupComplete, this, results,
                               start_time, attempt_number, error, os_error));
@@ -770,7 +770,7 @@ class HostResolverImpl::ProcTask
                         const uint32_t attempt_number,
                         int error,
                         const int os_error) {
-    TRACE_EVENT0("net", "ProcTask::OnLookupComplete");
+    TRACE_EVENT0(kNetTracingCategory, "ProcTask::OnLookupComplete");
     DCHECK(network_task_runner_->BelongsToCurrentThread());
     // If results are empty, we should return an error.
     bool empty_list_on_ok = (error == OK && results.empty());
@@ -1457,9 +1457,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
                                   requests_.front()->info(),
                                   &addr_list)) {
       // This will destroy the Job.
-      CompleteRequests(
-          HostCache::Entry(OK, MakeAddressListForRequest(addr_list)),
-          base::TimeDelta());
+      CompleteRequests(MakeCacheEntry(OK, addr_list), base::TimeDelta());
       return true;
     }
     return false;
@@ -1499,6 +1497,25 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
     DCHECK_EQ(1u, num_occupied_job_slots_);
   }
 
+  // MakeCacheEntry() and MakeCacheEntryWithTTL() are helpers to build a
+  // HostCache::Entry(). The address list is omited from the cache entry
+  // for errors.
+  HostCache::Entry MakeCacheEntry(int net_error,
+                                  const AddressList& addr_list) const {
+    return HostCache::Entry(
+        net_error,
+        net_error == OK ? MakeAddressListForRequest(addr_list) : AddressList());
+  }
+
+  HostCache::Entry MakeCacheEntryWithTTL(int net_error,
+                                         const AddressList& addr_list,
+                                         base::TimeDelta ttl) const {
+    return HostCache::Entry(
+        net_error,
+        net_error == OK ? MakeAddressListForRequest(addr_list) : AddressList(),
+        ttl);
+  }
+
   AddressList MakeAddressListForRequest(const AddressList& list) const {
     if (requests_.empty())
       return list;
@@ -1618,15 +1635,16 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
       }
     }
 
+    if (ContainsIcannNameCollisionIp(addr_list))
+      net_error = ERR_ICANN_NAME_COLLISION;
+
     base::TimeDelta ttl =
         base::TimeDelta::FromSeconds(kNegativeCacheEntryTTLSeconds);
     if (net_error == OK)
       ttl = base::TimeDelta::FromSeconds(kCacheEntryTTLSeconds);
 
     // Don't store the |ttl| in cache since it's not obtained from the server.
-    CompleteRequests(
-        HostCache::Entry(net_error, MakeAddressListForRequest(addr_list)),
-        ttl);
+    CompleteRequests(MakeCacheEntry(net_error, addr_list), ttl);
   }
 
   void StartDnsTask() {
@@ -1708,9 +1726,12 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
     base::TimeDelta bounded_ttl =
         std::max(ttl, base::TimeDelta::FromSeconds(kMinimumTTLSeconds));
 
-    CompleteRequests(
-        HostCache::Entry(net_error, MakeAddressListForRequest(addr_list), ttl),
-        bounded_ttl);
+    if (ContainsIcannNameCollisionIp(addr_list)) {
+      CompleteRequestsWithError(ERR_ICANN_NAME_COLLISION);
+    } else {
+      CompleteRequests(MakeCacheEntryWithTTL(net_error, addr_list, ttl),
+                       bounded_ttl);
+    }
   }
 
   void OnFirstDnsTransactionComplete() override {
@@ -1768,7 +1789,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
 
     DCHECK(!requests_.empty());
 
-    if (entry.error() == OK) {
+    if (entry.error() == OK || entry.error() == ERR_ICANN_NAME_COLLISION) {
       // Record this histogram here, when we know the system has a valid DNS
       // configuration.
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HaveDnsConfig",
@@ -1895,9 +1916,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);
@@ -1948,7 +1969,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,
@@ -1966,14 +1987,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);
 
@@ -2302,9 +2323,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(
@@ -2335,12 +2358,14 @@ HostResolverImpl::Key HostResolverImpl::GetEffectiveKeyForRequest(
 }
 
 bool HostResolverImpl::IsIPv6Reachable(const NetLogWithSource& net_log) {
-  base::TimeTicks now = base::TimeTicks::Now();
+  // Cache the result for kIPv6ProbePeriodMs (measured from after
+  // IsGloballyReachable() completes).
   bool cached = true;
-  if ((now - last_ipv6_probe_time_).InMilliseconds() > kIPv6ProbePeriodMs) {
+  if ((base::TimeTicks::Now() - last_ipv6_probe_time_).InMilliseconds() >
+      kIPv6ProbePeriodMs) {
     last_ipv6_probe_result_ =
         IsGloballyReachable(IPAddress(kIPv6ProbeAddress), net_log);
-    last_ipv6_probe_time_ = now;
+    last_ipv6_probe_time_ = base::TimeTicks::Now();
     cached = false;
   }
   net_log.AddEvent(NetLogEventType::HOST_RESOLVER_IMPL_IPV6_REACHABILITY_CHECK,
@@ -2358,10 +2383,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());
@@ -2398,7 +2423,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);
 }
@@ -2413,8 +2438,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();
diff --git a/chromium/net/dns/host_resolver_impl.h b/chromium/net/dns/host_resolver_impl.h
index 373f2297ea0..0ad7146dfc9 100644
--- a/chromium/net/dns/host_resolver_impl.h
+++ b/chromium/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
diff --git a/chromium/net/dns/host_resolver_impl_unittest.cc b/chromium/net/dns/host_resolver_impl_unittest.cc
index 0dbed080e9e..0b4807a9851 100644
--- a/chromium/net/dns/host_resolver_impl_unittest.cc
+++ b/chromium/net/dns/host_resolver_impl_unittest.cc
@@ -1486,9 +1486,9 @@ TEST_F(HostResolverImplTest, MultipleAttempts) {
 
 // If a host resolves to a list that includes 127.0.53.53, this is treated as
 // an error. 127.0.53.53 is a localhost address, however it has been given a
-// special significance by ICANN to help surfance name collision resulting from
+// special significance by ICANN to help surface name collision resulting from
 // the new gTLDs.
-TEST_F(HostResolverImplTest, NameCollision127_0_53_53) {
+TEST_F(HostResolverImplTest, NameCollisionIcann) {
   proc_->AddRuleForAllFamilies("single", "127.0.53.53");
   proc_->AddRuleForAllFamilies("multiple", "127.0.0.1,127.0.53.53");
   proc_->AddRuleForAllFamilies("ipv6", "::127.0.53.53");
@@ -1503,6 +1503,12 @@ TEST_F(HostResolverImplTest, NameCollision127_0_53_53) {
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
 
+  // ERR_ICANN_NAME_COLLISION is cached like any other error, using a
+  // fixed TTL for failed entries from proc-based resolver. That said, the
+  // fixed TTL is 0, so it will never be cached.
+  request = CreateRequest("single");
+  EXPECT_THAT(request->ResolveFromCache(), IsError(ERR_DNS_CACHE_MISS));
+
   request = CreateRequest("multiple");
   EXPECT_THAT(request->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_THAT(request->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
@@ -1615,6 +1621,16 @@ class HostResolverImplDnsTest : public HostResolverImplTest {
                MockDnsClientRule::OK, true);
     AddDnsRule("4slow_6timeout", dns_protocol::kTypeAAAA,
                MockDnsClientRule::TIMEOUT, false);
+    AddDnsRule("4collision", dns_protocol::kTypeA, IPAddress(127, 0, 53, 53),
+               false);
+    AddDnsRule("4collision", dns_protocol::kTypeAAAA, MockDnsClientRule::EMPTY,
+               false);
+    AddDnsRule("6collision", dns_protocol::kTypeA, MockDnsClientRule::EMPTY,
+               false);
+    // This isn't the expected IP for collisions (but looks close to it).
+    AddDnsRule("6collision", dns_protocol::kTypeAAAA,
+               IPAddress(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 0, 53, 53),
+               false);
     CreateResolver();
   }
 
@@ -1633,6 +1649,22 @@ class HostResolverImplDnsTest : public HostResolverImplTest {
   // Adds a rule to |dns_rules_|. Must be followed by |CreateResolver| to apply.
   void AddDnsRule(const std::string& prefix,
                   uint16_t qtype,
+                  MockDnsClientRule::ResultType result_type,
+                  bool delay) {
+    return AddDnsRule(prefix, qtype, MockDnsClientRule::Result(result_type),
+                      delay);
+  }
+
+  void AddDnsRule(const std::string& prefix,
+                  uint16_t qtype,
+                  const IPAddress& result_ip,
+                  bool delay) {
+    return AddDnsRule(prefix, qtype, MockDnsClientRule::Result(result_ip),
+                      delay);
+  }
+
+  void AddDnsRule(const std::string& prefix,
+                  uint16_t qtype,
                   MockDnsClientRule::Result result,
                   bool delay) {
     dns_rules_.push_back(MockDnsClientRule(prefix, qtype, result, delay));
@@ -1792,6 +1824,34 @@ TEST_F(HostResolverImplDnsTest, DnsTaskUnspec) {
   EXPECT_TRUE(requests_[3]->HasAddress("192.168.1.101", 80));
 }
 
+TEST_F(HostResolverImplDnsTest, NameCollisionIcann) {
+  ChangeDnsConfig(CreateValidDnsConfig());
+
+  // When the resolver returns an A record with 127.0.53.53 it should be mapped
+  // to a special error.
+  EXPECT_THAT(CreateRequest("4collision", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+
+  EXPECT_THAT(requests_[0]->WaitForResult(), IsError(ERR_ICANN_NAME_COLLISION));
+
+  // When the resolver returns an AAAA record with ::127.0.53.53 it should
+  // work just like any other IP. (Despite having the same suffix, it is not
+  // considered special)
+  EXPECT_THAT(CreateRequest("6collision", 80)->Resolve(),
+              IsError(ERR_IO_PENDING));
+
+  EXPECT_THAT(requests_[1]->WaitForResult(), IsError(OK));
+  EXPECT_TRUE(requests_[1]->HasAddress("::127.0.53.53", 80));
+
+  // The mock responses for 4collision (and 6collision) have a TTL of 1 day.
+  // Test whether the ERR_ICANN_NAME_COLLISION failure was cached.
+  // On the one hand caching the failure makes sense, as the error is derived
+  // from the IP in the response. However for consistency with the the proc-
+  // based implementation the TTL is unused.
+  EXPECT_THAT(CreateRequest("4collision", 80)->ResolveFromCache(),
+              IsError(ERR_DNS_CACHE_MISS));
+}
+
 TEST_F(HostResolverImplDnsTest, ServeFromHosts) {
   // Initially, use empty HOSTS file.
   DnsConfig config = CreateValidDnsConfig();
diff --git a/chromium/net/dns/host_resolver_mojo.cc b/chromium/net/dns/host_resolver_mojo.cc
index 3c311c4a2a8..ac4183adb7b 100644
--- a/chromium/net/dns/host_resolver_mojo.cc
+++ b/chromium/net/dns/host_resolver_mojo.cc
@@ -7,6 +7,7 @@
 #include <utility>
 
 #include "base/callback_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
@@ -89,7 +90,7 @@ int HostResolverMojo::Resolve(const RequestInfo& info,
 
   interfaces::HostResolverRequestClientPtr handle;
   std::unique_ptr<Job> job(new Job(key, addresses, callback,
-                                   mojo::GetProxy(&handle),
+                                   mojo::MakeRequest(&handle),
                                    host_cache_weak_factory_.GetWeakPtr()));
   request->reset(new RequestImpl(std::move(job)));
 
diff --git a/chromium/net/dns/mdns_cache.h b/chromium/net/dns/mdns_cache.h
index a2d3d0fc0e5..60987953904 100644
--- a/chromium/net/dns/mdns_cache.h
+++ b/chromium/net/dns/mdns_cache.h
@@ -17,7 +17,6 @@
 
 namespace net {
 
-class ParsedDnsRecord;
 class RecordParsed;
 
 // mDNS Cache
diff --git a/chromium/net/dns/mdns_client_impl.cc b/chromium/net/dns/mdns_client_impl.cc
index 67c5ac5b333..8dbd6d3277e 100644
--- a/chromium/net/dns/mdns_client_impl.cc
+++ b/chromium/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);
   }
 }
diff --git a/chromium/net/dns/mdns_client_impl.h b/chromium/net/dns/mdns_client_impl.h
index ec0536c6264..f86de96f222 100644
--- a/chromium/net/dns/mdns_client_impl.h
+++ b/chromium/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.
diff --git a/chromium/net/dns/mojo_host_resolver_impl.cc b/chromium/net/dns/mojo_host_resolver_impl.cc
index f8f08d8b249..e61387ab740 100644
--- a/chromium/net/dns/mojo_host_resolver_impl.cc
+++ b/chromium/net/dns/mojo_host_resolver_impl.cc
@@ -6,7 +6,6 @@
 
 #include <utility>
 
-#include "base/stl_util.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
@@ -26,6 +25,8 @@ class MojoHostResolverImpl::Job {
       interfaces::HostResolverRequestClientPtr client);
   ~Job();
 
+  void set_iter(std::list<Job>::iterator iter) { iter_ = iter; }
+
   void Start();
 
  private:
@@ -36,6 +37,9 @@ class MojoHostResolverImpl::Job {
   void OnConnectionError();
 
   MojoHostResolverImpl* resolver_service_;
+  // This Job's iterator in |resolver_service_|, so the Job may be removed on
+  // completion.
+  std::list<Job>::iterator iter_;
   net::HostResolver* resolver_;
   net::HostResolver::RequestInfo request_info_;
   const NetLogWithSource net_log_;
@@ -51,7 +55,6 @@ MojoHostResolverImpl::MojoHostResolverImpl(net::HostResolver* resolver,
 
 MojoHostResolverImpl::~MojoHostResolverImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  base::STLDeleteElements(&pending_jobs_);
 }
 
 void MojoHostResolverImpl::Resolve(
@@ -64,17 +67,17 @@ void MojoHostResolverImpl::Resolve(
     // 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_.emplace_front(this, resolver_, *request_info, net_log_,
+                              std::move(client));
+  auto job = pending_jobs_.begin();
+  job->set_iter(job);
   job->Start();
 }
 
-void MojoHostResolverImpl::DeleteJob(Job* job) {
+void MojoHostResolverImpl::DeleteJob(std::list<Job>::iterator job) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  size_t num_erased = pending_jobs_.erase(job);
-  DCHECK(num_erased);
-  delete job;
+  pending_jobs_.erase(job);
 }
 
 MojoHostResolverImpl::Job::Job(
@@ -93,6 +96,9 @@ MojoHostResolverImpl::Job::Job(
 }
 
 void MojoHostResolverImpl::Job::Start() {
+  // The caller is responsible for setting up |iter_|.
+  DCHECK_EQ(this, &*iter_);
+
   DVLOG(1) << "Resolve " << request_info_.host_port_pair().ToString();
   int result =
       resolver_->Resolve(request_info_, DEFAULT_PRIORITY, &result_,
@@ -117,7 +123,7 @@ void MojoHostResolverImpl::Job::OnResolveDone(int result) {
     DVLOG(1) << address.ToString();
   }
   client_->ReportResult(result, result_);
-  resolver_service_->DeleteJob(this);
+  resolver_service_->DeleteJob(iter_);
 }
 
 void MojoHostResolverImpl::Job::OnConnectionError() {
@@ -126,7 +132,7 @@ void MojoHostResolverImpl::Job::OnConnectionError() {
   DCHECK(resolver_service_);
   DVLOG(1) << "Connection error on request for "
            << request_info_.host_port_pair().ToString();
-  resolver_service_->DeleteJob(this);
+  resolver_service_->DeleteJob(iter_);
 }
 
 }  // namespace net
diff --git a/chromium/net/dns/mojo_host_resolver_impl.h b/chromium/net/dns/mojo_host_resolver_impl.h
index 8c9eb48cc44..cdfa1c8a42d 100644
--- a/chromium/net/dns/mojo_host_resolver_impl.h
+++ b/chromium/net/dns/mojo_host_resolver_impl.h
@@ -5,7 +5,8 @@
 #ifndef NET_DNS_MOJO_HOST_RESOLVER_IMPL_H_
 #define NET_DNS_MOJO_HOST_RESOLVER_IMPL_H_
 
-#include <set>
+#include <list>
+#include <memory>
 
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
@@ -36,8 +37,8 @@ class MojoHostResolverImpl {
  private:
   class Job;
 
-  // Removes |job| from the set of pending jobs, and deletes it.
-  void DeleteJob(Job* job);
+  // Removes |job| from the set of pending jobs.
+  void DeleteJob(std::list<Job>::iterator job);
 
   // Resolver for resolving incoming requests. Not owned.
   net::HostResolver* resolver_;
@@ -46,8 +47,7 @@ class MojoHostResolverImpl {
   const NetLogWithSource net_log_;
 
   // All pending jobs, so they can be cancelled when this service is destroyed.
-  // Owns all jobs.
-  std::set<Job*> pending_jobs_;
+  std::list<Job> pending_jobs_;
 
   base::ThreadChecker thread_checker_;
 
diff --git a/chromium/net/dns/mojo_host_resolver_impl_unittest.cc b/chromium/net/dns/mojo_host_resolver_impl_unittest.cc
index 9405c71afb1..1b6722eddbe 100644
--- a/chromium/net/dns/mojo_host_resolver_impl_unittest.cc
+++ b/chromium/net/dns/mojo_host_resolver_impl_unittest.cc
@@ -8,6 +8,7 @@
 #include <string>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ -162,7 +163,7 @@ class MojoHostResolverImplTest : public testing::Test {
 
 TEST_F(MojoHostResolverImplTest, Resolve) {
   interfaces::HostResolverRequestClientPtr client_ptr;
-  TestRequestClient client(mojo::GetProxy(&client_ptr));
+  TestRequestClient client(mojo::MakeRequest(&client_ptr));
 
   resolver_service_->Resolve(CreateRequest("example.com", 80, false),
                              std::move(client_ptr));
@@ -176,7 +177,7 @@ TEST_F(MojoHostResolverImplTest, Resolve) {
 
 TEST_F(MojoHostResolverImplTest, ResolveSynchronous) {
   interfaces::HostResolverRequestClientPtr client_ptr;
-  TestRequestClient client(mojo::GetProxy(&client_ptr));
+  TestRequestClient client(mojo::MakeRequest(&client_ptr));
 
   mock_host_resolver_.set_synchronous_mode(true);
 
@@ -192,9 +193,9 @@ TEST_F(MojoHostResolverImplTest, ResolveSynchronous) {
 
 TEST_F(MojoHostResolverImplTest, ResolveMultiple) {
   interfaces::HostResolverRequestClientPtr client1_ptr;
-  TestRequestClient client1(mojo::GetProxy(&client1_ptr));
+  TestRequestClient client1(mojo::MakeRequest(&client1_ptr));
   interfaces::HostResolverRequestClientPtr client2_ptr;
-  TestRequestClient client2(mojo::GetProxy(&client2_ptr));
+  TestRequestClient client2(mojo::MakeRequest(&client2_ptr));
 
   mock_host_resolver_.set_ondemand_mode(true);
 
@@ -220,9 +221,9 @@ TEST_F(MojoHostResolverImplTest, ResolveMultiple) {
 
 TEST_F(MojoHostResolverImplTest, ResolveDuplicate) {
   interfaces::HostResolverRequestClientPtr client1_ptr;
-  TestRequestClient client1(mojo::GetProxy(&client1_ptr));
+  TestRequestClient client1(mojo::MakeRequest(&client1_ptr));
   interfaces::HostResolverRequestClientPtr client2_ptr;
-  TestRequestClient client2(mojo::GetProxy(&client2_ptr));
+  TestRequestClient client2(mojo::MakeRequest(&client2_ptr));
 
   mock_host_resolver_.set_ondemand_mode(true);
 
@@ -248,7 +249,7 @@ TEST_F(MojoHostResolverImplTest, ResolveDuplicate) {
 
 TEST_F(MojoHostResolverImplTest, ResolveFailure) {
   interfaces::HostResolverRequestClientPtr client_ptr;
-  TestRequestClient client(mojo::GetProxy(&client_ptr));
+  TestRequestClient client(mojo::MakeRequest(&client_ptr));
 
   resolver_service_->Resolve(CreateRequest("failure.fail", 80, false),
                              std::move(client_ptr));
@@ -261,7 +262,7 @@ TEST_F(MojoHostResolverImplTest, ResolveFailure) {
 TEST_F(MojoHostResolverImplTest, DestroyClient) {
   interfaces::HostResolverRequestClientPtr client_ptr;
   std::unique_ptr<TestRequestClient> client(
-      new TestRequestClient(mojo::GetProxy(&client_ptr)));
+      new TestRequestClient(mojo::MakeRequest(&client_ptr)));
 
   mock_host_resolver_.set_ondemand_mode(true);
 
diff --git a/chromium/net/dns/mojo_host_struct_traits.cc b/chromium/net/dns/mojo_host_struct_traits.cc
index 9772fd2c139..09f167323a1 100644
--- a/chromium/net/dns/mojo_host_struct_traits.cc
+++ b/chromium/net/dns/mojo_host_struct_traits.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "net/base/address_list.h"
 
 namespace mojo {
diff --git a/chromium/net/dns/serial_worker.cc b/chromium/net/dns/serial_worker.cc
index 8a715f37f83..7ac87cc0666 100644
--- a/chromium/net/dns/serial_worker.cc
+++ b/chromium/net/dns/serial_worker.cc
@@ -97,4 +97,3 @@ void SerialWorker::RetryWork() {
 }
 
 }  // namespace net
-
diff --git a/chromium/net/dns/serial_worker.h b/chromium/net/dns/serial_worker.h
index c48a61b1e26..14398a8ed0b 100644
--- a/chromium/net/dns/serial_worker.h
+++ b/chromium/net/dns/serial_worker.h
@@ -94,4 +94,3 @@ class NET_EXPORT_PRIVATE SerialWorker
 }  // namespace net
 
 #endif  // NET_DNS_SERIAL_WORKER_H_
-
diff --git a/chromium/net/dns/serial_worker_unittest.cc b/chromium/net/dns/serial_worker_unittest.cc
index 1c544db650a..1f940fefbaf 100644
--- a/chromium/net/dns/serial_worker_unittest.cc
+++ b/chromium/net/dns/serial_worker_unittest.cc
@@ -164,4 +164,3 @@ TEST_F(SerialWorkerTest, ExecuteAndSerializeReads) {
 }  // namespace
 
 }  // namespace net
-