DNS: Add stubs for persisting data across restarts

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>
 
 #include <map>
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/time/time.h"
+#include "base/timer/timer.h"
 #include "net/base/net_export.h"
 #include "net/base/network_change_notifier.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/host_resolver_proc.h"
 
 namespace net {
 
 class AddressList;
 class BoundNetLog;
@@ skipping 120 matching lines @@
   std::unique_ptr<base::Value> GetDnsConfigAsValue() const override;
 
   // Like |ResolveFromCache()|, but can return a stale result if the
   // implementation supports it. Fills in |*stale_info| if a response is
   // returned to indicate how stale (or not) it is.
   int ResolveStaleFromCache(const RequestInfo& info,
                             AddressList* addresses,
                             HostCache::EntryStaleness* stale_info,
                             const BoundNetLog& source_net_log);
 
+  void InitializePersistence(
+      const PersistCallback& persist_callback,
+      std::unique_ptr<const base::Value> old_data) 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);
@@ skipping 121 matching lines @@
 
   void UpdateDNSConfig(bool config_changed);
 
   // True if have a DnsClient with a valid DnsConfig.
   bool HaveDnsConfig() const;
 
   // Called when a host name is successfully resolved and DnsTask was run on it
   // and resulted in |net_error|.
   void OnDnsTaskResolve(int net_error);
 
+  void SchedulePersist();
+  void DoPersist();
+
+  void ApplyPersistentData(std::unique_ptr<const base::Value>);
+  std::unique_ptr<const base::Value> GetPersistentData();
+
   // Allows the tests to catch slots leaking out of the dispatcher.  One
   // HostResolverImpl::Job could occupy multiple PrioritizedDispatcher job
   // slots.
   size_t num_running_dispatcher_jobs_for_tests() const {
     return dispatcher_->num_running_jobs();
   }
 
   // Cache of host resolution results.
   std::unique_ptr<HostCache> cache_;
 
@@ skipping 36 matching lines @@
   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_;
 
+  bool persist_initialized_;
+  PersistCallback persist_callback_;
+  base::OneShotTimer persist_timer_;
+
   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_