Add a Dns preresolve interface in //content

chrome/browser/net/predictor.h

 // Copyright (c) 2012 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.
 
 // A Predictor object is instantiated once in the browser process, and manages
 // both preresolution of hostnames, as well as TCP/IP preconnection to expected
 // subresources.
 // Most hostname lists are provided by the renderer processes, and include URLs
 // that *might* be used in the near future by the browsing user.  One goal of
 // this class is to cause the underlying DNS structure to lookup a hostname
 // before it is really needed, and hence reduce latency in the standard lookup
 // paths.
 // Subresource relationships are usually acquired from the referrer field in a
 // navigation.  A subresource URL may be associated with a referrer URL.  Later
 // navigations may, if the likelihood of needing the subresource is high enough,
 // cause this module to speculatively create a TCP/IP connection. If there is
 // only a low likelihood, then a DNS pre-resolution operation may be performed.
 
 #ifndef CHROME_BROWSER_NET_PREDICTOR_H_
 #define CHROME_BROWSER_NET_PREDICTOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
-#include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/net/referrer.h"
 #include "chrome/browser/net/timed_cache.h"
 #include "chrome/browser/net/url_info.h"
@@ skipping 233 matching lines @@
   // instigated this activity.
   void PredictFrameSubresources(const GURL& url,
                                 const GURL& first_party_for_cookies);
 
   // Put URL in canonical form, including a scheme, host, and port.
   // Returns GURL::EmptyGURL() if the scheme is not http/https or if the url
   // cannot be otherwise canonicalized.
   static GURL CanonicalizeUrl(const GURL& url);
 
   // Used for testing.
-  void SetHostResolver(net::HostResolver* host_resolver) {
-    host_resolver_ = host_resolver;
-  }
-  // Used for testing.
   void SetTransportSecurityState(
       net::TransportSecurityState* transport_security_state) {
     transport_security_state_ = transport_security_state;
   }
   // Used for testing.
   size_t max_concurrent_dns_lookups() const {
     return max_concurrent_dns_lookups_;
   }
   // Used for testing.
   void SetShutdown(bool shutdown) {
@@ skipping 29 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, SingleLookupTestWithDisabledAdvisor);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, SingleLookupTestWithEnabledAdvisor);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, TestSimplePreconnectAdvisor);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, NoProxyService);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, ProxyDefinitelyEnabled);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, ProxyDefinitelyNotEnabled);
   FRIEND_TEST_ALL_PREFIXES(PredictorTest, ProxyMaybeEnabled);
   friend class WaitForResolutionHelper;  // For testing.
   friend class PredictorBrowserTest;
 
-  class LookupRequest;
-
   // A simple priority queue for handling host names.
   // Some names that are queued up have |motivation| that requires very rapid
   // handling.  For example, a sub-resource name lookup MUST be done before the
   // actual sub-resource is fetched.  In contrast, a name that was speculatively
   // noted in a page has to be resolved before the user "gets around to"
   // clicking on a link.  By tagging (with a motivation) each push we make into
   // this FIFO queue, the queue can re-order the more important names to service
   // them sooner (relative to some low priority background resolutions).
   class HostNameQueue {
    public:
@@ skipping 81 matching lines @@
 
   // ------------- Start IO thread methods.
 
   // Perform actual resolution or preconnection to subresources now.  This is
   // an internal worker method that is reached via a post task from
   // PredictFrameSubresources().
   void PrepareFrameSubresources(const GURL& url,
                                 const GURL& first_party_for_cookies);
 
   // Access method for use by async lookup request to pass resolution result.
-  void OnLookupFinished(LookupRequest* request, const GURL& url, bool found);
+  void OnLookupFinished(const GURL& url, int result);
 
   // Underlying method for both async and synchronous lookup to update state.
-  void LookupFinished(LookupRequest* request,
-                      const GURL& url, bool found);
+  void LookupFinished(const GURL& url, bool found);
 
   // Queue hostname for resolution.  If queueing was done, return the pointer

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

nit: Queue --> Queues (feel free to save that for another CL)

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

Done.

-  // to the queued instance, otherwise return NULL. If the proxy advisor is
+  // to the queued instance, otherwise return nullptr. If the proxy advisor is
   // enabled, and |url| is likely to be proxied, the hostname will not be
   // queued as the browser is not expected to fetch it directly.
   UrlInfo* AppendToResolutionQueue(const GURL& url,
                                    UrlInfo::ResolutionMotivation motivation);
 
   // Check to see if too much queuing delay has been noted for the given info,
   // which indicates that there is "congestion" or growing delay in handling the
   // resolution of names.  Rather than letting this congestion potentially grow
   // without bounds, we abandon our queued efforts at pre-resolutions in such a
   // case.
@@ skipping 54 matching lines @@
   // This is set by InitNetworkPredictor and used for calling
   // CanPrefetchAndPrerenderIO and CanPreresolveAndPreconnectIO.
   ProfileIOData* profile_io_data_;
 
   // work_queue_ holds a list of names we need to look up.
   HostNameQueue work_queue_;
 
   // results_ contains information for existing/prior prefetches.
   Results results_;
 
-  std::set<LookupRequest*> pending_lookups_;
+  size_t num_pending_lookups_;
 
   // For testing, to verify that we don't exceed the limit.
   size_t peak_pending_lookups_;
 
   // When true, we don't make new lookup requests.
   bool shutdown_;
 
   // The number of concurrent speculative lookups currently allowed to be sent
   // to the resolver.  Any additional lookups will be queued to avoid exceeding
   // this value.  The queue is a priority queue that will accelerate
   // sub-resource speculation, and retard resolutions suggested by page scans.
   const size_t max_concurrent_dns_lookups_;
 
   // The maximum queueing delay that is acceptable before we enter congestion
   // reduction mode, and discard all queued (but not yet assigned) resolutions.
   const base::TimeDelta max_dns_queue_delay_;
 
-  // The host resolver we warm DNS entries for.
-  net::HostResolver* host_resolver_;
-
   // The TransportSecurityState instance we query HSTS redirects from.
   net::TransportSecurityState* transport_security_state_;
 
   // The SSLConfigService we query SNI support from (used in querying HSTS
   // redirects).
   net::SSLConfigService* ssl_config_service_;
 
   // The ProxyService, used to determine whether preresolve is useful.
   net::ProxyService* proxy_service_;
 
@@ skipping 54 matching lines @@
 
  private:
   // These member functions return True for unittests.
   bool CanPrefetchAndPrerender() const override;
   bool CanPreresolveAndPreconnect() const override;
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_PREDICTOR_H_