Add a Dns preresolve interface in //content

content/browser/loader/resource_hints_impl.cc

Index: content/browser/loader/resource_hints_impl.cc
diff --git a/content/browser/loader/resource_hints_impl.cc b/content/browser/loader/resource_hints_impl.cc
index 694947881e67296fa2fa2d6ebdb829da9de7eedb..55b4833f140f0ab5463bfecaa1f49f0aa0dc6e6a 100644
--- a/content/browser/loader/resource_hints_impl.cc
+++ b/content/browser/loader/resource_hints_impl.cc
@@ -2,30 +2,46 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/public/browser/resource_hints.h"
-
+#include "base/memory/ptr_util.h"
+#include "base/memory/ref_counted.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_context.h"
+#include "content/public/browser/resource_hints.h"
+#include "net/base/address_list.h"
 #include "net/base/load_flags.h"
+#include "net/dns/host_resolver.h"
+#include "net/dns/single_request_host_resolver.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/url_request/http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
 
 namespace content {
 
-void PreconnectUrl(net::URLRequestContextGetter* getter,
+namespace {
+
+void OnResolveComplete(std::unique_ptr<net::SingleRequestHostResolver> request,
+                       const net::CompletionCallback& callback,
+                       int result) {
+  // Plumb the resolution result into the callback if future consumers want
+  // that information.
+  callback.Run(result);
+}
+
+}  // namespace
+
+void PreconnectUrl(content::ResourceContext* resource_context,
                    const GURL& url,
                    const GURL& first_party_for_cookies,
                    int count,
                    bool allow_credentials,
                    net::HttpRequestInfo::RequestMotivation motivation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(getter);
+  DCHECK(resource_context);
 
-  net::URLRequestContext* context = getter->GetURLRequestContext();
+  net::URLRequestContext* context = resource_context->GetRequestContext();
   net::HttpTransactionFactory* factory = context->http_transaction_factory();
   net::HttpNetworkSession* session = factory->GetSession();
 
@@ -57,4 +73,20 @@ void PreconnectUrl(net::URLRequestContextGetter* getter,
   http_stream_factory->PreconnectStreams(count, request_info);
 }
 
+int PreresolveUrl(content::ResourceContext* resource_context,
+                  const GURL& url,
+                  const net::CompletionCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(resource_context);
+
+  net::SingleRequestHostResolver* resolver =
+      new net::SingleRequestHostResolver(resource_context->GetHostResolver());
+  net::HostResolver::RequestInfo resolve_info(net::HostPortPair::FromURL(url));
+  return resolver->Resolve(
+      resolve_info, net::IDLE, nullptr,

[eroman, 2016/05/31 20:45:27]

I would rather not introduce the concept of a null result int
SingleRequestHostResolver.

In part because I want to remove SingleRequestHostResolver [1], so any deviation
from the HostResolver API will just cause problems during that migration.

Instead how about binding the result lifetime to the callback, as in:

AddressList* addresses = new AddressList;

return resolver->Resolve(
  resolve_info, net::IDLE, addresses,
  base::Bind(&OnResolveComplete, base::Passed(base::WrapUnique(resolver)),
base::Owned(addresses), callback)

Kind of annoying to express this pattern with a std::unique_ptr<> +
base::Passed() because of undefined argument evaluation order of C++, so for the
example above just did the raw pointer version.

[1] https://bugs.chromium.org/p/chromium/issues/detail?id=486264

[Charlie Harrison, 2016/05/31 21:14:47]

Done. Thanks for the suggestion.

+      base::Bind(&OnResolveComplete, base::Passed(base::WrapUnique(resolver)),
+                 callback),
+      net::BoundNetLog());
+}
+
 }  // namespace content