Avoid initial NetworkChangeNotifier OnDNSChanged() signal on Android

net/android/network_change_notifier_android_unittest.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.
 
 // See network_change_notifier_android.h for design explanations.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "net/android/network_change_notifier_android.h"
 #include "net/android/network_change_notifier_delegate_android.h"
 #include "net/base/network_change_notifier.h"
+#include "net/dns/dns_config_service.h"
+#include "net/dns/dns_protocol.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class NetworkChangeNotifierDelegateAndroidObserver
     : public NetworkChangeNotifierDelegateAndroid::Observer {
  public:
   NetworkChangeNotifierDelegateAndroidObserver()
@@ skipping 28 matching lines @@
   }
 
   int notifications_count() const {
     return notifications_count_;
   }
 
  private:
   int notifications_count_;
 };
 
+class DNSChangeObserver : public NetworkChangeNotifier::DNSObserver {
+ public:
+  DNSChangeObserver()
+      : change_notifications_count_(0), initial_notifications_count_(0) {}
+
+  // NetworkChangeNotifier::DNSObserver:
+  void OnDNSChanged() override { change_notifications_count_++; }
+
+  void OnInitialDNSConfigRead() override {
+    initial_notifications_count_++;
+    base::MessageLoop::current()->Quit();
+  }
+
+  int change_notifications_count() const { return change_notifications_count_; }
+
+  int initial_notifications_count() const {
+    return initial_notifications_count_;
+  }
+
+ private:
+  int change_notifications_count_;
+  int initial_notifications_count_;
+};
+
 }  // namespace
 
 class BaseNetworkChangeNotifierAndroidTest : public testing::Test {
  protected:
   typedef NetworkChangeNotifier::ConnectionType ConnectionType;
 
   ~BaseNetworkChangeNotifierAndroidTest() override {}
 
   void RunTest(
       const base::Callback<int(void)>& notifications_count_getter,
@@ skipping 95 matching lines @@
               base::Unretained(&delegate_)));
   // Check that *all* the observers are notified. Both observers should have the
   // same state.
   EXPECT_EQ(delegate_observer_.type_notifications_count(),
             other_delegate_observer_.type_notifications_count());
 }
 
 class NetworkChangeNotifierAndroidTest
     : public BaseNetworkChangeNotifierAndroidTest {
  protected:
-  NetworkChangeNotifierAndroidTest() : notifier_(&delegate_) {
+  void SetUp() override {
+    IPAddressNumber dns_number;
+    ASSERT_TRUE(ParseIPLiteralToNumber("8.8.8.8", &dns_number));
+    dns_config_.nameservers.push_back(
+        IPEndPoint(dns_number, dns_protocol::kDefaultPort));
+    notifier_.reset(new NetworkChangeNotifierAndroid(&delegate_, &dns_config_));
     NetworkChangeNotifier::AddConnectionTypeObserver(
         &connection_type_observer_);
     NetworkChangeNotifier::AddConnectionTypeObserver(
         &other_connection_type_observer_);
   }
 
   NetworkChangeNotifierObserver connection_type_observer_;
   NetworkChangeNotifierObserver other_connection_type_observer_;
   NetworkChangeNotifier::DisableForTest disable_for_test_;
-  NetworkChangeNotifierAndroid notifier_;
+  DnsConfig dns_config_;
+  scoped_ptr<NetworkChangeNotifierAndroid> notifier_;
 };
 
 // When a NetworkChangeNotifierAndroid is observing a
 // NetworkChangeNotifierDelegateAndroid for network state changes, and the
 // NetworkChangeNotifierDelegateAndroid's connectivity state changes, the
 // NetworkChangeNotifierAndroid should reflect that state.
 TEST_F(NetworkChangeNotifierAndroidTest,
        NotificationsSentToNetworkChangeNotifierAndroid) {
-  RunTest(
-      base::Bind(
-          &NetworkChangeNotifierObserver::notifications_count,
-          base::Unretained(&connection_type_observer_)),
-      base::Bind(
-          &NetworkChangeNotifierAndroid::GetCurrentConnectionType,
-          base::Unretained(&notifier_)));
+  RunTest(base::Bind(&NetworkChangeNotifierObserver::notifications_count,
+                     base::Unretained(&connection_type_observer_)),
+          base::Bind(&NetworkChangeNotifierAndroid::GetCurrentConnectionType,
+                     base::Unretained(notifier_.get())));
 }
 
 // When a NetworkChangeNotifierAndroid's connection state changes, it should
 // notify all of its observers.
 TEST_F(NetworkChangeNotifierAndroidTest,
        NotificationsSentToClientsOfNetworkChangeNotifier) {
   RunTest(
       base::Bind(
           &NetworkChangeNotifierObserver::notifications_count,
           base::Unretained(&connection_type_observer_)),
       base::Bind(&NetworkChangeNotifier::GetConnectionType));
   // Check that *all* the observers are notified.
   EXPECT_EQ(connection_type_observer_.notifications_count(),
             other_connection_type_observer_.notifications_count());
 }
 
 TEST_F(NetworkChangeNotifierAndroidTest, MaxBandwidth) {
   SetOnline();
   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
-            notifier_.GetConnectionType());
+            notifier_->GetConnectionType());
   EXPECT_EQ(std::numeric_limits<double>::infinity(),
-            notifier_.GetMaxBandwidth());
+            notifier_->GetMaxBandwidth());
   SetOffline();
   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
-            notifier_.GetConnectionType());
-  EXPECT_EQ(0.0, notifier_.GetMaxBandwidth());
+            notifier_->GetConnectionType());
+  EXPECT_EQ(0.0, notifier_->GetMaxBandwidth());
 }
 
 TEST_F(NetworkChangeNotifierDelegateAndroidTest,
        MaxBandwidthNotifiedOnConnectionChange) {
   EXPECT_EQ(0, delegate_observer_.bandwidth_notifications_count());
   SetOffline();
   EXPECT_EQ(1, delegate_observer_.bandwidth_notifications_count());
   SetOnline();
   EXPECT_EQ(2, delegate_observer_.bandwidth_notifications_count());
   SetOnline();
   EXPECT_EQ(2, delegate_observer_.bandwidth_notifications_count());
 }
 
+TEST_F(NetworkChangeNotifierAndroidTest, InitialSignal) {
+  DNSChangeObserver dns_change_observer;
+  NetworkChangeNotifier::AddDNSObserver(&dns_change_observer);
+  base::MessageLoop::current()->Run();
+  EXPECT_EQ(1, dns_change_observer.initial_notifications_count());
+  EXPECT_EQ(0, dns_change_observer.change_notifications_count());
+  NetworkChangeNotifier::RemoveDNSObserver(&dns_change_observer);
+}
+
 }  // namespace net