Added function to get list of networks with prefetched passwords

chrome/browser/extensions/api/gcd_private/gcd_private_api.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/extensions/api/gcd_private/gcd_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/stringprintf.h"
@@ skipping 267 matching lines @@
                                 const std::string& api,
                                 const base::DictionaryValue& input,
                                 MessageResponseCallback callback) {
   const base::DictionaryValue* input_actual = &input;
 #if defined(ENABLE_WIFI_BOOTSTRAPPING)
   scoped_ptr<base::DictionaryValue> input_cloned;
 
   if (api == kPrivatAPISetup) {
     const base::DictionaryValue* wifi = NULL;
 
-    if (input.GetDictionary(kPrivetKeyWifi, &wifi) &&
-        !wifi->HasKey(kPrivetKeyPassphrase)) {
-      // If the message is a setup message, has a wifi section, try sending the
-      // passphrase.
+    if (input.GetDictionary(kPrivetKeyWifi, &wifi)) {
       std::string ssid;
 
       if (!wifi->GetString(kPrivetKeySSID, &ssid)) {
         callback.Run(gcd_private::STATUS_SETUPPARSEERROR,
                      base::DictionaryValue());
         return;
       }
 
-      PasswordMap::iterator found = wifi_passwords_.find(ssid);
-      if (found == wifi_passwords_.end()) {
-        callback.Run(gcd_private::STATUS_WIFIPASSWORDERROR,
-                     base::DictionaryValue());
-        return;
+      if (!wifi->HasKey(kPrivetKeyPassphrase)) {
+        // If the message is a setup message, has a wifi section, try sending
+        // the passphrase.
+
+        PasswordMap::iterator found = wifi_passwords_.find(ssid);
+        if (found == wifi_passwords_.end()) {
+          callback.Run(gcd_private::STATUS_WIFIPASSWORDERROR,
+                       base::DictionaryValue());
+          return;
+        }
+
+        input_cloned.reset(input.DeepCopy());
+        input_cloned->SetString(kPrivetKeyPassphraseDotted, found->second);
+        input_actual = input_cloned.get();
       }
-
-      input_cloned.reset(input.DeepCopy());
-      input_cloned->SetString(kPrivetKeyPassphraseDotted, found->second);
-      input_actual = input_cloned.get();
     }
   }
 #endif
 
   GCDSessionMap::iterator found = sessions_.find(session_id);
 
   if (found == sessions_.end()) {
     callback.Run(gcd_private::STATUS_UNKNOWNSESSIONERROR,
                  base::DictionaryValue());
     return;
@@ skipping 33 matching lines @@
     wifi_manager_->Start();
   }
 }
 
 #endif
 
 void GcdPrivateAPI::RemoveSession(int session_id) {
   sessions_.erase(session_id);
 }
 
+scoped_ptr<base::ListValue> GcdPrivateAPI::GetPrefetchedSSIDList() {
+  scoped_ptr<base::ListValue> retval(new base::ListValue);
+
+#if defined(ENABLE_WIFI_BOOTSTRAPPING)
+  for (PasswordMap::iterator i = wifi_passwords_.begin();
+       i != wifi_passwords_.end();
+       i++) {
+    retval->AppendString(i->first);
+  }
+#endif
+
+  return retval.Pass();
+}
+
 // static
 void GcdPrivateAPI::SetGCDApiFlowFactoryForTests(
     GCDApiFlowFactoryForTests* factory) {
   g_gcd_api_flow_factory = factory;
 }
 
 GcdPrivateRequest::GcdPrivateRequest(
     const std::string& api,
     const base::DictionaryValue& input,
     const GcdPrivateAPI::MessageResponseCallback& callback,
@@ skipping 187 matching lines @@
 }
 
 GcdPrivateQueryForNewLocalDevicesFunction::
     ~GcdPrivateQueryForNewLocalDevicesFunction() {
 }
 
 bool GcdPrivateQueryForNewLocalDevicesFunction::RunSync() {
   GcdPrivateAPI* gcd_api =
       BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
 
-  if (!gcd_api)
-    return false;
 
   if (!gcd_api->QueryForDevices()) {
     error_ =
         "You must first subscribe to onDeviceStateChanged or onDeviceRemoved "
         "notifications";
     return false;
   }
 
   return true;
 }
@@ skipping 42 matching lines @@
 bool GcdPrivateEstablishSessionFunction::RunAsync() {
   scoped_ptr<gcd_private::EstablishSession::Params> params =
       gcd_private::EstablishSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPI* gcd_api =
       BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
 
-  if (!gcd_api)
-    return false;
 
   gcd_api->EstablishSession(
       params->ip_address,
       params->port,
       base::Bind(&GcdPrivateEstablishSessionFunction::OnConfirmCodeCallback,
                  this));
 
   return true;
 }
 
@@ skipping 16 matching lines @@
 bool GcdPrivateConfirmCodeFunction::RunAsync() {
   scoped_ptr<gcd_private::ConfirmCode::Params> params =
       gcd_private::ConfirmCode::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPI* gcd_api =
       BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
 
-  if (!gcd_api)
-    return false;
 
   gcd_api->ConfirmCode(
       params->session_id,
       base::Bind(&GcdPrivateConfirmCodeFunction::OnSessionEstablishedCallback,
                  this));
 
   return true;
 }
 
 void GcdPrivateConfirmCodeFunction::OnSessionEstablishedCallback(
@@ skipping 11 matching lines @@
 bool GcdPrivateSendMessageFunction::RunAsync() {
   scoped_ptr<gcd_private::PassMessage::Params> params =
       gcd_private::PassMessage::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPI* gcd_api =
       BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
 
-  if (!gcd_api)
-    return false;
 
   gcd_api->SendMessage(
       params->session_id,
       params->api,
       params->input.additional_properties,
       base::Bind(&GcdPrivateSendMessageFunction::OnMessageSentCallback, this));
 
   return true;
 }
 
@@ skipping 16 matching lines @@
 bool GcdPrivateTerminateSessionFunction::RunAsync() {
   scoped_ptr<gcd_private::TerminateSession::Params> params =
       gcd_private::TerminateSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPI* gcd_api =
       BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
 
-  if (!gcd_api)
-    return false;
 
   gcd_api->RemoveSession(params->session_id);
 
   SendResponse(true);
   return true;
 }
 
 GcdPrivateGetCommandDefinitionsFunction::
     GcdPrivateGetCommandDefinitionsFunction() {
 }
 
 GcdPrivateGetCommandDefinitionsFunction::
     ~GcdPrivateGetCommandDefinitionsFunction() {
 }
 
+GcdPrivateGetPrefetchedWifiNameListFunction::
+    GcdPrivateGetPrefetchedWifiNameListFunction() {
+}
+
+GcdPrivateGetPrefetchedWifiNameListFunction::
+    ~GcdPrivateGetPrefetchedWifiNameListFunction() {
+}
+
+bool GcdPrivateGetPrefetchedWifiNameListFunction::RunSync() {
+  GcdPrivateAPI* gcd_api =
+      BrowserContextKeyedAPIFactory<GcdPrivateAPI>::Get(GetProfile());
+
+  DCHECK(gcd_api);
+  scoped_ptr<base::ListValue> ssid_list = gcd_api->GetPrefetchedSSIDList();
+
+  SetResult(ssid_list.release());
+
+  return true;
+}
+
 bool GcdPrivateGetCommandDefinitionsFunction::RunAsync() {
   return false;
 }
 
 GcdPrivateInsertCommandFunction::GcdPrivateInsertCommandFunction() {
 }
 
 GcdPrivateInsertCommandFunction::~GcdPrivateInsertCommandFunction() {
 }
 
@@ skipping 25 matching lines @@
 }
 
 GcdPrivateGetCommandsListFunction::~GcdPrivateGetCommandsListFunction() {
 }
 
 bool GcdPrivateGetCommandsListFunction::RunAsync() {
   return false;
 }
 
 }  // namespace extensions