Fix CreateNetworks to stop it from signaling duplicate networks changed events

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 72 matching lines @@
   }
 
 #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) {
     network_manager.ConvertIfAddrs(interfaces, include_ignored, networks);
   }
+
+  struct sockaddr_in6* CreateIpv6Addr(const std::string& ip_string,
+                                      uint32_t scope_id) {
+    struct sockaddr_in6* ipv6_addr = new struct sockaddr_in6;
+    memset(ipv6_addr, 0, sizeof(struct sockaddr_in6));
+    ipv6_addr->sin6_family = AF_INET6;
+    ipv6_addr->sin6_scope_id = scope_id;
+    IPAddress ip;
+    IPFromString(ip_string, &ip);
+    ipv6_addr->sin6_addr = ip.ipv6_address();
+    return ipv6_addr;
+  }
+
+  // Pointers created here need to be released via ReleaseIfAddrs.
+  struct ifaddrs* AddIpv6Address(struct ifaddrs* list,
+                                 char* if_name,
+                                 const std::string& ipv6_address,
+                                 const std::string& ipv6_netmask,
+                                 uint32_t scope_id) {
+    struct ifaddrs* if_addr = new struct ifaddrs;
+    memset(if_addr, 0, sizeof(struct ifaddrs));
+    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;
+    return if_addr;
+  }
+
+  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;
+    }
+  }
 #endif  // defined(WEBRTC_POSIX)
 
  protected:
   bool callback_called_;
 };
 
 // Test that the Network ctor works properly.
 TEST_F(NetworkTest, TestNetworkConstruct) {
   Network ipv4_network1("test_eth0", "Test Network Adapter 1",
                         IPAddress(0x12345600U), 24);
@@ skipping 473 matching lines @@
     } else {
       // Check the IP didn't get added anywhere it wasn't supposed to.
       EXPECT_EQ((*it)->GetIPs().end(),
                 std::find((*it)->GetIPs().begin(),
                           (*it)->GetIPs().end(),
                           ip));
     }
   }
 }
 
-// Test that DumpNetworks works.
-TEST_F(NetworkTest, TestDumpNetworks) {
+// Test that DumpNetworks does not crash.
+TEST_F(NetworkTest, TestCreateAndDumpNetworks) {
   BasicNetworkManager manager;
-  manager.DumpNetworks(true);
+  NetworkManager::NetworkList list = GetNetworks(manager, true);
+  bool changed;
+  MergeNetworkList(manager, list, &changed);
+  manager.DumpNetworks();
 }
 
 // Test that we can toggle IPv6 on and off.
 // Crashes on Linux. See webrtc:4923.
 #if defined(WEBRTC_LINUX)
 #define MAYBE_TestIPv6Toggle DISABLED_TestIPv6Toggle
 #else
 #define MAYBE_TestIPv6Toggle TestIPv6Toggle
 #endif
 TEST_F(NetworkTest, MAYBE_TestIPv6Toggle) {
@@ skipping 86 matching lines @@
 TEST_F(NetworkTest, TestConvertIfAddrsNoAddress) {
   ifaddrs list;
   memset(&list, 0, sizeof(list));
   list.ifa_name = const_cast<char*>("test_iface");
 
   NetworkManager::NetworkList result;
   BasicNetworkManager manager;
   CallConvertIfAddrs(manager, &list, true, &result);
   EXPECT_TRUE(result.empty());
 }
+
+// Verify that if there are two addresses on one interface, only one network
+// is generated.
+TEST_F(NetworkTest, TestConvertIfAddrsMultiAddressesOnOneInterface) {
+  char if_name[20] = "rmnet0";
+  ifaddrs* list = nullptr;
+  list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:1",
+                        "FFFF:FFFF:FFFF:FFFF::", 0);
+  list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:2",
+                        "FFFF:FFFF:FFFF:FFFF::", 0);
+  NetworkManager::NetworkList result;
+  BasicNetworkManager manager;
+  CallConvertIfAddrs(manager, list, true, &result);
+  EXPECT_EQ(1U, result.size());
+  bool changed;
+  // This ensures releasing the objects created in CallConvertIfAddrs.

[pthatcher1, 2015/12/08 19:40:24]

This ensures releasing => this ensures we realase

[honghaiz3, 2015/12/10 19:26:18]

Done.

+  MergeNetworkList(manager, result, &changed);
+  ReleaseIfAddrs(list);
+}
 #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 63 matching lines @@
   manager.GetNetworks(&list2);
 
   // Make sure the resulted networklist has only 1 element and 2
   // IPAddresses.
   EXPECT_EQ(list2.size(), 1uL);
   EXPECT_EQ(list2[0]->GetIPs().size(), 2uL);
   EXPECT_EQ(list2[0]->GetIPs()[0], ip1);
   EXPECT_EQ(list2[0]->GetIPs()[1], ip2);
 }
 
