Avoid initial NetworkChangeNotifier OnDNSChanged() signal on Android

net/android/network_change_notifier_android.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.
 
 ////////////////////////////////////////////////////////////////////////////////
 // Threading considerations:
 //
 // This class is designed to meet various threading guarantees starting from the
 // ones imposed by NetworkChangeNotifier:
 // - The notifier can be constructed on any thread.
@@ skipping 43 matching lines @@
 // state change, and notifies each of its observers on their threads.
 //
 // This can also be seen as:
 // Android platform -> NetworkChangeNotifier (Java) ->
 // NetworkChangeNotifierDelegateAndroid -> NetworkChangeNotifierAndroid.
 
 #include "net/android/network_change_notifier_android.h"
 
 #include "base/threading/thread.h"
 #include "net/base/address_tracker_linux.h"
-#include "net/dns/dns_config_service.h"
+#include "net/dns/dns_config_service_posix.h"
 
 namespace net {
 
 // Thread on which we can run DnsConfigService, which requires a TYPE_IO
 // message loop to monitor /system/etc/hosts.
 class NetworkChangeNotifierAndroid::DnsConfigServiceThread
-    : public base::Thread {
+    : public base::Thread,
+      public NetworkChangeNotifier::NetworkChangeObserver {
  public:
-  DnsConfigServiceThread()
+  DnsConfigServiceThread(const DnsConfig* dns_config_for_testing)
       : base::Thread("DnsConfigService"),
+        dns_config_for_testing_(dns_config_for_testing),
+        creation_time_(base::Time::Now()),
         address_tracker_(base::Bind(base::DoNothing),
                          base::Bind(base::DoNothing),
                          // We're only interested in tunnel interface changes.
                          base::Bind(NotifyNetworkChangeNotifierObservers)) {}
 
-  ~DnsConfigServiceThread() override { Stop(); }
+  ~DnsConfigServiceThread() override {
+    NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
+    Stop();
+  }
+
+  void InitAfterStart() {
+    DCHECK(IsRunning());
+    NetworkChangeNotifier::AddNetworkChangeObserver(this);
+  }
 
   void Init() override {
     address_tracker_.Init();
-    dns_config_service_ = DnsConfigService::CreateSystemService();
+    dns_config_service_.reset(new internal::DnsConfigServicePosix());
+    if (dns_config_for_testing_)
+      dns_config_service_->SetDnsConfigForTesting(dns_config_for_testing_);
     dns_config_service_->WatchConfig(
-        base::Bind(&NetworkChangeNotifier::SetDnsConfig));
+        base::Bind(&DnsConfigServiceThread::DnsConfigChangeCallback,
+                   base::Unretained(this)));
   }
 
   void CleanUp() override { dns_config_service_.reset(); }
 
   static void NotifyNetworkChangeNotifierObservers() {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChange();
     NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange();
   }
 
  private:
-  scoped_ptr<DnsConfigService> dns_config_service_;
+  void DnsConfigChangeCallback(const DnsConfig& config) {
+    DCHECK(task_runner()->BelongsToCurrentThread());
+    if (dns_config_service_->SeenChangeSince(creation_time_)) {
+      NetworkChangeNotifier::SetDnsConfig(config);
+    } else {
+      NetworkChangeNotifier::SetInitialDnsConfig(config);
+    }
+  }
+
+  // NetworkChangeNotifier::NetworkChangeObserver implementation:
+  void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type) override {
+    task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&internal::DnsConfigServicePosix::OnNetworkChanged,
+                   base::Unretained(dns_config_service_.get()), type));
+  }
+
+  const DnsConfig* dns_config_for_testing_;
+  const base::Time creation_time_;
+  scoped_ptr<internal::DnsConfigServicePosix> dns_config_service_;
   // Used to detect tunnel state changes.
   internal::AddressTrackerLinux address_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsConfigServiceThread);
 };
 
 NetworkChangeNotifierAndroid::~NetworkChangeNotifierAndroid() {
   delegate_->RemoveObserver(this);
 }
 
@@ skipping 15 matching lines @@
   NetworkChangeNotifier::NotifyObserversOfMaxBandwidthChange(
       max_bandwidth_mbps);
 }
 
 // static
 bool NetworkChangeNotifierAndroid::Register(JNIEnv* env) {
   return NetworkChangeNotifierDelegateAndroid::Register(env);
 }
 
 NetworkChangeNotifierAndroid::NetworkChangeNotifierAndroid(
-    NetworkChangeNotifierDelegateAndroid* delegate)
+    NetworkChangeNotifierDelegateAndroid* delegate,
+    const DnsConfig* dns_config_for_testing)
     : NetworkChangeNotifier(NetworkChangeCalculatorParamsAndroid()),
       delegate_(delegate),
-      dns_config_service_thread_(new DnsConfigServiceThread()) {
+      dns_config_service_thread_(
+          new DnsConfigServiceThread(dns_config_for_testing)) {
   delegate_->AddObserver(this);
   dns_config_service_thread_->StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
+  dns_config_service_thread_->InitAfterStart();
 }
 
 // static
 NetworkChangeNotifier::NetworkChangeCalculatorParams
 NetworkChangeNotifierAndroid::NetworkChangeCalculatorParamsAndroid() {
   NetworkChangeCalculatorParams params;
   // IPAddressChanged is produced immediately prior to ConnectionTypeChanged
   // so delay IPAddressChanged so they get merged with the following
   // ConnectionTypeChanged signal.
   params.ip_address_offline_delay_ = base::TimeDelta::FromSeconds(1);
   params.ip_address_online_delay_ = base::TimeDelta::FromSeconds(1);
   params.connection_type_offline_delay_ = base::TimeDelta::FromSeconds(0);
   params.connection_type_online_delay_ = base::TimeDelta::FromSeconds(0);
   return params;
 }
 
 }  // namespace net