DNS: Add stubs for persisting data across restarts

net/dns/host_resolver_impl.cc

 // 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.
 
 #include "net/dns/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 481 matching lines @@
 };
 
 void MakeNotStale(HostCache::EntryStaleness* stale_info) {
   if (!stale_info)
     return;
   stale_info->expired_by = base::TimeDelta::FromSeconds(-1);
   stale_info->network_changes = 0;
   stale_info->stale_hits = 0;
 }
 
+// Persist data every five minutes (potentially, cache and learned RTT).
+const int64_t kPersistDelaySec = 300;
+
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 bool ResolveLocalHostname(base::StringPiece host,
                           uint16_t port,
                           AddressList* address_list) {
   address_list->clear();
 
   bool is_local6;
@@ skipping 1240 matching lines @@
     if (num_active_requests() == 0) {
       net_log_.AddEvent(NetLog::TYPE_CANCELLED);
       net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                         OK);
       return;
     }
 
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB,
                                       entry.error());
 
+    resolver_->SchedulePersist();
+
     DCHECK(!requests_.empty());
 
     if (entry.error() == OK) {
       // Record this histogram here, when we know the system has a valid DNS
       // configuration.
       UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HaveDnsConfig",
                             resolver_->received_dns_config_);
     }
 
     bool did_complete = (entry.error() != ERR_NETWORK_CHANGED) &&
@@ skipping 119 matching lines @@
   NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   NetworkChangeNotifier::RemoveDNSObserver(this);
 }
 
 void HostResolverImpl::SetMaxQueuedJobs(size_t value) {
   DCHECK_EQ(0u, dispatcher_->num_queued_jobs());
   DCHECK_GT(value, 0u);
   max_queued_jobs_ = value;
 }
 
+void HostResolverImpl::SetDnsClient(std::unique_ptr<DnsClient> dns_client) {

[Charlie Harrison, 2016/07/26 13:49:42]

Did this need to move?

[Julia Tuttle, 2016/07/26 21:10:13]

Nope.

+  // DnsClient and config must be updated before aborting DnsTasks, since doing
+  // so may start new jobs.
+  dns_client_ = std::move(dns_client);
+  if (dns_client_ && !dns_client_->GetConfig() &&
+      num_dns_failures_ < kMaximumDnsFailures) {
+    DnsConfig dns_config;
+    NetworkChangeNotifier::GetDnsConfig(&dns_config);
+    dns_client_->SetConfig(dns_config);
+    num_dns_failures_ = 0;
+    if (dns_client_->GetConfig())
+      UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
+  }
+
+  AbortDnsTasks();
+}
+
 int HostResolverImpl::Resolve(const RequestInfo& info,
                               RequestPriority priority,
                               AddressList* addresses,
                               const CompletionCallback& callback,
                               RequestHandle* out_req,
                               const BoundNetLog& source_net_log) {
   DCHECK(addresses);
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(false, callback.is_null());
 
@@ skipping 66 matching lines @@
       proc_params_(NULL, options.max_retry_attempts),
       net_log_(net_log),
       received_dns_config_(false),
       num_dns_failures_(0),
       use_local_ipv6_(false),
       last_ipv6_probe_result_(true),
       resolved_known_ipv6_hostname_(false),
       additional_resolver_flags_(0),
       fallback_to_proctask_(true),
       worker_task_runner_(std::move(worker_task_runner)),
+      persist_initialized_(false),
       weak_ptr_factory_(this),
       probe_weak_ptr_factory_(this) {
   if (options.enable_caching)
     cache_ = HostCache::CreateDefaultCache();
 
   PrioritizedDispatcher::Limits job_limits = options.GetDispatcherLimits();
   dispatcher_.reset(new PrioritizedDispatcher(job_limits));
   max_queued_jobs_ = job_limits.total_jobs * 100u;
 
   DCHECK_GE(dispatcher_->num_priorities(), static_cast<size_t>(NUM_PRIORITIES));
@@ skipping 534 matching lines @@
   dns_client_->SetConfig(DnsConfig());
 
   // Switch jobs with active DnsTasks over to using ProcTasks.
   AbortDnsTasks();
 
   UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", false);
   UMA_HISTOGRAM_SPARSE_SLOWLY("AsyncDNS.DnsClientDisabledReason",
                               std::abs(net_error));
 }
 
-void HostResolverImpl::SetDnsClient(std::unique_ptr<DnsClient> dns_client) {
-  // DnsClient and config must be updated before aborting DnsTasks, since doing
-  // so may start new jobs.
-  dns_client_ = std::move(dns_client);
-  if (dns_client_ && !dns_client_->GetConfig() &&
-      num_dns_failures_ < kMaximumDnsFailures) {
-    DnsConfig dns_config;
-    NetworkChangeNotifier::GetDnsConfig(&dns_config);
-    dns_client_->SetConfig(dns_config);
-    num_dns_failures_ = 0;
-    if (dns_client_->GetConfig())
-      UMA_HISTOGRAM_BOOLEAN("AsyncDNS.DnsClientEnabled", true);
-  }
+void HostResolverImpl::InitializePersistence(
+    const PersistCallback& persist_callback,
+    std::unique_ptr<const base::Value> old_data) {
+  DCHECK(!persist_initialized_);
+  persist_callback_ = persist_callback;
+  persist_initialized_ = true;
+  if (old_data)
+    ApplyPersistentData(std::move(old_data));
+}
 
-  AbortDnsTasks();
+void HostResolverImpl::SchedulePersist() {
+  if (!persist_initialized_ || persist_timer_.IsRunning())
+    return;
+  persist_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(kPersistDelaySec),
+      base::Bind(&HostResolverImpl::DoPersist, weak_ptr_factory_.GetWeakPtr()));
+}
+
+void HostResolverImpl::DoPersist() {
+  DCHECK(persist_initialized_);
+  persist_callback_.Run(GetPersistentData());
+}
+
+void HostResolverImpl::ApplyPersistentData(
+    std::unique_ptr<const base::Value> data) {}
+
+std::unique_ptr<const base::Value> HostResolverImpl::GetPersistentData() {
+  return std::unique_ptr<const base::Value>();
 }
 
 }  // namespace net