Determine connection type in NetworkChangeNotifierLinux.

net/base/address_tracker_linux.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_BASE_ADDRESS_TRACKER_LINUX_H_
 #define NET_BASE_ADDRESS_TRACKER_LINUX_H_
 
 #include <sys/socket.h>  // Needed to include netlink.
 // Mask superfluous definition of |struct net|. This is fixed in Linux 2.6.38.
 #define net net_kernel
@@ skipping 47 matching lines @@
 
   AddressMap GetAddressMap() const;
 
   // Returns set of interface indicies for online interfaces.
   base::hash_set<int> GetOnlineLinks() const;
 
   // Implementation of NetworkChangeNotifierLinux::GetCurrentConnectionType().
   // Safe to call from any thread, but will block until Init() has completed.
   NetworkChangeNotifier::ConnectionType GetCurrentConnectionType();
 
+  // Adds/removes a netif name to ignore. Returns true if success.
+  bool AddNetifToIgnore(const std::string& netif_name);
+  bool RemoveNetifToIgnore(const std::string& netif_name);
+
+  bool GetNetworkList(NetworkInterfaceList* networks, int policy) const;

[pauljensen, 2014/11/21 18:55:36]

This API is exposed in net_util.h and should not be exposed here.

[derekjchow1, 2014/11/21 23:13:58]

Done.

+  std::string GetPrimaryNetif() const;

[pauljensen, 2014/11/21 18:55:36]

This cannot be accurate as there may be multiple interfaces used by the default
network.  TMobile for example uses multiple interfaces (rmnet0 and clatd).

[derekjchow1, 2014/11/21 23:13:58]

What should the correct behavior of NetworkChangeNotifier::GetConnectionType be
in the case of multiple interfaces?

This past reverted CL
(https://codereview.chromium.org/298023005/patch/130001/140001) suggests that we
should return the connection type if every network interface has the same
connection type or otherwise return CONNECTION_UNKNOWN. Should
address_tracker_linux preform something similar?

[pauljensen, 2014/11/24 12:33:18]

The correct behavior of NetworkChangeNotifier::GetConnectionType is to return
the type of the first hop of the default internet connection.  In the case of
TMobile cellular with two interfaces, NetworkChangeNotifier::GetConnectionType
should return one of the cellular types.
GetNetworkList() (which uses AddressTrackerLinux on several hosts) should
accurately determine the type of each interface if possible. 
NetworkChangeNotifier should should compute the type of the first hop of the
default internet connection.  If all results from GetNetworkList() are of the
same type I think it is safe to assume the default internet connection is of
this type too.

+
  private:
   friend class AddressTrackerLinuxTest;
 
   // In tracking mode, holds |lock| while alive. In non-tracking mode,
   // enforces single-threaded access.
   class AddressTrackerAutoLock {
    public:
     AddressTrackerAutoLock(const AddressTrackerLinux& tracker,
                            base::Lock& lock);
     ~AddressTrackerAutoLock();
 
    private:
     const AddressTrackerLinux& tracker_;
     base::Lock& lock_;
     DISALLOW_COPY_AND_ASSIGN(AddressTrackerAutoLock);
   };
 
   // A function that returns the name of an interface given the interface index
   // in |interface_index|.
-  typedef const char* (*GetInterfaceNameFunction)(int interface_index);
-
+  typedef char* (*GetInterfaceNameFunction)(unsigned int interface_index,
+                                            char* ifname);
   // Sets |*address_changed| to indicate whether |address_map_| changed and
   // sets |*link_changed| to indicate if |online_links_| changed and sets
   // |*tunnel_changed| to indicate if |online_links_| changed with regards to a
   // tunnel interface while reading messages from |netlink_fd_|.
   void ReadMessages(bool* address_changed,
                     bool* link_changed,
                     bool* tunnel_changed);
 
   // Sets |*address_changed| to true if |address_map_| changed, sets
   // |*link_changed| to true if |online_links_| changed, sets |*tunnel_changed|
@@ skipping 26 matching lines @@
   base::Closure address_callback_;
   base::Closure link_callback_;
   base::Closure tunnel_callback_;
 
   int netlink_fd_;
   base::MessageLoopForIO::FileDescriptorWatcher watcher_;
 
   mutable base::Lock address_map_lock_;
   AddressMap address_map_;
 
+  base::hash_set<std::string> netifs_to_ignore_;
+
   // Set of interface indices for links that are currently online.
   mutable base::Lock online_links_lock_;
   base::hash_set<int> online_links_;
 
   base::Lock is_offline_lock_;
   bool is_offline_;
   bool is_offline_initialized_;
   base::ConditionVariable is_offline_initialized_cv_;
   bool tracking_;
 
   // Used to verify single-threaded access in non-tracking mode.
   base::ThreadChecker thread_checker_;
 };
 
 }  // namespace internal
 }  // namespace net
 
 #endif  // NET_BASE_ADDRESS_TRACKER_LINUX_H_