net: Add fuzzer for HostResolverImpl.

net/dns/host_resolver_impl.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.
 
 #ifndef NET_DNS_HOST_RESOLVER_IMPL_H_
 #define NET_DNS_HOST_RESOLVER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 14 matching lines @@
 namespace net {
 
 class AddressList;
 class BoundNetLog;
 class DnsClient;
 class IPAddress;
 class NetLog;
 
 // For each hostname that is requested, HostResolver creates a
 // HostResolverImpl::Job. When this job gets dispatched it creates a ProcTask
-// which runs the given HostResolverProc on a WorkerPool thread. If requests for
-// that same host are made during the job's lifetime, they are attached to the
-// existing job rather than creating a new one. This avoids doing parallel
-// resolves for the same host.
+// which runs the given HostResolverProc on a worker thread (a WorkerPool
+// thread, in production code.) If requests for that same host are made during
+// the job's lifetime, they are attached to the existing job rather than
+// creating a new one. This avoids doing parallel resolves for the same host.
 //
 // The way these classes fit together is illustrated by:
 //
 //
 //            +----------- HostResolverImpl -------------+
 //            |                    |                     |
 //           Job                  Job                   Job
 //    (for host1, fam1)    (for host2, fam2)     (for hostx, famx)
 //       /    |   |            /   |   |             /   |   |
 //   Request ... Request  Request ... Request   Request ... Request
@@ skipping 12 matching lines @@
 class NET_EXPORT HostResolverImpl
     : public HostResolver,
       NON_EXPORTED_BASE(public base::NonThreadSafe),
       public NetworkChangeNotifier::IPAddressObserver,
       public NetworkChangeNotifier::ConnectionTypeObserver,
       public NetworkChangeNotifier::DNSObserver {
  public:
   // Parameters for ProcTask which resolves hostnames using HostResolveProc.
   //
   // |resolver_proc| is used to perform the actual resolves; it must be
-  // thread-safe since it is run from multiple worker threads. If
+  // thread-safe since it may be run from multiple worker threads. If
   // |resolver_proc| is NULL then the default host resolver procedure is
   // used (which is SystemHostResolverProc except if overridden).
   //
   // For each attempt, we could start another attempt if host is not resolved
   // within |unresponsive_delay| time. We keep attempting to resolve the host
   // for |max_retry_attempts|. For every retry attempt, we grow the
   // |unresponsive_delay| by the |retry_factor| amount (that is retry interval
   // is multiplied by the retry factor each time). Once we have retried
   // |max_retry_attempts|, we give up on additional attempts.
   //
@@ skipping 14 matching lines @@
     size_t max_retry_attempts;
 
     // This is the limit after which we make another attempt to resolve the host
     // if the worker thread has not responded yet.
     base::TimeDelta unresponsive_delay;
 
     // Factor to grow |unresponsive_delay| when we re-re-try.
     uint32_t retry_factor;
   };
 
-  // Creates a HostResolver as specified by |options|.
+  // Creates a HostResolver as specified by |options|. Blocking tasks are run on
+  // the WorkerPool.
   //
   // If Options.enable_caching is true, a cache is created using
   // HostCache::CreateDefaultCache(). Otherwise no cache is used.
   //
   // Options.GetDispatcherLimits() determines the maximum number of jobs that
   // the resolver will run at once. This upper-bounds the total number of
   // outstanding DNS transactions (not counting retransmissions and retries).
   //
   // |net_log| must remain valid for the life of the HostResolverImpl.
   HostResolverImpl(const Options& options, NetLog* net_log);
@@ skipping 27 matching lines @@
                              RequestPriority priority) override;
   void CancelRequest(RequestHandle req) override;
   void SetDnsClientEnabled(bool enabled) override;
   HostCache* GetHostCache() override;
   std::unique_ptr<base::Value> GetDnsConfigAsValue() const override;
 
   void set_proc_params_for_test(const ProcTaskParams& proc_params) {
     proc_params_ = proc_params;
   }
 
