Infer network connection type from network interface type.

net/base/network_change_notifier.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_NETWORK_CHANGE_NOTIFIER_H_
 #define NET_BASE_NETWORK_CHANGE_NOTIFIER_H_
 
+#include <vector>
+
 #include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"

[pauljensen, 2014/06/20 05:58:53]

Sadly I cannot include net_util.h here because it includes
network_change_notifier.h (which is a no-op because of the recursive include
guards) before using NetworkChangeNotifier::ConnectionType.

 
 class GURL;
 
 namespace net {
 
 struct DnsConfig;
 class HistogramWatcher;
 class NetworkChangeNotifierFactory;
+struct NetworkInterface;
+typedef std::vector<NetworkInterface> NetworkInterfaceList;

[pauljensen, 2014/06/20 05:58:53]

This is sadly necessary because net_util.h includes network_change_notifier.h
before declaring NetworkInterfaceList.

[mmenke, 2014/06/20 15:18:57]

Ugly, but fine for now.  I'd argue it may make sense to have
ConnectionTypeFromInterfaceList as a NET_EXPORT_PRIVATE in the same file as
NetworkInterface, but net_util already has enough random stuff as it is.  And
NET_EXPORT_PRIVATE doesn't give us any hard guarantees about non-use externally,
unfortunately.

 class URLRequest;
 
 #if defined(OS_LINUX)
 namespace internal {
 class AddressTrackerLinux;
 }
 #endif
 
 // NetworkChangeNotifier monitors the system for network changes, and notifies
 // registered observers of those events.  Observers may register on any thread,
@@ skipping 263 matching lines @@
   // happens asynchronously, even for observers on the current thread, even in
   // tests.
   static void NotifyObserversOfIPAddressChange();
   static void NotifyObserversOfConnectionTypeChange();
   static void NotifyObserversOfDNSChange();
   static void NotifyObserversOfNetworkChange(ConnectionType type);
 
   // Stores |config| in NetworkState and notifies observers.
   static void SetDnsConfig(const DnsConfig& config);
 
+  // Infer connection type from |GetNetworkList|. If all network interfaces have
+  // the same type, return it, otherwise return CONNECTION_UNKNOWN.
+  static ConnectionType ConnectionTypeFromInterfaces();
+
  private:
   friend class HostResolverImplDnsTest;
   friend class NetworkChangeNotifierAndroidTest;
   friend class NetworkChangeNotifierLinuxTest;
   friend class NetworkChangeNotifierWinTest;
+  FRIEND_TEST_ALL_PREFIXES(NetworkChangeNotifierTest,
+                           InterfacesToConnectionType);
 
   class NetworkState;
   class NetworkChangeCalculator;
 
+  // Infer connection type from |list|. If all network interfaces have
+  // the same type, return it, otherwise return CONNECTION_UNKNOWN.
+  static ConnectionType ConnectionTypeFromInterfaceList(
+      const NetworkInterfaceList& interfaces);
+
   const scoped_refptr<ObserverListThreadSafe<IPAddressObserver> >
       ip_address_observer_list_;
   const scoped_refptr<ObserverListThreadSafe<ConnectionTypeObserver> >
       connection_type_observer_list_;
   const scoped_refptr<ObserverListThreadSafe<DNSObserver> >
       resolver_state_observer_list_;
   const scoped_refptr<ObserverListThreadSafe<NetworkChangeObserver> >
       network_change_observer_list_;
 
   // The current network state. Hosts DnsConfig, exposed via GetDnsConfig.
   scoped_ptr<NetworkState> network_state_;
 
   // A little-piggy-back observer that simply logs UMA histogram data.
   scoped_ptr<HistogramWatcher> histogram_watcher_;
 
   // Computes NetworkChange signal from IPAddress and ConnectionType signals.
   scoped_ptr<NetworkChangeCalculator> network_change_calculator_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkChangeNotifier);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_NETWORK_CHANGE_NOTIFIER_H_