Add WiFi SSID getter to NetworkChangeNotifier.

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
 #include <linux/rtnetlink.h>
 #undef net
 
 #include <map>
+#include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "net/base/net_util.h"
 #include "net/base/network_change_notifier.h"
 
 namespace net {
 namespace internal {
 
 // Keeps track of network interface addresses using rtnetlink. Used by
 // NetworkChangeNotifier to provide signals to registered IPAddressObservers.
 class NET_EXPORT_PRIVATE AddressTrackerLinux :
     public base::MessageLoopForIO::Watcher {
  public:
   typedef std::map<IPAddressNumber, struct ifaddrmsg> AddressMap;
 
+  // A function that returns the SSID of an interface given the interface name.
+  typedef std::string (*GetInterfaceSSIDFunction)(const std::string& ifname);
+
   // Non-tracking version constructor: it takes a snapshot of the
   // current system configuration. Once Init() returns, the
   // configuration is available through GetOnlineLinks() and
   // GetAddressMap().
   AddressTrackerLinux();
 
   // Tracking version constructor: it will run |address_callback| when
   // the AddressMap changes, |link_callback| when the list of online
   // links changes, and |tunnel_callback| when the list of online
   // tunnels changes.
@@ skipping 11 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();
 
+  // Implementation of NetworkChangeNotifierLinux::GetCurrentWiFiSSID().
+  // Safe to call from any thread. Doesn't wait for initialization to complete,
+  // so may return empty string.
+  std::string GetCurrentWiFiSSID();
+
   // Returns the name for the interface with interface index |interface_index|.
   // |buf| should be a pointer to an array of size IFNAMSIZ. The returned
   // pointer will point to |buf|. This function acts like if_indextoname which
   // cannot be used as net/if.h cannot be mixed with linux/if.h. We'll stick
   // with exclusively talking to the kernel and not the C library.
   static char* GetInterfaceName(int interface_index, char* buf);
 
+  // Gets the current Wi-Fi SSID based on |interfaces|. Returns
+  // empty string if there are no interfaces or if two interfaces have different
+  // connection types. Otherwise returns the SSID of all interfaces if they have
+  // the same SSID. This is adapted from
+  // NetworkChangeNotifier::ConnectionTypeFromInterfaceList.
+  static std::string ConnectionSSIDFromInterfaceList(
+      const NetworkInterfaceList& interfaces,
+      GetInterfaceSSIDFunction get_interface_ssid);
+
  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();
@@ skipping 33 matching lines @@
   // MessageLoopForIO::Watcher:
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int /* fd */) override;
 
   // Close |netlink_fd_|
   void CloseSocket();
 
   // Does |interface_index| refer to a tunnel interface?
   bool IsTunnelInterface(int interface_index) const;
 
-  // Updates current_connection_type_ based on the network list.
-  void UpdateCurrentConnectionType();
+  // Updates current_connection_type_ and current_wifi_ssid_ based on the
+  // network list.
+  void UpdateCurrentConnectionTypeAndSSID();
 
   // Gets the name of an interface given the interface index |interface_index|.
   // May return empty string if it fails but should not return NULL. This is
   // overridden by tests.
   GetInterfaceNameFunction get_interface_name_;
 
   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_;
 
   // Set of interface indices for links that are currently online.
   mutable base::Lock online_links_lock_;
   base::hash_set<int> online_links_;
 
   base::Lock connection_type_lock_;
   bool connection_type_initialized_;
   base::ConditionVariable connection_type_initialized_cv_;
   NetworkChangeNotifier::ConnectionType current_connection_type_;
+
+  base::Lock wifi_ssid_lock_;
+  std::string current_wifi_ssid_;
+
   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_