Update the type and cost of existing networks if its type is found later by network monitor

webrtc/base/network_unittest.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 16 matching lines @@
 namespace rtc {
 
 namespace {
 
 class FakeNetworkMonitor : public NetworkMonitorBase {
  public:
   void Start() override { started_ = true; }
   void Stop() override { started_ = false; }
   bool started() { return started_; }
   AdapterType GetAdapterType(const std::string& if_name) override {
+    // Note that the name matching rules are different from the
+    // GetAdapterTypeFromName in NetworkManager.
+    if (if_name.find("wifi") == 0) {
+      return ADAPTER_TYPE_WIFI;
+    }
+    if (if_name.find("cellular") == 0) {
+      return ADAPTER_TYPE_CELLULAR;
+    }
     return ADAPTER_TYPE_UNKNOWN;
   }
 
  private:
   bool started_ = false;
 };
 
 class FakeNetworkMonitorFactory : public NetworkMonitorFactory {
  public:
   FakeNetworkMonitorFactory() {}
@@ skipping 48 matching lines @@
         network_manager.network_monitor_.get());
   }
   void ClearNetworks(BasicNetworkManager& network_manager) {
     for (const auto& kv : network_manager.networks_map_) {
       delete kv.second;
     }
     network_manager.networks_.clear();
     network_manager.networks_map_.clear();
   }
 
+  AdapterType GetAdapterType(BasicNetworkManager& network_manager) {
+    BasicNetworkManager::NetworkList list;
+    network_manager.GetNetworks(&list);
+    ASSERT(list.size() == 1u);
+    return list[0]->type();
+  }
+
 #if defined(WEBRTC_POSIX)
   // Separated from CreateNetworks for tests.
   static void CallConvertIfAddrs(const BasicNetworkManager& network_manager,
                                  struct ifaddrs* interfaces,
                                  bool include_ignored,
                                  NetworkManager::NetworkList* networks) {
     // Use the base IfAddrsConverter for test cases.
     std::unique_ptr<IfAddrsConverter> ifaddrs_converter(new IfAddrsConverter());
     network_manager.ConvertIfAddrs(interfaces, ifaddrs_converter.get(),
                                    include_ignored, networks);
@@ skipping 22 matching lines @@
     if_addr->ifa_name = if_name;
     if_addr->ifa_addr = reinterpret_cast<struct sockaddr*>(
         CreateIpv6Addr(ipv6_address, scope_id));
     if_addr->ifa_netmask =
         reinterpret_cast<struct sockaddr*>(CreateIpv6Addr(ipv6_netmask, 0));
     if_addr->ifa_next = list;
     if_addr->ifa_flags = IFF_RUNNING;
     return if_addr;
   }
 
+  struct ifaddrs* InstallIpv6Network(char* if_name,
+                                     const std::string& ipv6_address,
+                                     const std::string& ipv6_mask,
+                                     BasicNetworkManager& network_manager) {
+    ifaddrs* addr_list = nullptr;
+    addr_list = AddIpv6Address(addr_list, if_name, ipv6_address, ipv6_mask, 0);
+    NetworkManager::NetworkList result;
+    bool changed;
+    NetworkManager::Stats stats;
+    CallConvertIfAddrs(network_manager, addr_list, true, &result);
+    network_manager.MergeNetworkList(result, &changed, &stats);
+    return addr_list;
+  }
+
   void ReleaseIfAddrs(struct ifaddrs* list) {
     struct ifaddrs* if_addr = list;
     while (if_addr != nullptr) {
       struct ifaddrs* next_addr = if_addr->ifa_next;
       delete if_addr->ifa_addr;
       delete if_addr->ifa_netmask;
       delete if_addr;
       if_addr = next_addr;
     }
   }
@@ skipping 617 matching lines @@
   sockaddr ifa_addr;
   sockaddr ifa_netmask;
   list.ifa_addr = &ifa_addr;
   list.ifa_netmask = &ifa_netmask;
 
   NetworkManager::NetworkList result;
   BasicNetworkManager manager;
   CallConvertIfAddrs(manager, &list, true, &result);
   EXPECT_TRUE(result.empty());
 }
+
+// Tests that the network type can be updated after the network monitor is
+// started.
+TEST_F(NetworkTest, TestGetAdapterTypeFromNetworkMonitor) {
+  char if_name1[20] = "wifi0";
+  std::string ipv6_address1 = "1000:2000:3000:4000:0:0:0:1";
+  std::string ipv6_address2 = "1000:2000:3000:8000:0:0:0:1";
+  std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::";
+  BasicNetworkManager manager;
+  // A network created before the network monitor is not started will get
+  // UNKNOWN type.
+  ifaddrs* addr_list =
+      InstallIpv6Network(if_name1, ipv6_address1, ipv6_mask, manager);
+  EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, GetAdapterType(manager));
+  ReleaseIfAddrs(addr_list);
+  // Note: do not call ClearNetworks here to check that an existing network

