Multi-networking with Android L.

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.
  */
 
 #ifndef WEBRTC_BASE_NETWORK_H_
 #define WEBRTC_BASE_NETWORK_H_
 
 #include <deque>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/ipaddress.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
+#include "webrtc/base/networkmonitor.h"
 
 #if defined(WEBRTC_POSIX)
 struct ifaddrs;
 #endif  // defined(WEBRTC_POSIX)
 
 namespace rtc {
 
 extern const char kPublicIPv4Host[];
 extern const char kPublicIPv6Host[];
 
 class Network;
+class NetworkInformation;
 class NetworkMonitorInterface;
 class Thread;
 
 enum AdapterType {
   // This enum resembles the one in Chromium net::ConnectionType.
   ADAPTER_TYPE_UNKNOWN = 0,
   ADAPTER_TYPE_ETHERNET = 1 << 0,
   ADAPTER_TYPE_WIFI = 1 << 1,
   ADAPTER_TYPE_CELLULAR = 1 << 2,
   ADAPTER_TYPE_VPN = 1 << 3,
@@ skipping 94 matching lines @@
 
   void set_max_ipv6_networks(int networks) { max_ipv6_networks_ = networks; }
   int max_ipv6_networks() { return max_ipv6_networks_; }
 
   EnumerationPermission enumeration_permission() const override;
 
   bool GetDefaultLocalAddress(int family, IPAddress* ipaddr) const override;
 
  protected:
   typedef std::map<std::string, Network*> NetworkMap;
+  NetworkMap& networks_map() { return networks_map_; }
   // Updates |networks_| with the networks listed in |list|. If
   // |network_map_| already has a Network object for a network listed
   // in the |list| then it is reused. Accept ownership of the Network
   // objects in the |list|. |changed| will be set to true if there is
   // any change in the network list.
   void MergeNetworkList(const NetworkList& list, bool* changed);
 
   // |stats| will be populated even if |*changed| is false.
   void MergeNetworkList(const NetworkList& list,
                         bool* changed,
@@ skipping 81 matching lines @@
 
   // Determines if a network should be ignored. This should only be determined
   // based on the network's property instead of any individual IP.
   bool IsIgnoredNetwork(const Network& network) const;
 
   // This function connects a UDP socket to a public address and returns the
   // local address associated it. Since it binds to the "any" address
   // internally, it returns the default local address on a multi-homed endpoint.
   IPAddress QueryDefaultLocalAddress(int family) const;
 
+
+  void OnNetworkAvailable(const NetworkInformation& network_info);
+
  private:
   friend class NetworkTest;
 
   // Creates a network monitor and listens for network updates.
   void StartNetworkMonitor();
   // 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();
 
+  void GetAndUpdateNetworkInfos();
+  // this changed network info ???
+  void UpdateNetworkInfo(Network* network) const;
+
+
   Thread* thread_;
   bool sent_first_update_;
   int start_count_;
   std::vector<std::string> network_ignore_list_;
   int network_ignore_mask_;
   bool ignore_non_default_routes_;
   scoped_ptr<NetworkMonitorInterface> network_monitor_;
+  std::map<std::string, NetworkInformation> network_infos_;
 };
 
 // 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);
 
@@ skipping 66 matching lines @@
   // Returns the scope-id of the network's address.
   // 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; }
 
+  uint32_t handle() const { return handle_; }
+  void set_handle(uint32_t handle) { handle_ = handle; }
+
   AdapterType type() const { return type_; }
+  void set_type(AdapterType type) { type_ = type; }
+
   int preference() const { return preference_; }
   void set_preference(int preference) { preference_ = preference; }
 
   // Debugging description of this network
   std::string ToString() const;
 
  private:
   const DefaultLocalAddressProvider* default_local_address_provider_ = nullptr;
   std::string name_;
   std::string description_;
   IPAddress prefix_;
   int prefix_length_;
   std::string key_;
   std::vector<InterfaceAddress> ips_;
   int scope_id_;
   bool ignored_;
   AdapterType type_;
   int preference_;
+  uint32_t handle_ = 0;
 
   friend class NetworkManager;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_NETWORK_H_