Async DNS: Don't watch hosts file 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 <memory>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 43 matching lines @@
 class DnsConfigWatcher {
  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:
   bool Watch(const base::Callback<void(bool succeeded)>& callback) {
     callback_ = callback;
     return true;
   }
 
   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)
+
+#elif defined(OS_MACOSX)
+
 // DnsConfigWatcher for OS_MACOSX is in dns_config_watcher_mac.{hh,cc}.
 
+#else  // !defined(OS_IOS) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
+
 #ifndef _PATH_RESCONF  // Normally defined in <resolv.h>
 #define _PATH_RESCONF "/etc/resolv.conf"
 #endif
 
 static const base::FilePath::CharType* kFilePathConfig =
     FILE_PATH_LITERAL(_PATH_RESCONF);
 
 class DnsConfigWatcher {
  public:
   typedef base::Callback<void(bool succeeded)> CallbackType;
 
   bool Watch(const CallbackType& callback) {
     callback_ = callback;
     return watcher_.Watch(base::FilePath(kFilePathConfig), false,
                           base::Bind(&DnsConfigWatcher::OnCallback,
                                      base::Unretained(this)));
   }
 
  private:
   void OnCallback(const base::FilePath& path, bool error) {
     callback_.Run(!error);
   }
 
   base::FilePathWatcher watcher_;
   CallbackType callback_;
 };
+
 #endif
 
 #if !defined(OS_ANDROID)
 ConfigParsePosixResult ReadDnsConfig(DnsConfig* config) {
   ConfigParsePosixResult result;
   config->unhandled_options = false;
 #if defined(OS_OPENBSD)
   // Note: res_ninit in glibc always returns 0 and sets RES_INIT.
   // res_init behaves the same way.
   memset(&_res, 0, sizeof(_res));
@@ skipping 84 matching lines @@
   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 !defined(OS_IOS)
+// Hosts file should never change on Android or iOS (and watching it on Android
+// is problematic; see http://crbug.com/600442), so don't watch it there.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
     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);
     }
-#endif
+#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
     return success;
   }
 
 #if defined(OS_ANDROID)
   void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) {
     config_watcher_.OnNetworkChanged(type);
   }
 #endif  // defined(OS_ANDROID)
 
  private:
@@ skipping 10 matching lines @@
   }
   void OnConfigChangedDelayed(bool succeeded) {
     service_->OnConfigChanged(succeeded);
   }
   void OnHostsChanged(const base::FilePath& path, bool error) {
     service_->OnHostsChanged(!error);
   }
 
   DnsConfigServicePosix* service_;
   DnsConfigWatcher config_watcher_;
-#if !defined(OS_IOS)
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
   base::FilePathWatcher hosts_watcher_;
-#endif
+#endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
   base::WeakPtrFactory<Watcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Watcher);
 };
 
 // A SerialWorker that uses libresolv to initialize res_state and converts
 // 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 {
@@ skipping 280 matching lines @@
       return CONFIG_PARSE_POSIX_NULL_ADDRESS;
   }
   return CONFIG_PARSE_POSIX_OK;
 }
 
 #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));
+  return seen_config_change_;
 }
 
 void DnsConfigServicePosix::OnNetworkChanged(
     NetworkChangeNotifier::ConnectionType type) {
   DCHECK(CalledOnValidThread());
   DCHECK(watcher_);
   watcher_->OnNetworkChanged(type);
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace internal
 
 // static
 std::unique_ptr<DnsConfigService> DnsConfigService::CreateSystemService() {
   return std::unique_ptr<DnsConfigService>(
       new internal::DnsConfigServicePosix());
 }
 
 }  // namespace net