[pthatcher1, 2016/05/17 21:23:11]

do => Do

[honghaiz3, 2016/05/18 07:41:46]

Done.

+  // will be updated.

[pthatcher1, 2016/05/17 21:23:11]

Why not?  It could use some explanation.

[honghaiz3, 2016/05/18 07:41:47]

Added explanations.

+
+  // After the network monitor starts, the type will be updated.
+  FakeNetworkMonitorFactory* factory = new FakeNetworkMonitorFactory();
+  NetworkMonitorFactory::SetFactory(factory);
+  // This brings up the hook with the network monitor.
+  manager.StartUpdating();
+  // Add the same ipv6 address as before but it has the right network type
+  // inferred from the network monitor now.
+  addr_list = InstallIpv6Network(if_name1, ipv6_address1, ipv6_mask, manager);
+
+  EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager));
+  ReleaseIfAddrs(addr_list);
+  ClearNetworks(manager);
+
+  // Add another network with the type inferred from the network monitor.
+  char if_name2[20] = "cellular0";
+  addr_list = InstallIpv6Network(if_name2, ipv6_address2, ipv6_mask, manager);
+  EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
+  ReleaseIfAddrs(addr_list);
+  ClearNetworks(manager);
+}
+
+// Test that the network type can be determined based on name matching in
+// a few cases. Note that UNKNOW type for non-matching strings has been tested

[pthatcher1, 2016/05/17 21:23:11]

UNKNOW => UNKNOWN

[honghaiz3, 2016/05/18 07:41:46]

Done.

+// in the above test.
+TEST_F(NetworkTest, TestGetAdapterTypeFromNameMatching) {
+  std::string ipv6_address1 = "1000:2000:3000:4000:0:0:0:1";
+  std::string ipv6_address2 = "1000:2000:3000:8000:0:0:0:1";
+  std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::";
+  BasicNetworkManager manager;
+
+#if defined(WEBRTC_IOS)
+  char if_name[20] = "pdp_ip0";
+  ifaddrs* addr_list =
+      InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
+
+  EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
+  ClearNetworks(manager);
+  ReleaseIfAddrs(addr_list);
+
+#elif defined(WEBRTC_ANDROID)
+  char if_name[20] = "rmnet0";
+  ifaddrs* addr_list =
+      InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
+
+  EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
+  ClearNetworks(manager);
+  ReleaseIfAddrs(addr_list);
+
+  strcpy(if_name, "wlan1");
+  addr_list = InstallIpv6Network(if_name, ipv6_address2, ipv6_mask, manager);
+  EXPECT_EQ(ADAPTER_TYPE_WIFI, GetAdapterType(manager));
+  ClearNetworks(manager);
+  ReleaseIfAddrs(addr_list);
+
+  strcpy(if_name, "v4-rmnet_data0");
+  addr_list = InstallIpv6Network(if_name, ipv6_address2, ipv6_mask, manager);
+  EXPECT_EQ(ADAPTER_TYPE_CELLULAR, GetAdapterType(manager));
+  ClearNetworks(manager);
+  ReleaseIfAddrs(addr_list);
+#else
+  char if_name[20] = "wlan0";
+  ifaddrs* addr_list =
+      InstallIpv6Network(if_name, ipv6_address1, ipv6_mask, manager);
+
+  EXPECT_EQ(ADAPTER_TYPE_UNKNOWN, GetAdapterType(manager));
+  ClearNetworks(manager);
+  ReleaseIfAddrs(addr_list);
+#endif
+}
 #endif  // defined(WEBRTC_POSIX)
 
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
 // If you want to test non-default routes, you can do the following on a linux
 // machine:
 // 1) Load the dummy network driver:
 // sudo modprobe dummy
 // sudo ifconfig dummy0 127.0.0.1
 // 2) Run this test and confirm the output says it found a dummy route (and
 // passes).
@@ skipping 239 matching lines @@
   // If the set default address is in a network, GetDefaultLocalAddress will
   // return the best IP in that network.
   manager.set_default_local_addresses(GetLoopbackIP(AF_INET), ip2);
   EXPECT_TRUE(manager.GetDefaultLocalAddress(AF_INET6, &ip));
   EXPECT_EQ(static_cast<IPAddress>(ip1), ip);
 
   manager.StopUpdating();
 }
 
 }  // namespace rtc