+ protected:
+  // Just like the public constructor, but allows the task runner used for
+  // blocking tasks to be specified. Intended for testing only.
+  HostResolverImpl(const Options& options,
+                   NetLog* net_log,
+                   scoped_refptr<base::TaskRunner> worker_task_runner);
+
+  // Callback from HaveOnlyLoopbackAddresses probe.
+  void SetHaveOnlyLoopbackAddresses(bool result);
+
  private:
   friend class HostResolverImplTest;
   class Job;
   class ProcTask;
   class LoopbackProbeJob;
   class DnsTask;
   class Request;
   typedef HostCache::Key Key;
   typedef std::map<Key, Job*> JobMap;
 
@@ skipping 33 matching lines @@
   bool ServeFromHosts(const Key& key,
                       const RequestInfo& info,
                       AddressList* addresses);
 
   // If |key| is for a localhost name (RFC 6761), returns true and fills
   // |addresses| with the loopback IP. Otherwise returns false.
   bool ServeLocalhost(const Key& key,
                       const RequestInfo& info,
                       AddressList* addresses);
 
-  // Callback from HaveOnlyLoopbackAddresses probe.
-  void SetHaveOnlyLoopbackAddresses(bool result);
-
   // Returns the (hostname, address_family) key to use for |info|, choosing an
   // "effective" address family by inheriting the resolver's default address
   // family when the request leaves it unspecified.
   Key GetEffectiveKeyForRequest(const RequestInfo& info,
                                 const IPAddress* ip_address,
                                 const BoundNetLog& net_log);
 
   // Probes IPv6 support and returns true if IPv6 support is enabled.
   // Results are cached, i.e. when called repeatedly this method returns result
   // from the first probe for some time before probing again.
   virtual bool IsIPv6Reachable(const BoundNetLog& net_log);
 
+  // Asynchronously checks if only loopback IPs are available.
+  virtual void RunLoopbackProbeJob();
+
   // Records the result in cache if cache is present.
   void CacheResult(const Key& key,
                    const HostCache::Entry& entry,
                    base::TimeDelta ttl);
 
   // Removes |job| from |jobs_|, only if it exists.
   void RemoveJob(Job* job);
 
   // Aborts all in progress jobs with ERR_NETWORK_CHANGED and notifies their
   // requests. Might start new jobs.
@@ skipping 72 matching lines @@
   // True iff ProcTask has successfully resolved a hostname known to have IPv6
   // addresses using ADDRESS_FAMILY_UNSPECIFIED. Reset on IP address change.
   bool resolved_known_ipv6_hostname_;
 
   // Any resolver flags that should be added to a request by default.
   HostResolverFlags additional_resolver_flags_;
 
   // Allow fallback to ProcTask if DnsTask fails.
   bool fallback_to_proctask_;
 
+  // Task runner used for DNS lookups using the platform resolver, and other
+  // blocking operations. Usually just the WorkerPool's task runner for slow
+  // tasks, but can be overridden for tests.
+  scoped_refptr<base::TaskRunner> worker_task_runner_;
+
   base::WeakPtrFactory<HostResolverImpl> weak_ptr_factory_;
 
   base::WeakPtrFactory<HostResolverImpl> probe_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HostResolverImpl);
 };
 
 // Resolves a local hostname (such as "localhost" or "localhost6") into
 // IP endpoints with the given port. Returns true if |host| is a local
 // hostname and false otherwise. Special IPv6 names (e.g. "localhost6")
 // will resolve to an IPv6 address only, whereas other names will
 // resolve to both IPv4 and IPv6.
 // This function is only exposed so it can be unit-tested.
 // TODO(tfarina): It would be better to change the tests so this function
 // gets exercised indirectly through HostResolverImpl.
 NET_EXPORT_PRIVATE bool ResolveLocalHostname(base::StringPiece host,
                                              uint16_t port,
                                              AddressList* address_list);
 
 }  // namespace net
 
 #endif  // NET_DNS_HOST_RESOLVER_IMPL_H_