Add a Dns preresolve interface in //content

content/browser/loader/resource_hints_controller.cc

Index: content/browser/loader/resource_hints_controller.cc
diff --git a/content/browser/loader/resource_hints_controller.cc b/content/browser/loader/resource_hints_controller.cc
new file mode 100644
index 0000000000000000000000000000000000000000..50f4aec9f2598f4401d7210c376058b443067326
--- /dev/null
+++ b/content/browser/loader/resource_hints_controller.cc
@@ -0,0 +1,55 @@
+// Copyright 2016 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/loader/resource_hints_controller.h"
+
+#include "base/memory/ptr_util.h"
+#include "content/public/browser/resource_context.h"
+#include "net/base/address_list.h"
+#include "net/dns/host_resolver.h"
+#include "net/dns/single_request_host_resolver.h"
+#include "net/url_request/url_request_context.h"
+
+namespace content {
+
+struct ResourceHintsController::DnsRequest {
+  explicit DnsRequest(net::HostResolver* resolver);
+  net::SingleRequestHostResolver resolver;
+  net::AddressList addresses;
+};
+
+ResourceHintsController::DnsRequest::DnsRequest(
+    net::HostResolver* host_resolver)
+    : resolver(host_resolver) {}
+
+ResourceHintsController::ResourceHintsController() {}
+
+ResourceHintsController::~ResourceHintsController() {}
+
+int ResourceHintsController::PreresolveUrl(
+    content::ResourceContext* resource_context,
+    const GURL& url,
+    const net::CompletionCallback& callback) {
+  DCHECK(resource_context);
+  std::unique_ptr<DnsRequest> request =
+      base::WrapUnique(new DnsRequest(resource_context->GetHostResolver()));
+  net::HostResolver::RequestInfo resolve_info(net::HostPortPair::FromURL(url));

[Charlie Harrison, 2016/05/24 13:14:22]

Make sure we set this to be speculative.

+  return request->resolver.Resolve(
+      resolve_info, net::IDLE, &request->addresses,
+      base::Bind(&ResourceHintsController::OnResolveComplete,
+                 base::Unretained(this), base::Passed(std::move(request)),

[kinuko, 2016/05/24 09:15:27]

ditto, how is it guaranteed that calling OnResolveComplete on |this| is always
safe?

[Charlie Harrison, 2016/05/24 13:14:22]

I think it might not be. The host resolver is destroyed when the IO thread is
destroyed, but the RDHI is Shutdown() right before that. I can add some safety
by picking this off the RDHI global.

[Charlie Harrison, 2016/05/24 16:06:36]

Actually, we don't actually need the controller here, just the callback. I've
changed this to be a static method.

+                 callback),
+      net::BoundNetLog());
+}
+
+void ResourceHintsController::OnResolveComplete(
+    std::unique_ptr<DnsRequest> request,
+    const net::CompletionCallback& callback,
+    int result) {
+  // Plumb the resolution result into the callback if future consumers want that
+  // information.
+  callback.Run(result);
+}
+
+}  // namespace content