Avoid initial NetworkChangeNotifier OnDNSChanged() signal on Android

net/dns/dns_config_service_posix.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_posix.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_path_watcher.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_util.h"
 #include "net/dns/dns_hosts.h"
 #include "net/dns/dns_protocol.h"
@@ skipping 30 matching lines @@
  public:
   typedef base::Callback<void(bool succeeded)> CallbackType;
 
   bool Watch(const CallbackType& callback) {
     return false;
   }
 };
 
 #elif defined(OS_ANDROID)
 // On Android, assume DNS config may have changed on every network change.
-class DnsConfigWatcher : public NetworkChangeNotifier::NetworkChangeObserver {
+class DnsConfigWatcher {
  public:
-  DnsConfigWatcher() {
-    NetworkChangeNotifier::AddNetworkChangeObserver(this);
-  }
-
-  ~DnsConfigWatcher() override {
-    NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
-  }
-
   bool Watch(const base::Callback<void(bool succeeded)>& callback) {
     callback_ = callback;
     return true;
   }
 
-  void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) override {
+  void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) {
     if (!callback_.is_null() && type != NetworkChangeNotifier::CONNECTION_NONE)
       callback_.Run(true);
   }
 
  private:
   base::Callback<void(bool succeeded)> callback_;
 };
 #elif !defined(OS_MACOSX)
 // DnsConfigWatcher for OS_MACOSX is in dns_config_watcher_mac.{hh,cc}.
 
@@ skipping 107 matching lines @@
 
   return CONFIG_PARSE_POSIX_OK;
 }
 #endif
 
 }  // namespace
 
 class DnsConfigServicePosix::Watcher {
  public:
   explicit Watcher(DnsConfigServicePosix* service)
-      : service_(service),
-        weak_factory_(this) {}
+      : service_(service), weak_factory_(this) {}
   ~Watcher() {}
 
   bool Watch() {
     bool success = true;
     if (!config_watcher_.Watch(base::Bind(&Watcher::OnConfigChanged,
                                           base::Unretained(this)))) {
       LOG(ERROR) << "DNS config watch failed to start.";
       success = false;
       UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                                 DNS_CONFIG_WATCH_FAILED_TO_START_CONFIG,
                                 DNS_CONFIG_WATCH_MAX);
     }
-    if (!hosts_watcher_.Watch(base::FilePath(kFilePathHosts), false,
-                              base::Bind(&Watcher::OnHostsChanged,
-                                         base::Unretained(this)))) {
+    if (!hosts_watcher_.Watch(
+            base::FilePath(service_->file_path_hosts_), false,
+            base::Bind(&Watcher::OnHostsChanged, base::Unretained(this)))) {
       LOG(ERROR) << "DNS hosts watch failed to start.";
       success = false;
       UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                                 DNS_CONFIG_WATCH_FAILED_TO_START_HOSTS,
                                 DNS_CONFIG_WATCH_MAX);
     }
     return success;
   }
 
