Add a Dns preresolve interface in //content

content/browser/loader/resource_hints_impl.cc

 // 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 "base/memory/ptr_util.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_hints.h"
-
-#include "content/public/browser/browser_thread.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 {
+
+struct DnsRequest {
+  explicit DnsRequest(net::HostResolver* resolver) : resolver(resolver) {}
+  net::SingleRequestHostResolver resolver;
+  net::AddressList addresses;
+};
+
+void 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
+
+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);
+  if (!resource_context)
+    return;
 
-  net::URLRequestContext* context = getter->GetURLRequestContext();
+  net::URLRequestContext* context = resource_context->GetRequestContext();
   net::HttpTransactionFactory* factory = context->http_transaction_factory();
   net::HttpNetworkSession* session = factory->GetSession();
 
   std::string user_agent;
   if (context->http_user_agent_settings())
     user_agent = context->http_user_agent_settings()->GetUserAgent();
   net::HttpRequestInfo request_info;
   request_info.url = url;
   request_info.method = "GET";
   request_info.extra_headers.SetHeader(net::HttpRequestHeaders::kUserAgent,
@@ skipping 11 matching lines @@
     request_info.privacy_mode = net::PRIVACY_MODE_ENABLED;
     request_info.load_flags = net::LOAD_DO_NOT_SEND_COOKIES |
                               net::LOAD_DO_NOT_SAVE_COOKIES |
                               net::LOAD_DO_NOT_SEND_AUTH_DATA;
   }
 
   net::HttpStreamFactory* http_stream_factory = session->http_stream_factory();
   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);
+  if (!resource_context)
+    return net::ERR_FAILED;

[kinuko, 2016/05/25 23:25:18]

This could happen.. in some tests?  DCHECK's not sufficient?

[Charlie Harrison, 2016/05/26 00:46:56]

I was thinking of just relaxing the constraints of the public interface. I don't
think any consumers provide null contexts, so I'll just change these back to
DCHECKs.

+  std::unique_ptr<DnsRequest> request =
+      base::WrapUnique(new DnsRequest(resource_context->GetHostResolver()));
+  net::HostResolver::RequestInfo resolve_info(net::HostPortPair::FromURL(url));
+  return request->resolver.Resolve(
+      resolve_info, net::IDLE, &request->addresses,
+      base::Bind(&OnResolveComplete, base::Passed(std::move(request)),
+                 callback),
+      net::BoundNetLog());
+}
+
 }  // namespace content