WiFi client for GCD bootstrapping

components/wifi/wifi_service_mac.mm

 // Copyright 2014 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"
 
 #import <netinet/in.h>
 #import <CoreWLAN/CoreWLAN.h>
 #import <SystemConfiguration/SystemConfiguration.h>
 
 #include "base/bind.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/sys_string_conversions.h"
 #include "components/onc/onc_constants.h"
+#include "components/wifi/network_properties.h"
 
 #if !defined(MAC_OS_X_VERSION_10_7) || \
     MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
 
 // Local definitions of API added in Mac OS X 10.7
 
 @interface CWInterface (LionAPI)
 - (BOOL)associateToNetwork:(CWNetwork*)network
                   password:(NSString*)password
                      error:(NSError**)error;
@@ skipping 46 matching lines @@
   virtual void SetProperties(const std::string& network_guid,
                              scoped_ptr<base::DictionaryValue> properties,
                              std::string* error) OVERRIDE;
 
   virtual void CreateNetwork(bool shared,
                              scoped_ptr<base::DictionaryValue> properties,
                              std::string* network_guid,
                              std::string* error) OVERRIDE;
 
   virtual void GetVisibleNetworks(const std::string& network_type,
-                                  base::ListValue* network_list) OVERRIDE;
+                                  base::ListValue* network_list,
+                                  bool include_details) OVERRIDE;
 
   virtual void RequestNetworkScan() OVERRIDE;
 
   virtual void StartConnect(const std::string& network_guid,
                             std::string* error) OVERRIDE;
 
   virtual void StartDisconnect(const std::string& network_guid,
                                std::string* error) OVERRIDE;
 
   virtual void GetKeyFromSystem(const std::string& network_guid,
@@ skipping 24 matching lines @@
     return base::SysNSStringToUTF8(ssid);
   }
 
   // Populates |properties| from |network|.
   void NetworkPropertiesFromCWNetwork(const CWNetwork* network,
                                       NetworkProperties* properties) const;
 
   // Converts |CWSecurityMode| into onc::wifi::k{WPA|WEP}* security constant.
   std::string SecurityFromCWSecurityMode(CWSecurityMode security) const;
 
-  // Converts |CWChannelBand| into WiFiService::Frequency constant.
+  // Converts |CWChannelBand| into Frequency constant.
   Frequency FrequencyFromCWChannelBand(CWChannelBand band) const;
 
   // Gets current |onc::connection_state| for given |network_guid|.
   std::string GetNetworkConnectionState(const std::string& network_guid) const;
 
   // Updates |networks_| with the list of visible wireless networks.
   void UpdateNetworks();
 
   // Find network by |network_guid| and return iterator to its entry in
   // |networks_|.
@@ skipping 105 matching lines @@
     network_properties_.SetWithoutPathExpansion(network_guid,
                                                 properties.release());
   }
 }
 
 void WiFiServiceMac::CreateNetwork(
     bool shared,
     scoped_ptr<base::DictionaryValue> properties,
     std::string* network_guid,
     std::string* error) {
-  WiFiService::NetworkProperties network_properties;
+  NetworkProperties network_properties;
   if (!network_properties.UpdateFromValue(*properties)) {
     *error = kErrorInvalidData;
     return;
   }
 
   std::string guid = network_properties.ssid;
   if (FindNetwork(guid) != networks_.end()) {
     *error = kErrorInvalidData;
     return;
   }
   network_properties_.SetWithoutPathExpansion(guid,
                                               properties.release());
   *network_guid = guid;
 }
 
 void WiFiServiceMac::GetVisibleNetworks(const std::string& network_type,
-                                        base::ListValue* network_list) {
+                                        base::ListValue* network_list,
+                                        bool include_details) {
   if (!network_type.empty() &&
       network_type != onc::network_type::kAllTypes &&
       network_type != onc::network_type::kWiFi) {
     return;
   }
 
   if (networks_.empty())
     UpdateNetworks();
 
-  for (WiFiService::NetworkList::const_iterator it = networks_.begin();
+  for (NetworkList::const_iterator it = networks_.begin();
        it != networks_.end();
        ++it) {
-    scoped_ptr<base::DictionaryValue> network(it->ToValue(true));
+    scoped_ptr<base::DictionaryValue> network(it->ToValue(!include_details));
     network_list->Append(network.release());
   }
 }
 
 void WiFiServiceMac::RequestNetworkScan() {
   DVLOG(1) << "*** RequestNetworkScan";
   UpdateNetworks();
 }
 
 void WiFiServiceMac::StartConnect(const std::string& network_guid,
@@ skipping 254 matching lines @@
     case kCWSecurityModeOpen:
       return onc::wifi::kNone;
     // TODO(mef): Figure out correct mapping.
     case kCWSecurityModeWPS:
     case kCWSecurityModeDynamicWEP:
       return onc::wifi::kWPA_EAP;
   }
   return onc::wifi::kWPA_EAP;
 }
 
-
-WiFiService::Frequency WiFiServiceMac::FrequencyFromCWChannelBand(
-    CWChannelBand band) const {
+Frequency WiFiServiceMac::FrequencyFromCWChannelBand(CWChannelBand band) const {
   return band == kCWChannelBand2GHz ? kFrequency2400 : kFrequency5000;
 }
 
-WiFiService::NetworkList::iterator WiFiServiceMac::FindNetwork(
+NetworkList::iterator WiFiServiceMac::FindNetwork(
     const std::string& network_guid) {
   for (NetworkList::iterator it = networks_.begin();
        it != networks_.end();
        ++it) {
     if (it->guid == network_guid)
       return it;
   }
   return networks_.end();
 }
 
@@ skipping 50 matching lines @@
   NetworkGuidList changed_networks(1, network_guid);
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(networks_changed_observer_, changed_networks));
 }
 
 // static
 WiFiService* WiFiService::Create() { return new WiFiServiceMac(); }
 
 }  // namespace wifi