Credential passing for WifiManager in Windows

chrome/browser/local_discovery/wifi/wifi_manager_nonchromeos.cc

 // 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 "chrome/browser/local_discovery/wifi/wifi_manager_nonchromeos.h"
 
 #include "base/cancelable_callback.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "components/onc/onc_constants.h"
 #include "components/wifi/wifi_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/network_change_notifier.h"
 
+#if defined(OS_WIN)
+#include "chrome/browser/local_discovery/wifi/credential_getter_win.h"
+#endif  // OS_WIN
+
 using ::wifi::WiFiService;
 
 namespace local_discovery {
 
 namespace wifi {
 
 namespace {
 
 const int kConnectionTimeoutSeconds = 10;
 
@@ skipping 64 matching lines @@
   bool IsConnected(const std::string& network_guid);
 
   void OnConnectToNetworkTimeout();
 
   void PostClosure(const base::Closure& closure);
 
   bool FindAndConfigureNetwork(const std::string& ssid,
                                const std::string& password,
                                std::string* network_guid);
 
+#if defined(OS_WIN)
+  void PostCredentialsCallback(const WifiManager::CredentialsCallback& callback,
+                               const std::string& ssid,
+                               bool success,
+                               const std::string& password);
+#endif  // OS_WIN
+
   scoped_ptr<WiFiService> wifi_service_;
 
   base::WeakPtr<WifiManagerNonChromeos> wifi_manager_;
 
   WifiManager::SuccessCallback connect_success_callback_;
   base::CancelableClosure connect_failure_callback_;
 
   // SSID of previously connected network.
   std::string connected_network_guid_;
 
   // SSID of network we are connecting to.
   std::string connecting_network_guid_;
 
   scoped_refptr<base::MessageLoopProxy> callback_runner_;
 
   base::WeakPtrFactory<WifiServiceWrapper> weak_factory_;
 
+#if defined(OS_WIN)
+  scoped_refptr<CredentialGetterWin> credential_getter_;
+#endif  // OS_WIN
+
   DISALLOW_COPY_AND_ASSIGN(WifiServiceWrapper);
 };
 
 WifiManagerNonChromeos::WifiServiceWrapper::WifiServiceWrapper(
     base::WeakPtr<WifiManagerNonChromeos> wifi_manager)
     : wifi_manager_(wifi_manager),
       callback_runner_(base::MessageLoopProxy::current()),
       weak_factory_(this) {
 }
 
@@ skipping 153 matching lines @@
 
 void WifiManagerNonChromeos::WifiServiceWrapper::RequestNetworkCredentials(
     const std::string& network_guid,
     const WifiManager::CredentialsCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
   bool success = true;
   std::string ssid;
   std::string key;
 
-#if defined(OS_WIN)
-  NOTIMPLEMENTED();
-  success = false;
-#else
   base::DictionaryValue properties;
   std::string error_string;
   wifi_service_->GetProperties(network_guid, &properties, &error_string);
 
   if (!error_string.empty()) {
     LOG(ERROR) << "Could not get network properties: " << error_string;
     success = false;
   }
 
   if (!properties.GetString(onc::network_config::kName, &ssid)) {
     LOG(ERROR) << "Could not get network SSID";
     success = false;
   }
 
-  if (success) {
+  if (!success) {
+    PostClosure(base::Bind(callback, success, "", ""));
+    return;
+  }
+
+#if defined(OS_WIN)
+  credential_getter_ = new CredentialGetterWin();
+  credential_getter_->StartGetCredentials(
+      network_guid,
+      base::Bind(&WifiServiceWrapper::PostCredentialsCallback,
+                 AsWeakPtr(),
+                 callback,
+                 ssid));
+#else
     wifi_service_->GetKeyFromSystem(network_guid, &key, &error_string);
 
     if (!error_string.empty()) {
       LOG(ERROR) << "Could not get key from system: " << error_string;
       success = false;
     }
-  }
+
+    PostClosure(base::Bind(callback, success, ssid, key));
 #endif  // OS_WIN
-  PostClosure(base::Bind(callback, success, ssid, key));
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::OnNetworkChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   wifi_service_->RequestConnectedNetworkUpdate();
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::GetSSIDListInternal(
     NetworkPropertiesList* ssid_list) {
   base::ListValue visible_networks;
@@ skipping 80 matching lines @@
   return true;
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::PostClosure(
     const base::Closure& closure) {
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiManagerNonChromeos::PostClosure, wifi_manager_, closure));
 }
 
+#if defined(OS_WIN)
+
+void WifiManagerNonChromeos::WifiServiceWrapper::PostCredentialsCallback(
+    const WifiManager::CredentialsCallback& callback,
+    const std::string& ssid,
+    bool success,
+    const std::string& password) {
+  PostClosure(base::Bind(callback, success, ssid, password));
+}
+
+#endif  // OS_WIN
+
 scoped_ptr<WifiManager> WifiManager::CreateDefault() {
   return scoped_ptr<WifiManager>(new WifiManagerNonChromeos());
 }
 
 WifiManagerNonChromeos::WifiManagerNonChromeos()
     : wifi_wrapper_(NULL), weak_factory_(this) {
 }
 
 WifiManagerNonChromeos::~WifiManagerNonChromeos() {
   if (wifi_wrapper_) {
@@ skipping 94 matching lines @@
 }
 
 void WifiManagerNonChromeos::RemoveNetworkListObserver(
     NetworkListObserver* observer) {
   network_list_observers_.RemoveObserver(observer);
 }
 
 }  // namespace wifi
 
 }  // namespace local_discovery