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 kMaxNetworkCost = 999;
+static const uint16_t kNetworkCostForUnknownType = 10;

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

See my comments about these names in another CL (I'd prefer something like
kNetworkCostMin = 0,  kNetworkCostLow = 10, kNetworkCostUnknown = 50, 
kNetworkCostHigh = 900, kNetworkCostMax = 999).

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

Done. I once worried that one client may set its cellular cost to be 901 so that
his cellular will be less used than the other side. 
So I set the cellular cost to the maximum vale 999. 
But since webrtc is controlling the cost assignment on both sides, it is perhaps
OK to assign it to 900. 
Let me know if you think this may be an issue. 

 
 // 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*> SignalNetworkTypeChanged;

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

SignalTypeChanged would be enough, since this is a Network.

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

Done.

 
   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) {

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

I'd slightly prefer this with an early return:

if (type_ == type) {
  return;
}

type_ = type;
SignalTypeChanged(this);

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

Done.

+      type_ = type;
+      SignalNetworkTypeChanged(this);
+    }
+  }
+
+  uint16_t GetCost() const {
+    switch (type_) {
+      case rtc::ADAPTER_TYPE_UNKNOWN:
+        return kNetworkCostForUnknownType;
+      case rtc::ADAPTER_TYPE_CELLULAR:
+        return kMaxNetworkCost;
+      default:

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

Again, see my comments in the other CL where I think the default should be
"UNKNOWN" and we should enumerate wifi/ethernet, and should prefer ethernet
slightly over wifi.

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

Done.

+        return 0;
+    }
+  }
 
   // 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,
@@ skipping 27 matching lines @@
   int preference_;
   bool active_ = true;
   uint16_t id_ = 0;
 
   friend class NetworkManager;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_NETWORK_H_