+#if defined(OS_ANDROID)
+  void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) {
+    config_watcher_.OnNetworkChanged(type);
+  }
+#endif  // defined(OS_ANDROID)
+
  private:
   void OnConfigChanged(bool succeeded) {
+#if defined(OS_ANDROID)
+    service_->seen_config_change_ = true;
+#endif  // defined(OS_ANDROID)
     // Ignore transient flutter of resolv.conf by delaying the signal a bit.
     const base::TimeDelta kDelay = base::TimeDelta::FromMilliseconds(50);
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&Watcher::OnConfigChangedDelayed,
                    weak_factory_.GetWeakPtr(),
                    succeeded),
         kDelay);
   }
   void OnConfigChangedDelayed(bool succeeded) {
@@ skipping 16 matching lines @@
 // it to DnsConfig (except on Android, where it reads system properties
 // net.dns1 and net.dns2; see #if around ReadDnsConfig above.)
 class DnsConfigServicePosix::ConfigReader : public SerialWorker {
  public:
   explicit ConfigReader(DnsConfigServicePosix* service)
       : service_(service), success_(false) {}
 
   void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     ConfigParsePosixResult result = ReadDnsConfig(&dns_config_);
+    if (service_->dns_config_for_testing_) {
+      dns_config_ = *service_->dns_config_for_testing_;
+      result = CONFIG_PARSE_POSIX_OK;
+    }
     switch (result) {
       case CONFIG_PARSE_POSIX_MISSING_OPTIONS:
       case CONFIG_PARSE_POSIX_UNHANDLED_OPTIONS:
         DCHECK(dns_config_.unhandled_options);
         // Fall through.
       case CONFIG_PARSE_POSIX_OK:
         success_ = true;
         break;
       default:
         success_ = false;
@@ skipping 23 matching lines @@
   DnsConfig dns_config_;
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(ConfigReader);
 };
 
 // A SerialWorker that reads the HOSTS file and runs Callback.
 class DnsConfigServicePosix::HostsReader : public SerialWorker {
  public:
   explicit HostsReader(DnsConfigServicePosix* service)
-      :  service_(service), path_(kFilePathHosts), success_(false) {}
+      : service_(service), success_(false) {}
 
  private:
   ~HostsReader() override {}
 
   void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
-    success_ = ParseHostsFile(path_, &hosts_);
+    success_ =
+        ParseHostsFile(base::FilePath(service_->file_path_hosts_), &hosts_);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostParseResult", success_);
     UMA_HISTOGRAM_TIMES("AsyncDNS.HostsParseDuration",
                         base::TimeTicks::Now() - start_time);
   }
 
   void OnWorkFinished() override {
     if (success_) {
       service_->OnHostsRead(hosts_);
     } else {
       LOG(WARNING) << "Failed to read DnsHosts.";
     }
   }
 
   DnsConfigServicePosix* service_;
-  const base::FilePath path_;
   // Written in DoWork, read in OnWorkFinished, no locking necessary.
   DnsHosts hosts_;
   bool success_;
 
   DISALLOW_COPY_AND_ASSIGN(HostsReader);
 };
 
 DnsConfigServicePosix::DnsConfigServicePosix()
-    : config_reader_(new ConfigReader(this)),
-      hosts_reader_(new HostsReader(this)) {}
+    : file_path_hosts_(kFilePathHosts),
+      dns_config_for_testing_(nullptr),
+      config_reader_(new ConfigReader(this)),
+      hosts_reader_(new HostsReader(this))
+#if defined(OS_ANDROID)
+      ,
+      seen_config_change_(false)
+#endif  // defined(OS_ANDROID)
+{
+}
 
 DnsConfigServicePosix::~DnsConfigServicePosix() {
   config_reader_->Cancel();
   hosts_reader_->Cancel();
 }
 
 void DnsConfigServicePosix::ReadNow() {
   config_reader_->WorkNow();
   hosts_reader_->WorkNow();
 }
@@ skipping 25 matching lines @@
     hosts_reader_->WorkNow();
   } else {
     LOG(ERROR) << "DNS hosts watch failed.";
     set_watch_failed(true);
     UMA_HISTOGRAM_ENUMERATION("AsyncDNS.WatchStatus",
                               DNS_CONFIG_WATCH_FAILED_HOSTS,
                               DNS_CONFIG_WATCH_MAX);
   }
 }
 
+void DnsConfigServicePosix::SetDnsConfigForTesting(
+    const DnsConfig* dns_config) {
+  DCHECK(CalledOnValidThread());
+  dns_config_for_testing_ = dns_config;
+}
+
 #if !defined(OS_ANDROID)
 ConfigParsePosixResult ConvertResStateToDnsConfig(const struct __res_state& res,
                                                   DnsConfig* dns_config) {
   CHECK(dns_config != NULL);
   if (!(res.options & RES_INIT))
     return CONFIG_PARSE_POSIX_RES_INIT_UNSET;
 
   dns_config->nameservers.clear();
 
 #if defined(OS_MACOSX) || defined(OS_FREEBSD)
@@ skipping 87 matching lines @@
 
   // If any name server is 0.0.0.0, assume the configuration is invalid.
   // TODO(szym): Measure how often this happens. http://crbug.com/125599
   const IPAddressNumber kEmptyAddress(kIPv4AddressSize);
   for (unsigned i = 0; i < dns_config->nameservers.size(); ++i) {
     if (dns_config->nameservers[i].address() == kEmptyAddress)
       return CONFIG_PARSE_POSIX_NULL_ADDRESS;
   }
   return CONFIG_PARSE_POSIX_OK;
 }
-#endif  // !defined(OS_ANDROID)
+
+#else   // defined(OS_ANDROID)
+
+bool DnsConfigServicePosix::SeenChangeSince(
+    const base::Time& since_time) const {
+  DCHECK(CalledOnValidThread());
+  if (seen_config_change_)
+    return true;
+  base::File hosts(base::FilePath(file_path_hosts_),
+                   base::File::FLAG_OPEN | base::File::FLAG_READ);
+  base::File::Info hosts_info;
+  // File last modified times are not nearly as accurate as Time::Now() and are
+  // rounded down.  This means a file modified at 1:23.456 might only
+  // be given a last modified time of 1:23.450.  If we compared the last
+  // modified time directly to |since_time| we might miss changes to the hosts
+  // file because of this rounding down.  To account for this the |since_time|
+  // is pushed back by 1s which should more than account for any rounding.
+  // In practice file modified times on Android are two orders of magnitude
+  // more accurate than this 1s.  In practice the hosts file on Android always
+  // contains "127.0.0.1 localhost" and is never modified after Android is
+  // installed.
+  return !hosts.GetInfo(&hosts_info) ||
+         hosts_info.last_modified >=
+             (since_time - base::TimeDelta::FromSeconds(1));
+}
+
+void DnsConfigServicePosix::OnNetworkChanged(
+    NetworkChangeNotifier::ConnectionType type) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(watcher_);
+  watcher_->OnNetworkChanged(type);
+}
+#endif  // defined(OS_ANDROID)
 
 }  // namespace internal
 
 // static
 scoped_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return scoped_ptr<DnsConfigService>(new internal::DnsConfigServicePosix());
 }
 
 }  // namespace net