WiFi client for GCD bootstrapping

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>
 
 #include <set>
 
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "components/onc/onc_constants.h"
+#include "components/wifi/network_properties.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 namespace {
 const wchar_t kNwCategoryWizardRegKey[] =
     L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Network\\"
     L"NwCategoryWizard";
 const wchar_t kNwCategoryWizardRegValue[] = L"Show";
 const wchar_t kNwCategoryWizardSavedRegValue[] = L"ShowSaved";
 const wchar_t kNwCategoryWizardDeleteRegValue[] = L"ShowDelete";
 const wchar_t kWlanApiDll[] = L"wlanapi.dll";
@@ skipping 162 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 357 matching lines @@
 
 void WiFiServiceImpl::CreateNetwork(
     bool shared,
     scoped_ptr<base::DictionaryValue> properties,
     std::string* network_guid,
     std::string* error) {
   DWORD error_code = EnsureInitialized();
   if (CheckError(error_code, kErrorWiFiService, error))
     return;
 
-  WiFiService::NetworkProperties network_properties;
+  NetworkProperties network_properties;
   if (!network_properties.UpdateFromValue(*properties)) {
     CheckError(ERROR_INVALID_DATA, kErrorWiFiService, error);
     return;
   }
 
   network_properties.guid = network_properties.ssid;
   std::string profile_xml;
   if (!CreateProfile(network_properties, kEncryptionTypeAny, &profile_xml)) {
     CheckError(ERROR_INVALID_DATA, kErrorWiFiService, error);
     return;
@@ skipping 21 matching lines @@
     tkip_profile->SetString(kProfileXmlKey, tkip_profile_xml);
     tkip_profile->SetBoolean(kProfileSharedKey, shared);
     created_profiles_.SetWithoutPathExpansion(network_properties.guid,
                                               tkip_profile.release());
   }
 
   *network_guid = network_properties.guid;
 }
 
 void WiFiServiceImpl::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;
   }
 
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     NetworkList networks;
     error = GetVisibleNetworkList(&networks);
     if (error == ERROR_SUCCESS && !networks.empty()) {
       SortNetworks(&networks);
-      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 WiFiServiceImpl::RequestNetworkScan() {
   DWORD error = EnsureInitialized();
   if (error == ERROR_SUCCESS) {
     WlanScan_function_(client_, &interface_guid_, NULL, NULL, NULL);
@@ skipping 276 matching lines @@
                                  const std::string& error_name,
                                  std::string* error) const {
   if (error_code != ERROR_SUCCESS) {
     DLOG(ERROR) << "WiFiService Error " << error_code << ": " << error_name;
     *error = error_name;
     return true;
   }
   return false;
 }
 
-WiFiService::NetworkList::iterator WiFiServiceImpl::FindNetwork(
+NetworkList::iterator WiFiServiceImpl::FindNetwork(
     NetworkList& networks,
     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 500 matching lines @@
   // Clean up.
   if (wlan_connection_attributes != NULL)
     WlanFreeMemory_function_(wlan_connection_attributes);
 
   if (bss_list != NULL)
     WlanFreeMemory_function_(bss_list);
 
   return error;
 }
 
-WiFiService::Frequency WiFiServiceImpl::GetFrequencyToConnect(
+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) &&
       properties->GetDictionary(onc::network_type::kWiFi, &wifi) &&
       wifi->GetInteger(onc::wifi::kFrequency, &frequency)) {
     return GetNormalizedFrequency(frequency);
@@ skipping 75 matching lines @@
     }
   }
 
   // Clean up.
   if (bss_list != NULL) {
     WlanFreeMemory_function_(bss_list);
   }
   return error;
 }
 
-WiFiService::Frequency WiFiServiceImpl::GetNormalizedFrequency(
-    int frequency_in_mhz) const {
+Frequency WiFiServiceImpl::GetNormalizedFrequency(int frequency_in_mhz) const {
   if (frequency_in_mhz == 0)
     return kFrequencyAny;
   if (frequency_in_mhz < 3000)
     return kFrequency2400;
   return kFrequency5000;
 }
 
 DWORD WiFiServiceImpl::Connect(const std::string& network_guid,
                                Frequency frequency) {
   if (client_ == NULL) {
@@ skipping 268 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