Use WiFi.Frequency property to set desired band for networkingPrivateApi.StartConnect()

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 273 matching lines @@
 
   // 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|.
+  // Default to |kFrequencyAny|.
+  Frequency GetDesiredFrequency(const std::string& network_guid);
+
   // Get DOT11_BSSID_LIST of desired BSSIDs to connect to |ssid| network on
   // given |frequency|.
   DWORD GetDesiredBssList(DOT11_SSID& ssid,
                           Frequency frequency,
                           scoped_ptr<DOT11_BSSID_LIST>* desired_list);
 
   // Save temporary wireless profile for |network_guid|.
   DWORD SaveTempProfile(const std::string& network_guid);
 
   // Get previously stored |profile_xml| for |network_guid|.
@@ skipping 28 matching lines @@
   WlanRegisterNotificationFunction WlanRegisterNotification_function_;
   WlanScanFunction WlanScan_function_;
   // WlanSaveTemporaryProfile function may not be avaiable on Windows XP.
   WlanSaveTemporaryProfileFunction WlanSaveTemporaryProfile_function_;
 
   // WLAN service handle.
   HANDLE client_;
   // GUID of the currently connected interface, if any, otherwise the GUID of
   // one of the WLAN interfaces.
   GUID interface_guid_;
+  // Temporary storage of network properties indexed by |network_guid|.
+  DictionaryValue temporary_network_properties_;

[stevenjb, 2013/11/26 18:00:34]

How about 'connect_properties_' to better describe what these properties are
used for. Also, document that these properties persist unless changed.

[mef, 2013/11/26 19:00:13]

Done.

   // Preserved WLAN profile xml.
   std::map<std::string, std::string> saved_profiles_xml_;
   // Observer to get notified when network(s) have changed (e.g. connect).
   NetworkGuidListCallback networks_changed_observer_;
   // Observer to get notified when network list has changed (scan complete).
   NetworkGuidListCallback network_list_changed_observer_;
   // Saved value of network location wizard show value.
   scoped_ptr<DWORD> saved_nw_category_wizard_;
   // MessageLoopProxy to post events on UI thread.
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
@@ skipping 60 matching lines @@
     }
   }
 
   CheckError(error_code, kWiFiServiceError, error);
 }
 
 void WiFiServiceImpl::SetProperties(
     const std::string& network_guid,
     scoped_ptr<base::DictionaryValue> properties,
     std::string* error) {
-  // This method is not implemented in first version as it is not used by
-  // Google Cast extension.
-  CheckError(ERROR_CALL_NOT_IMPLEMENTED, kWiFiServiceError, error);
+  // Temporary preserve WiFi properties (desired frequency, wifi password to use
+  // in StartConnect.
+  DCHECK(properties->HasKey(onc::network_type::kWiFi));

[stevenjb, 2013/11/26 18:00:34]

This should set |error| instead of CHECK

[mef, 2013/11/26 19:00:13]

Done.

+  temporary_network_properties_.SetWithoutPathExpansion(network_guid,
+                                                        properties.release());
 }
 
 void WiFiServiceImpl::GetVisibleNetworks(ListValue* network_list) {
   DWORD error = EnsureInitialized();
 
   if (error == ERROR_SUCCESS) {
     NetworkList networks;
     error = GetVisibleNetworkList(&networks);
     if (error == ERROR_SUCCESS && !networks.empty()) {
       SortNetworks(&networks);
@@ skipping 15 matching lines @@
 }
 
 void WiFiServiceImpl::StartConnect(const std::string& network_guid,
                                    std::string* error) {
   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) {
-      Frequency frequency = kFrequencyAny;
+      Frequency frequency = GetDesiredFrequency(network_guid);
       // Connect only if network |network_guid| is not connected already.

[tbarzic, 2013/11/26 19:02:21]

is |network_guid| unique for (ssid, frequency) pair?
if not, this will not handle the case where we are connected to 2.4G band and
want to connect to the 5G band (for the same ssid).

[mef, 2013/11/27 18:00:03]

Good point, done. Currently connected band is not readily available, but I think
I've figured it out.

       if (network_guid != connected_network_guid)
         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()) {
           DisableNwCategoryWizard();
           // Disable automatic network change notifications as they get fired
           // when network is just connected, but not yet accessible (doesn't
@@ skipping 566 matching lines @@
   }
 
   // clean up
   if (available_network_list != NULL) {
     WlanFreeMemory_function_(available_network_list);
   }
 
   return error;
 }
 
+WiFiService::Frequency WiFiServiceImpl::GetDesiredFrequency(

[stevenjb, 2013/11/26 18:00:34]

GetConnectFrequency or GetFrequencyForConnect?

[mef, 2013/11/26 19:00:13]

Done.

+    const std::string& network_guid) {
+  // Check whether desired frequency is set in |temporary_network_properties_|.
+  DictionaryValue* properties;
+  DictionaryValue* wifi;
+  int frequency;
+  if (temporary_network_properties_.GetDictionaryWithoutPathExpansion(
+          network_guid,
+          &properties) &&

[stevenjb, 2013/11/26 18:00:34]

nit: OK (and a little clearer imho) to combine these two lines.

[mef, 2013/11/26 19:00:13]

Done.

+      properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
+      wifi->GetInteger(onc::wifi::kFrequency, &frequency)) {

[tbarzic, 2013/11/26 19:02:21]

should frequency be normalized (here or in SetProperties)?

[mef, 2013/11/27 18:00:03]

Done.

+    return static_cast<Frequency>(frequency);
+  }
+  return kFrequencyAny;
+}
+
 DWORD WiFiServiceImpl::GetDesiredBssList(
     DOT11_SSID& ssid,
     Frequency frequency,
     scoped_ptr<DOT11_BSSID_LIST>* desired_list) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   desired_list->reset();
@@ skipping 64 matching lines @@
     }
   }
 
   // clean up
   if (bss_list != NULL) {
     WlanFreeMemory_function_(bss_list);
   }
   return error;
 }
 
-
 DWORD WiFiServiceImpl::Connect(const std::string& network_guid,
                                Frequency frequency) {
   if (client_ == NULL) {
     NOTREACHED();
     return ERROR_NOINTERFACE;
   }
 
   DWORD error = ERROR_SUCCESS;
   DOT11_SSID ssid = SSIDFromGUID(network_guid);
   scoped_ptr<DOT11_BSSID_LIST> desired_bss_list;
@@ skipping 122 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