[net/dns] Suppress multiple DnsConfig withdrawals after timeout.

net/dns/dns_config_service.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/dns_config_service.h"
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 
@@ skipping 57 matching lines @@
   dict->SetBoolean("edns0", edns0);
   dict->SetInteger("num_hosts", hosts.size());
 
   return dict;
 }
 
 
 DnsConfigService::DnsConfigService()
     : have_config_(false),
       have_hosts_(false),
-      need_update_(false) {}
+      need_update_(false),
+      last_sent_empty_(true) {}
 
 DnsConfigService::~DnsConfigService() {
   // Must always clean up.
   NetworkChangeNotifier::RemoveDNSObserver(this);
 }
 
 void DnsConfigService::Read(const CallbackType& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
   DCHECK(callback_.is_null());
@@ skipping 50 matching lines @@
     need_update_ = true;
   }
 
   have_hosts_ = true;
   if (have_config_)
     OnCompleteConfig();
 }
 
 void DnsConfigService::StartTimer() {
   DCHECK(CalledOnValidThread());
+  if (last_sent_empty_) {
+    DCHECK(!timer_.IsRunning());
+    return;  // No need to withdraw again.
+  }
   timer_.Stop();
 
   // Give it a short timeout to come up with a valid config. Otherwise withdraw
   // the config from the receiver. The goal is to avoid perceivable network
   // outage (when using the wrong config) but at the same time avoid
   // unnecessary Job aborts in HostResolverImpl. The signals come from multiple
   // sources so it might receive multiple events during a config change.
 
   // DHCP and user-induced changes are on the order of seconds, so 100ms should
   // not add perceivable delay. On the other hand, config readers should finish
   // within 100ms with the rare exception of I/O block or extra large HOSTS.
   const base::TimeDelta kTimeout = base::TimeDelta::FromMilliseconds(100);
 
   timer_.Start(FROM_HERE,
                kTimeout,
                this,
                &DnsConfigService::OnTimeout);
 }
 
 void DnsConfigService::OnTimeout() {
   DCHECK(CalledOnValidThread());
+  DCHECK(!last_sent_empty_);
   // Indicate that even if there is no change in On*Read, we will need to
   // update the receiver when the config becomes complete.
   need_update_ = true;
   // Empty config is considered invalid.
+  last_sent_empty_ = true;
   callback_.Run(DnsConfig());
 }
 
 void DnsConfigService::OnCompleteConfig() {
   timer_.Stop();
-  if (need_update_) {
-    need_update_ = false;
-    callback_.Run(dns_config_);
-  }
+  if (!need_update_)
+    return;
+  need_update_ = false;
+  last_sent_empty_ = false;
+  callback_.Run(dns_config_);
 }
 
 }  // namespace net