+// Test that MergeNetworkList successfully detects the change if
+// a network becomes inactive and then active again.
+TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) {
+  BasicNetworkManager manager;
+  Network network1("test_wifi", "Test Network Adapter 1",
+                   IPAddress(0x12345600U), 24);
+  Network network2("test_eth0", "Test Network Adapter 2",
+                   IPAddress(0x00010000U), 16);
+  network1.AddIP(IPAddress(0x12345678));
+  network2.AddIP(IPAddress(0x00010004));
+  NetworkManager::NetworkList list;
+  list.push_back(new Network(network1));
+  bool changed;
+  MergeNetworkList(manager, list, &changed);
+  EXPECT_TRUE(changed);

[pthatcher1, 2015/12/08 19:40:24]

Should we test what's in the manager right here?

[honghaiz3, 2015/12/10 19:26:18]

Done.

+
+  list.clear();
+  list.push_back(new Network(network2));
+  MergeNetworkList(manager, list, &changed);
+  EXPECT_TRUE(changed);
+  list.clear();
+  manager.GetNetworks(&list);
+  EXPECT_EQ(1U, list.size());

[pthatcher1, 2015/12/08 19:40:24]

Should we test what's in there, and not just the size?

[honghaiz3, 2015/12/10 19:26:18]

Done.

+
+  // Now network1 is inactive. Try to merge it again.

[pthatcher1, 2015/12/08 19:40:24]

What makes network1 inactive?

[honghaiz3, 2015/12/10 19:26:18]

When you merge list2 into an existing list1, 
If a network appeared in list1 but not in list2, it means the network is gone,
so it becomes inactive. We keep it because if the same network come back again,
it can reuse the Network object. We cannot delete it because some port may be
using the Network pointer. 

+  list.clear();
+  list.push_back(new Network(network1));
+  MergeNetworkList(manager, list, &changed);
+  EXPECT_TRUE(changed);
+  list.clear();
+  manager.GetNetworks(&list);
+  EXPECT_EQ(1U, list.size());
+  EXPECT_TRUE(list.front()->active());

[pthatcher1, 2015/12/08 19:40:24]

Nit: I find list[0].active() more readable.

[honghaiz3, 2015/12/10 19:26:18]

Done.

+}
+
 // Test that the filtering logic follows the defined ruleset in network.h.
 TEST_F(NetworkTest, TestIPv6Selection) {
   InterfaceAddress ip;
   std::string ipstr;
 
   ipstr = "2401:fa00:4:1000:be30:5bff:fee5:c3";
   ASSERT_TRUE(IPFromString(ipstr, IPV6_ADDRESS_FLAG_DEPRECATED, &ip));
 
   // Create a network with this prefix.
   Network ipv6_network(
@@ skipping 47 matching lines @@
   EXPECT_TRUE_WAIT(callback_called_, 1000);
 
   // Network manager is stopped; the network monitor is removed.
   manager.StopUpdating();
   EXPECT_TRUE(GetNetworkMonitor(manager) == nullptr);
 
   NetworkMonitorFactory::ReleaseFactory(factory);
 }
 
 }  // namespace rtc