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

webrtc/base/network.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 274 matching lines @@
       net->set_id(next_available_network_id_++);
       // Also, we might have accumulated IPAddresses from the first
       // step, set it here.
       net->SetIPs(kv.second.ips, true);
       *changed = true;
     } else {
       // This network exists in the map already. Reset its IP addresses.
       Network* existing_net = existing->second;
       *changed = existing_net->SetIPs(kv.second.ips, *changed);
       merged_list.push_back(existing_net);
+      if (net->type() != ADAPTER_TYPE_UNKNOWN &&
+          net->type() != existing_net->type()) {
+        existing_net->set_type(net->type());
+        *changed = true;
+      }
       // If the existing network was not active, networks have changed.
       if (!existing_net->active()) {
         *changed = true;
       }
       ASSERT(net->active());
       if (existing_net != net) {
         delete net;
       }
     }
   }
@@ skipping 82 matching lines @@
 
 BasicNetworkManager::BasicNetworkManager()
     : thread_(NULL), sent_first_update_(false), start_count_(0),
       ignore_non_default_routes_(false) {
 }
 
 BasicNetworkManager::~BasicNetworkManager() {
 }
 
 void BasicNetworkManager::OnNetworksChanged() {
-  LOG(LS_VERBOSE) << "Network change was observed at the network manager";
+  LOG(LS_INFO) << "Network change was observed";
   UpdateNetworksOnce();
 }
 
 #if defined(__native_client__)
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   ASSERT(false);
   LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet";
   return false;
@@ skipping 37 matching lines @@
 
     // Special case for IPv6 address.
     if (cursor->ifa_addr->sa_family == AF_INET6) {
       if (IsIgnoredIPv6(ip)) {
         continue;
       }
       scope_id =
           reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
     }
 
+    AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN;
+    if (cursor->ifa_flags & IFF_LOOPBACK) {
+      adapter_type = ADAPTER_TYPE_LOOPBACK;
+    } else {
+      adapter_type = GetAdapterTypeFromName(cursor->ifa_name);
+    }
     int prefix_length = CountIPMaskBits(mask);
     prefix = TruncateIP(ip, prefix_length);
     std::string key = MakeNetworkKey(std::string(cursor->ifa_name),
                                      prefix, prefix_length);
-    auto existing_network = current_networks.find(key);
-    if (existing_network == current_networks.end()) {
-      AdapterType adapter_type = ADAPTER_TYPE_UNKNOWN;
-      if (cursor->ifa_flags & IFF_LOOPBACK) {
-        adapter_type = ADAPTER_TYPE_LOOPBACK;
-      } else if (network_monitor_) {
-        adapter_type = network_monitor_->GetAdapterType(cursor->ifa_name);
-      }
-#if defined(WEBRTC_IOS)
-      // Cell networks are pdp_ipN on iOS.
-      if (strncmp(cursor->ifa_name, "pdp_ip", 6) == 0) {
-        adapter_type = ADAPTER_TYPE_CELLULAR;
-      }
-#endif
+    auto iter = current_networks.find(key);
+    if (iter == current_networks.end()) {
       // TODO(phoglund): Need to recognize other types as well.
       std::unique_ptr<Network> network(
           new Network(cursor->ifa_name, cursor->ifa_name, prefix, prefix_length,
                       adapter_type));
       network->set_default_local_address_provider(this);
       network->set_scope_id(scope_id);
       network->AddIP(ip);
       network->set_ignored(IsIgnoredNetwork(*network));
       if (include_ignored || !network->ignored()) {
         current_networks[key] = network.get();
         networks->push_back(network.release());
       }
     } else {
-      (*existing_network).second->AddIP(ip);
+      Network* existing_network = iter->second;
+      existing_network->AddIP(ip);
+      if (adapter_type != ADAPTER_TYPE_UNKNOWN) {
+        existing_network->set_type(adapter_type);
+      }
     }
   }
 }
 
 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
                                          NetworkList* networks) const {
   struct ifaddrs* interfaces;
   int error = getifaddrs(&interfaces);
   if (error != 0) {
     LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error;
@@ skipping 283 matching lines @@
     }
     case kSignalNetworksMessage:  {
       SignalNetworksChanged();
       break;
     }
     default:
       ASSERT(false);
   }
 }
 
+AdapterType BasicNetworkManager::GetAdapterTypeFromName(
+    const char* network_name) const {
+  // If there is a network_monitor, use it to get the adapter type.
+  // Otherwise, get the adapter type based on a few name matching rules.
+  if (network_monitor_) {
+    AdapterType type = network_monitor_->GetAdapterType(network_name);
+    if (type != ADAPTER_TYPE_UNKNOWN) {
+      return type;
+    }
+  }
+#if defined(WEBRTC_IOS)
+  // Cell networks are pdp_ipN on iOS.
+  if (strncmp(network_name, "pdp_ip", 6) == 0) {
+    return ADAPTER_TYPE_CELLULAR;
+  }
+#elif defined(WEBRTC_ANDROID)
+  if (strncmp(network_name, "rmnet", 5) == 0 ||
+      strncmp(network_name, "v4-rmnet", 8) == 0) {
+    return ADAPTER_TYPE_CELLULAR;
+  }
+  if (strncmp(network_name, "wlan", 4) == 0) {
+    return ADAPTER_TYPE_WIFI;
+  }
+#endif
+
+  return ADAPTER_TYPE_UNKNOWN;
+}
+
 IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const {
   ASSERT(thread_ == Thread::Current());
   ASSERT(thread_->socketserver() != nullptr);
   ASSERT(family == AF_INET || family == AF_INET6);
 
   std::unique_ptr<AsyncSocket> socket(
       thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
   if (!socket) {
     LOG_ERR(LERROR) << "Socket creation failed";
     return IPAddress();
@@ skipping 138 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc