| // 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. |
| |
| #ifndef COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_ |
| #define COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_ |
| |
| #include <unordered_set> |
| |
| #include "net/dns/host_resolver.h" |
| #include "net/dns/host_resolver_impl.h" |
| |
| namespace cronet { |
| |
| // A HostResolver that wraps a HostResolverImpl and uses it to make requests, |
| // but "impatiently" returns stale data (if available and usable) after a delay, |
| // to reduce DNS latency at the expense of accuracy. |
| class NET_EXPORT StaleHostResolver : public net::HostResolver { |
| public: |
| struct NET_EXPORT StaleOptions { |
| StaleOptions(); |
| |
| // How long to wait before returning stale data, if available. |
| base::TimeDelta delay; |
| |
| // If positive, how long stale data can be past the expiration time before |
| // it's considered unusable. If zero or negative, stale data can be used |
| // indefinitely. |
| base::TimeDelta max_expired_time; |
| |
| // If set, stale data from previous networks is usable; if clear, it's not. |
| // |
| // If the other network had a working, correct DNS setup, this can increase |
| // the availability of useful stale results. |
| // |
| // If the other network had a broken (e.g. hijacked for captive portal) DNS |
| // setup, this will instead end up returning useless results. |
| bool allow_other_network; |
| |
| // If positive, the maximum number of times a stale entry can be used. If |
| // zero, there is no limit. |
| int max_stale_uses; |
| }; |
| |
| // Creates a StaleHostResolver that uses |inner_resolver| for actual |
| // resolution, but potentially returns stale data according to |
| // |stale_options|. |
| StaleHostResolver(std::unique_ptr<net::HostResolverImpl> inner_resolver, |
| const StaleOptions& stale_options); |
| |
| ~StaleHostResolver() override; |
| |
| // HostResolver implementation: |
| |
| // Resolves as a regular HostResolver, but if stale data is available and |
| // usable (according to the options passed to the constructor), and fresh data |
| // is not returned before the specified delay, returns the stale data instead. |
| // |
| // If stale data is returned, the StaleHostResolver allows the underlying |
| // request to continue in order to repopulate the cache. |
| int Resolve(const RequestInfo& info, |
| net::RequestPriority priority, |
| net::AddressList* addresses, |
| const net::CompletionCallback& callback, |
| std::unique_ptr<Request>* out_req, |
| const net::NetLogWithSource& net_log) override; |
| |
| // The remaining public methods pass through to the inner resolver: |
| |
| int ResolveFromCache(const RequestInfo& info, |
| net::AddressList* addresses, |
| const net::NetLogWithSource& net_log) override; |
| void SetDnsClientEnabled(bool enabled) override; |
| net::HostCache* GetHostCache() override; |
| std::unique_ptr<base::Value> GetDnsConfigAsValue() const override; |
| |
| private: |
| class RequestImpl; |
| |
| // Called from |Request| when a request is complete and can be destroyed. |
| void OnRequestComplete(Request* request); |
| |
| // The underlying HostResolverImpl that will be used to make cache and network |
| // requests. |
| std::unique_ptr<net::HostResolverImpl> inner_resolver_; |
| |
| // Options that govern when a stale response can or can't be returned. |
| StaleOptions options_; |
| |
| DISALLOW_COPY_AND_ASSIGN(StaleHostResolver); |
| }; |
| |
| } // namespace cronet |
| |
| #endif // COMPONENTS_CRONET_STALE_HOST_RESOLVER_H_ |