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

webrtc/base/network.h

 /*
  *  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 19 matching lines @@
 namespace rtc {
 
 extern const char kPublicIPv4Host[];
 extern const char kPublicIPv6Host[];
 
 class IfAddrsConverter;
 class Network;
 class NetworkMonitorInterface;
 class Thread;
 
+static const uint16_t kNetworkCostMax = 999;
+static const uint16_t kNetworkCostHigh = 900;
+static const uint16_t kNetworkCostUnknown = 50;
+static const uint16_t kNetworkCostLow = 10;
+static const uint16_t kNetworkCostMin = 0;
 
 // By default, ignore loopback interfaces on the host.
 const int kDefaultNetworkIgnoreMask = ADAPTER_TYPE_LOOPBACK;
 
 // Makes a string key for this network. Used in the network manager's maps.
 // Network objects are keyed on interface name, network prefix and the
 // length of that prefix.
 std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
                            int prefix_length);
 
@@ skipping 192 matching lines @@
   // Stops and removes the network monitor.
   void StopNetworkMonitor();
   // Called when it receives updates from the network monitor.
   void OnNetworksChanged();
 
   // Updates the networks and reschedules the next update.
   void UpdateNetworksContinually();
   // Only updates the networks; does not reschedule the next update.
   void UpdateNetworksOnce();
 
+  AdapterType GetAdapterTypeFromName(const char* network_name) const;
+
   Thread* thread_;
   bool sent_first_update_;
   int start_count_;
   std::vector<std::string> network_ignore_list_;
   bool ignore_non_default_routes_;
   std::unique_ptr<NetworkMonitorInterface> network_monitor_;
 };
 
 // Represents a Unix-type network interface, with a name and single address.
 class Network {
  public:
   Network(const std::string& name,
           const std::string& description,
           const IPAddress& prefix,
           int prefix_length);
 
   Network(const std::string& name,
           const std::string& description,
           const IPAddress& prefix,
           int prefix_length,
           AdapterType type);
   ~Network();
 
   sigslot::signal1<const Network*> SignalInactive;
+  sigslot::signal1<const Network*> SignalTypeChanged;
 
   const DefaultLocalAddressProvider* default_local_address_provider() {
     return default_local_address_provider_;
   }
   void set_default_local_address_provider(
       const DefaultLocalAddressProvider* provider) {
     default_local_address_provider_ = provider;
   }
 
   // Returns the name of the interface this network is associated wtih.
@@ skipping 51 matching lines @@
   // Should only be relevant for link-local IPv6 addresses.
   int scope_id() const { return scope_id_; }
   void set_scope_id(int id) { scope_id_ = id; }
 
   // Indicates whether this network should be ignored, perhaps because
   // the IP is 0, or the interface is one we know is invalid.
   bool ignored() const { return ignored_; }
   void set_ignored(bool ignored) { ignored_ = ignored; }
 
   AdapterType type() const { return type_; }
-  void set_type(AdapterType type) { type_ = type; }
+  void set_type(AdapterType type) {
+    if (type_ == type) {
+      return;
+    }
+    type_ = type;
+    SignalTypeChanged(this);
+  }
 
+  uint16_t GetCost() const {
+    switch (type_) {
+      case rtc::ADAPTER_TYPE_ETHERNET:
+      case rtc::ADAPTER_TYPE_LOOPBACK:
+        return kNetworkCostMin;
+      case rtc::ADAPTER_TYPE_WIFI:
+      case rtc::ADAPTER_TYPE_VPN:
+        return kNetworkCostLow;
+      case rtc::ADAPTER_TYPE_CELLULAR:
+        return kNetworkCostHigh;
+      default:
+        return kNetworkCostUnknown;
+    }
+  }
   // A unique id assigned by the network manager, which may be signaled
   // to the remote side in the candidate.
   uint16_t id() const { return id_; }
   void set_id(uint16_t id) { id_ = id; }
 
   int preference() const { return preference_; }
   void set_preference(int preference) { preference_ = preference; }
 
   // When we enumerate networks and find a previously-seen network is missing,
   // we do not remove it (because it may be used elsewhere). Instead, we mark
@@ skipping 26 matching lines @@
   int preference_;
   bool active_ = true;
   uint16_t id_ = 0;
 
   friend class NetworkManager;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_NETWORK_H_