Switch from OnIPAddressChanged and OnConnectionTypeChange to OnNetworkChanged

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"
@@ skipping 19 matching lines @@
 
   int notifications_count() const {
     return notifications_count_;
   }
 
  private:
   int notifications_count_;
 };
 
 class NetworkChangeNotifierObserver
-    : public NetworkChangeNotifier::ConnectionTypeObserver {
+    : public NetworkChangeNotifier::NetworkChangeObserver {
  public:
   NetworkChangeNotifierObserver() : notifications_count_(0) {}
 
-  // NetworkChangeNotifier::Observer:
-  virtual void OnConnectionTypeChanged(
+  // NetworkChangeNotifier::NetworkChangeObserver:
+  virtual void OnNetworkChanged(
       NetworkChangeNotifier::ConnectionType connection_type) OVERRIDE {
     notifications_count_++;
   }
 
   int notifications_count() const {
     return notifications_count_;
   }
 
  private:
   int notifications_count_;
 };
 
 }  // namespace
 
 class BaseNetworkChangeNotifierAndroidTest : public testing::Test {
  protected:
   typedef NetworkChangeNotifier::ConnectionType ConnectionType;
 
   virtual ~BaseNetworkChangeNotifierAndroidTest() {}
 
+  // |extra_online_notification| indicates
+  // NetworkChangeNotifier::OnNetworkChanged() is being tested, which produces
+  // two notifications when transitioning to an online state.
   void RunTest(
       const base::Callback<int(void)>& notifications_count_getter,
-      const base::Callback<ConnectionType(void)>&  connection_type_getter) {
+      const base::Callback<ConnectionType(void)>&  connection_type_getter,
+      bool extra_online_notification) {
     EXPECT_EQ(0, notifications_count_getter.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
               connection_type_getter.Run());
 
     // Changing from online to offline should trigger a notification.
     SetOffline();
     EXPECT_EQ(1, notifications_count_getter.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
               connection_type_getter.Run());
 
     // No notification should be triggered when the offline state hasn't
     // changed.
     SetOffline();
     EXPECT_EQ(1, notifications_count_getter.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
               connection_type_getter.Run());
 
     // Going from offline to online should trigger a notification.
     SetOnline();
-    EXPECT_EQ(2, notifications_count_getter.Run());
+    EXPECT_EQ(extra_online_notification ? 3 : 2,
+              notifications_count_getter.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
               connection_type_getter.Run());
   }
 
   void SetOnline() {
     delegate_.SetOnline();
     // Note that this is needed because ObserverListThreadSafe uses PostTask().
     MessageLoop::current()->RunUntilIdle();
   }
 
@@ skipping 55 matching lines @@
 // A testing-only observer is used here for testing. In production the
 // delegate's observers are instances of NetworkChangeNotifierAndroid.
 TEST_F(NetworkChangeNotifierDelegateAndroidTest, DelegateObserverNotified) {
   // Test the logic with a single observer.
   RunTest(
       base::Bind(
           &NetworkChangeNotifierDelegateAndroidObserver::notifications_count,
           base::Unretained(&delegate_observer_)),
       base::Bind(
           &NetworkChangeNotifierDelegateAndroid::GetCurrentConnectionType,
-          base::Unretained(&delegate_)));
+          base::Unretained(&delegate_)),
+      false);
   // Check that *all* the observers are notified. Both observers should have the
   // same state.
   EXPECT_EQ(delegate_observer_.notifications_count(),
             other_delegate_observer_.notifications_count());
 }
 
 class NetworkChangeNotifierAndroidTest
     : public BaseNetworkChangeNotifierAndroidTest {
  protected:
   NetworkChangeNotifierAndroidTest() : notifier_(&delegate_) {
-    NetworkChangeNotifier::AddConnectionTypeObserver(
-        &connection_type_observer_);
-    NetworkChangeNotifier::AddConnectionTypeObserver(
+    NetworkChangeNotifier::AddNetworkChangeObserver(&connection_type_observer_);
+    NetworkChangeNotifier::AddNetworkChangeObserver(
         &other_connection_type_observer_);
   }
 
   NetworkChangeNotifierObserver connection_type_observer_;
   NetworkChangeNotifierObserver other_connection_type_observer_;
   NetworkChangeNotifier::DisableForTest disable_for_test_;
   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_)));
+          base::Unretained(&notifier_)),
+      true);
 }
 
 // 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));
+      base::Bind(&NetworkChangeNotifier::GetConnectionType),
+      true);
   // Check that *all* the observers are notified.
   EXPECT_EQ(connection_type_observer_.notifications_count(),
             other_connection_type_observer_.notifications_count());
 }
 
 }  // namespace net