Refactor NetworkChangeNotifierAndroid

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/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 163 matching lines @@
 
   ChangeType last_change_type_;
   NetworkChangeNotifier::NetworkHandle last_network_changed_;
 };
 
 }  // namespace
 
 class BaseNetworkChangeNotifierAndroidTest : public testing::Test {
  protected:
   typedef NetworkChangeNotifier::ConnectionType ConnectionType;
+  typedef NetworkChangeNotifier::ConnectionSubtype ConnectionSubtype;
 
   ~BaseNetworkChangeNotifierAndroidTest() override {}
 
   void RunTest(
       const base::Callback<int(void)>& notifications_count_getter,
       const base::Callback<ConnectionType(void)>&  connection_type_getter) {
     EXPECT_EQ(0, notifications_count_getter.Run());
     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
               connection_type_getter.Run());
 
@@ skipping 23 matching lines @@
     // PostTask().
     base::RunLoop().RunUntilIdle();
   }
 
   void SetOffline() {
     delegate_.SetOffline();
     // See comment above.
     base::RunLoop().RunUntilIdle();
   }
 
-  void FakeMaxBandwidthChange(double max_bandwidth_mbps) {
-    delegate_.FakeMaxBandwidthChanged(max_bandwidth_mbps);
+  void FakeConnectionSubtypeChange(ConnectionSubtype subtype) {
+    delegate_.FakeConnectionSubtypeChanged(subtype);
     base::RunLoop().RunUntilIdle();
   }
 
   void FakeNetworkChange(ChangeType change,
                          NetworkChangeNotifier::NetworkHandle network,
                          ConnectionType type) {
     switch (change) {
       case CONNECTED:
         delegate_.FakeNetworkConnected(network, type);
         break;
@@ skipping 150 matching lines @@
   SetOffline();
   notifier_->GetMaxBandwidthAndConnectionType(&max_bandwidth_mbps,
                                               &connection_type);
   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE, connection_type);
   EXPECT_EQ(0.0, max_bandwidth_mbps);
 }
 
 TEST_F(NetworkChangeNotifierDelegateAndroidTest, MaxBandwidthCallbackNotifier) {
   // The bandwidth notification should always be forwarded, even if the value
   // doesn't change (because the type might have changed).
-  FakeMaxBandwidthChange(100.0);
+  FakeConnectionSubtypeChange(ConnectionSubtype::SUBTYPE_CDMA);
   EXPECT_EQ(1, delegate_observer_.bandwidth_notifications_count());
   EXPECT_EQ(1, max_bandwidth_observer_.notifications_count());
 
-  FakeMaxBandwidthChange(100.0);
+  FakeConnectionSubtypeChange(ConnectionSubtype::SUBTYPE_CDMA);
   EXPECT_EQ(2, delegate_observer_.bandwidth_notifications_count());
   EXPECT_EQ(2, max_bandwidth_observer_.notifications_count());
 
-  FakeMaxBandwidthChange(101.0);
+  FakeConnectionSubtypeChange(ConnectionSubtype::SUBTYPE_LTE);
   EXPECT_EQ(3, delegate_observer_.bandwidth_notifications_count());
   EXPECT_EQ(3, max_bandwidth_observer_.notifications_count());
 }
 
 TEST_F(NetworkChangeNotifierDelegateAndroidTest,
        MaxBandwidthNotifiedOnConnectionChange) {
   EXPECT_EQ(0, delegate_observer_.bandwidth_notifications_count());
   SetOffline();
   EXPECT_EQ(1, delegate_observer_.bandwidth_notifications_count());
   SetOnline();
@@ skipping 102 matching lines @@
   NetworkChangeNotifier::GetConnectedNetworks(&network_list);
   EXPECT_EQ(1u, network_list.size());
   EXPECT_EQ(100, network_list[0]);
   EXPECT_EQ(NetworkChangeNotifier::kInvalidNetworkHandle,
             NetworkChangeNotifier::GetDefaultNetwork());
 
   NetworkChangeNotifier::RemoveNetworkObserver(&network_observer);
 }
 
 }  // namespace net