Rename WiFiService::GetConnectedProperties into GetCurrentProperties.

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 337 matching lines @@
   // Update |properties| based on bss info from |wlan_bss_list|. If |bssid| in
   // |properties| is not empty, then it is not changed and |frequency| is set
   // based on that bssid.
   void UpdateNetworkPropertiesFromBssList(const std::string& network_guid,
                                           const WLAN_BSS_LIST& wlan_bss_list,
                                           NetworkProperties* properties);
 
   // Get the list of visible wireless networks.
   DWORD GetVisibleNetworkList(NetworkList* network_list);
 
-  // Find currently connected network if any. Populate |connected_properties|
-  // on success.
-  DWORD GetConnectedProperties(NetworkProperties* connected_properties);
+  // Get properties of the network currently used (connected or in transition)
+  // by interface. Populate |current_properties| on success.
+  DWORD GetCurrentProperties(NetworkProperties* current_properties);
 
   // 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();
 
@@ skipping 137 matching lines @@
 }
 
 void WiFiServiceImpl::GetProperties(const std::string& network_guid,
                                     base::DictionaryValue* properties,
                                     std::string* error) {
   DWORD error_code = EnsureInitialized();
   if (CheckError(error_code, kWiFiServiceError, error))
     return;
 
   NetworkProperties connected_properties;
-  error_code = GetConnectedProperties(&connected_properties);
+  error_code = GetCurrentProperties(&connected_properties);
   if (error_code == ERROR_SUCCESS &&
       connected_properties.guid == network_guid) {
     properties->Swap(connected_properties.ToValue(false).get());
     return;
   }
 
   NetworkList network_list;
   error_code = GetVisibleNetworkList(&network_list);
   if (error_code == ERROR_SUCCESS) {
     NetworkList::const_iterator it = FindNetwork(network_list, network_guid);
@@ skipping 133 matching lines @@
   DVLOG(1) << "Start Connect: " << network_guid;
   DWORD error_code = EnsureInitialized();
   if (error_code == ERROR_SUCCESS) {
     std::string connected_network_guid;
     error_code = SaveCurrentConnectedNetwork(&connected_network_guid);
     if (error_code == ERROR_SUCCESS) {
       // Check, if the network is already connected on desired frequency.
       bool already_connected = (network_guid == connected_network_guid);
       Frequency frequency = GetFrequencyToConnect(network_guid);
       if (already_connected && frequency != kFrequencyAny) {
-        NetworkProperties connected_properties;
-        if (GetConnectedProperties(&connected_properties) == ERROR_SUCCESS) {
-          already_connected = frequency == connected_properties.frequency &&
-                              network_guid == connected_properties.guid;
+        NetworkProperties current_properties;
+        if (GetCurrentProperties(&current_properties) == ERROR_SUCCESS) {
+          already_connected = current_properties.connection_state ==
+                              onc::connection_state::kConnected &&

[tbarzic, 2014/04/23 16:50:20]

nit: increasing indent (+4) here would make it easier to read.

(I'd suggest running 'git cl format' it should take care of nits like this)

[mef, 2014/04/23 17:04:21]

Done.

+                              frequency == current_properties.frequency &&
+                              network_guid == current_properties.guid;
         }
       }
       // Connect only if network |network_guid| is not connected already.
       if (!already_connected)
         error_code = Connect(network_guid, frequency);
       if (error_code == ERROR_SUCCESS) {
         // Notify that previously connected network has changed.
         NotifyNetworkChanged(connected_network_guid);
         // Start waiting for network connection state change.
         if (!networks_changed_observer_.is_null()) {
@@ skipping 201 matching lines @@
           LOG(ERROR) << "Failed to delete created profile for " << network_guid
                      << " error=" << error_code;
         }
       }
     }
     // Restore automatic network change notifications and stop waiting.
     enable_notify_network_changed_ = true;
     RestoreNwCategoryWizard();
     return;
   }
-  NetworkProperties connected_network_properties;
-  DWORD error = GetConnectedProperties(&connected_network_properties);
-  if (network_guid == connected_network_properties.guid &&
-      connected_network_properties.connection_state ==
+  NetworkProperties current_properties;
+  DWORD error = GetCurrentProperties(&current_properties);
+  if (network_guid == current_properties.guid &&
+      current_properties.connection_state ==
       onc::connection_state::kConnected) {
     DVLOG(1) << "WiFi Connected, Reset DHCP: " << network_guid;
     // Even though wireless network is now connected, it may still be unusable,
     // e.g. after Chromecast device reset. Reset DHCP on wireless network to
     // work around this issue.
     error = ResetDHCP();
     // There is no need to keep created profile as network is connected.
     created_profiles_.RemoveWithoutPathExpansion(network_guid, NULL);
     // Restore previously suppressed notifications.
     enable_notify_network_changed_ = true;
@@ skipping 29 matching lines @@
        ++it) {
     if (it->guid == network_guid)
       return it;
   }
   return networks.end();
 }
 
 DWORD WiFiServiceImpl::SaveCurrentConnectedNetwork(
     std::string* connected_network_guid) {
   // Find currently connected network.
-  NetworkProperties connected_network_properties;
-  DWORD error = GetConnectedProperties(&connected_network_properties);
-  if (error == ERROR_SUCCESS && !connected_network_properties.guid.empty()) {
-    *connected_network_guid = connected_network_properties.guid;
+  NetworkProperties current_properties;
+  DWORD error = GetCurrentProperties(&current_properties);
+  if (error == ERROR_SUCCESS && !current_properties.guid.empty() &&
+      current_properties.connection_state ==
+      onc::connection_state::kConnected) {
+    *connected_network_guid = current_properties.guid;
     SaveTempProfile(*connected_network_guid);
     std::string profile_xml;
     error = GetProfile(*connected_network_guid, false, &profile_xml);
     if (error == ERROR_SUCCESS) {
       saved_profiles_xml_[*connected_network_guid] = profile_xml;
     }
   }
   return error;
 }
 
@@ skipping 414 matching lines @@
   // Clean up.
   if (available_network_list != NULL) {
     WlanFreeMemory_function_(available_network_list);
   }
   if (bss_list != NULL) {
     WlanFreeMemory_function_(bss_list);
   }
   return error;
 }
 
-DWORD WiFiServiceImpl::GetConnectedProperties(NetworkProperties* properties) {
+DWORD WiFiServiceImpl::GetCurrentProperties(NetworkProperties* properties) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   // TODO(mef): WlanGetNetworkBssList is not available on XP. If XP support is
   // needed, then different method of getting BSS (e.g. OID query) will have
   // to be used.
   if (WlanGetNetworkBssList_function_ == NULL)
     return ERROR_NOINTERFACE;
 
-  Frequency frequency = kFrequencyUnknown;
   DWORD error = ERROR_SUCCESS;
   DWORD data_size = 0;
   PWLAN_CONNECTION_ATTRIBUTES wlan_connection_attributes = NULL;
   PWLAN_BSS_LIST bss_list = 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;
 
     properties->connection_state = ConnectionStateFromInterfaceState(
         wlan_connection_attributes->isState);
     properties->ssid = GUIDFromSSID(connected_wlan.dot11Ssid);
     properties->name = properties->ssid;
     properties->guid = GUIDFromSSID(connected_wlan.dot11Ssid);
     properties->type = onc::network_type::kWiFi;
     properties->bssid = NetworkProperties::MacAddressAsString(
         connected_wlan.dot11Bssid);
     properties->security = SecurityFromDot11AuthAlg(
         wlan_connection_attributes->wlanSecurityAttributes.dot11AuthAlgorithm);
     properties->signal_strength = connected_wlan.wlanSignalQuality;
 
-    // TODO(mef): WlanGetNetworkBssList is not available on XP. If XP support is
-    // needed, then different method of getting BSS (e.g. OID query) will have
-    // to be used.
     error = WlanGetNetworkBssList_function_(client_,
                                             &interface_guid_,
                                             &connected_wlan.dot11Ssid,
                                             connected_wlan.dot11BssType,
                                             FALSE,
                                             NULL,
                                             &bss_list);
     if (error == ERROR_SUCCESS && NULL != bss_list) {
       UpdateNetworkPropertiesFromBssList(properties->guid,
                                          *bss_list,
                                          properties);
     }
   }
 
   // Clean up.
   if (wlan_connection_attributes != NULL)
     WlanFreeMemory_function_(wlan_connection_attributes);
 
   if (bss_list != NULL)
     WlanFreeMemory_function_(bss_list);
 
-  return frequency;
+  return error;
 }
 
 WiFiService::Frequency WiFiServiceImpl::GetFrequencyToConnect(
     const std::string& network_guid) const {
   // Check whether desired frequency is set in |connect_properties_|.
   const base::DictionaryValue* properties;
   const base::DictionaryValue* wifi;
   int frequency;
   if (connect_properties_.GetDictionaryWithoutPathExpansion(
           network_guid, &properties) &&
@@ skipping 353 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