Add SSID getter to WiFiService

components/wifi/wifi_service_win.cc

 // Copyright 2013 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.
 
 #include "components/wifi/wifi_service.h"
 
 #include <iphlpapi.h>
 #include <objbase.h>
 #include <wlanapi.h>
 
@@ skipping 208 matching lines @@
                                 std::string* key_data,
                                 std::string* error) override;
 
   virtual void SetEventObservers(
       scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
       const NetworkGuidListCallback& networks_changed_observer,
       const NetworkGuidListCallback& network_list_changed_observer) override;
 
   virtual void RequestConnectedNetworkUpdate() override {}
 
+  virtual void GetConnectedNetworkSSID(std::string* ssid,
+                                       std::string* error) override;
+
  private:
   typedef int32 EncryptionType;
   enum EncryptionTypeEnum {
     kEncryptionTypeAny = 0,
     kEncryptionTypeAES = 1,
     kEncryptionTypeTKIP = 2
   };
 
   // Static callback for Windows WLAN_NOTIFICATION. Calls OnWlanNotification
   // on WiFiServiceImpl passed back as |context|.
@@ skipping 111 matching lines @@
                                           const WLAN_BSS_LIST& wlan_bss_list,
                                           NetworkProperties* properties);
 
   // Get the list of visible wireless networks.
   DWORD GetVisibleNetworkList(NetworkList* network_list);
 
   // Get properties of the network currently used (connected or in transition)
   // by interface. Populate |current_properties| on success.
   DWORD GetCurrentProperties(NetworkProperties* current_properties);
 
+  // Get the SSID of the network currently used (connected or in transition)
+  // by interface. Populate |ssid| on success. This is a stripped down version
+  // of GetCurrentProperties that doesn't use the BSS list;
+  DWORD GetCurrentSSID(std::string* ssid);
+
   // Connect to network |network_guid| using previosly stored profile if exists,
   // or just network sid. If |frequency| is not |kFrequencyUnknown| then
   // connects only to BSS which uses that frequency and returns
   // |ERROR_NOT_FOUND| if such BSS cannot be found.
   DWORD Connect(const std::string& network_guid, Frequency frequency);
 
   // Disconnect from currently connected network if any.
   DWORD Disconnect();
 
   // Get desired connection freqency if it was set using |SetProperties|.
@@ skipping 429 matching lines @@
     WlanRegisterNotification_function_(client_,
                                        WLAN_NOTIFICATION_SOURCE_ALL,
                                        FALSE,
                                        OnWlanNotificationCallback,
                                        this,
                                        NULL,
                                        NULL);
   }
 }
 
+void WiFiServiceImpl::GetConnectedNetworkSSID(std::string* ssid,
+                                              std::string* error) {
+  DWORD error_code = EnsureInitialized();
+  if (CheckError(error_code, kErrorWiFiService, error))
+    return;
+  std::string current_ssid;
+  error_code = GetCurrentSSID(&current_ssid);
+  if (CheckError(error_code, kErrorWiFiService, error))
+    return;
+  *ssid = current_ssid;
+}
+
 void WiFiServiceImpl::OnWlanNotificationCallback(
     PWLAN_NOTIFICATION_DATA wlan_notification_data,
     PVOID context) {
   WiFiServiceImpl* service = reinterpret_cast<WiFiServiceImpl*>(context);
   service->OnWlanNotification(wlan_notification_data);
 }
 
 void WiFiServiceImpl::OnWlanNotification(
     PWLAN_NOTIFICATION_DATA wlan_notification_data) {
   if (message_loop_proxy_.get() == NULL)
@@ skipping 636 matching lines @@
   // Clean up.
   if (wlan_connection_attributes != NULL)
     WlanFreeMemory_function_(wlan_connection_attributes);
 
   if (bss_list != NULL)
     WlanFreeMemory_function_(bss_list);
 
   return error;
 }
 
+
+DWORD WiFiServiceImpl::GetCurrentSSID(std::string* ssid) {
+  if (client_ == NULL) {
+    NOTREACHED();
+    return ERROR_NOINTERFACE;
+  }
+  DWORD error = ERROR_SUCCESS;
+  DWORD data_size = 0;
+  PWLAN_CONNECTION_ATTRIBUTES wlan_connection_attributes = NULL;
+  error = WlanQueryInterface_function_(
+      client_,
+      &interface_guid_,
+      wlan_intf_opcode_current_connection,
+      NULL,
+      &data_size,
+      reinterpret_cast<PVOID*>(&wlan_connection_attributes),
+      NULL);
+  if (error == ERROR_SUCCESS &&
+      wlan_connection_attributes != NULL) {
+    WLAN_ASSOCIATION_ATTRIBUTES& connected_wlan =
+        wlan_connection_attributes->wlanAssociationAttributes;
+    *ssid = GUIDFromSSID(connected_wlan.dot11Ssid);
+  }
+
+  // Clean up.
+  if (wlan_connection_attributes != NULL)
+    WlanFreeMemory_function_(wlan_connection_attributes);
+
+  return error;
+}
+
 Frequency WiFiServiceImpl::GetFrequencyToConnect(
     const std::string& network_guid) const {
   // Check whether desired frequency is set in |connect_properties_|.
   const base::DictionaryValue* properties;
   if (connect_properties_.GetDictionaryWithoutPathExpansion(network_guid,
                                                             &properties)) {
     const base::DictionaryValue* wifi;
     if (properties->GetDictionary(onc::network_type::kWiFi, &wifi)) {
       int frequency;
       if (wifi->GetInteger(onc::wifi::kFrequency, &frequency))
@@ skipping 365 matching lines @@
     NetworkGuidList changed_networks(1, network_guid);
     message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(networks_changed_observer_, changed_networks));
   }
 }
 
 WiFiService* WiFiService::Create() { return new WiFiServiceImpl(); }
 
 }  // namespace wifi