Revert of 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/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 118 matching lines @@
   void SendMessage(int session_id,
                    const std::string& api,
                    const base::DictionaryValue& input,
                    MessageResponseCallback callback);
 
   void RequestWifiPassword(const std::string& ssid,
                            const SuccessCallback& callback);
 
   void RemoveSession(int session_id);
 
-  scoped_ptr<base::ListValue> GetPrefetchedSSIDList();
-
  private:
   typedef std::map<std::string /* id_string */,
                    linked_ptr<api::gcd_private::GCDDevice> > GCDDeviceMap;
 
   typedef std::map<int /* session id*/, linked_ptr<GcdPrivateSessionHolder> >
       GCDSessionMap;
 
   typedef std::map<std::string /* ssid */, std::string /* password */>
       PasswordMap;
 
@@ skipping 235 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)) {
+    if (input.GetDictionary(kPrivetKeyWifi, &wifi) &&
+        !wifi->HasKey(kPrivetKeyPassphrase)) {
+      // If the message is a setup message, has a wifi section, try sending the
+      // passphrase.
       std::string ssid;
 
       if (!wifi->GetString(kPrivetKeySSID, &ssid)) {
         callback.Run(gcd_private::STATUS_SETUPPARSEERROR,
                      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;
+      }
 
-        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 34 matching lines @@
     wifi_manager_->Start();
   }
 }
 
 #endif
 
 void GcdPrivateAPIImpl::RemoveSession(int session_id) {
   sessions_.erase(session_id);
 }
 
-scoped_ptr<base::ListValue> GcdPrivateAPIImpl::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();
-}
-
 GcdPrivateRequest::GcdPrivateRequest(
     const std::string& api,
     const base::DictionaryValue& input,
     const GcdPrivateAPIImpl::MessageResponseCallback& callback,
     GcdPrivateSessionHolder* session_holder)
     : api_(api),
       input_(input.DeepCopy()),
       callback_(callback),
       session_holder_(session_holder) {
 }
@@ skipping 199 matching lines @@
     GcdPrivateQueryForNewLocalDevicesFunction() {
 }
 
 GcdPrivateQueryForNewLocalDevicesFunction::
     ~GcdPrivateQueryForNewLocalDevicesFunction() {
 }
 
 bool GcdPrivateQueryForNewLocalDevicesFunction::RunSync() {
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::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;
 }
 
 GcdPrivatePrefetchWifiPasswordFunction::
     GcdPrivatePrefetchWifiPasswordFunction() {
 }
 
 GcdPrivatePrefetchWifiPasswordFunction::
     ~GcdPrivatePrefetchWifiPasswordFunction() {
 }
 
 bool GcdPrivatePrefetchWifiPasswordFunction::RunAsync() {
   scoped_ptr<gcd_private::PrefetchWifiPassword::Params> params =
       gcd_private::PrefetchWifiPassword::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
+  if (!gcd_api)
+    return false;
+
   gcd_api->RequestWifiPassword(
       params->ssid,
       base::Bind(&GcdPrivatePrefetchWifiPasswordFunction::OnResponse, this));
 
   return true;
 }
 
 void GcdPrivatePrefetchWifiPasswordFunction::OnResponse(bool response) {
   scoped_ptr<base::FundamentalValue> response_value(
       new base::FundamentalValue(response));
   SetResult(response_value.release());
   SendResponse(true);
 }
 
 GcdPrivateEstablishSessionFunction::GcdPrivateEstablishSessionFunction() {
 }
 
 GcdPrivateEstablishSessionFunction::~GcdPrivateEstablishSessionFunction() {
 }
 
 bool GcdPrivateEstablishSessionFunction::RunAsync() {
   scoped_ptr<gcd_private::EstablishSession::Params> params =
       gcd_private::EstablishSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
+  if (!gcd_api)
+    return false;
+
   gcd_api->EstablishSession(
       params->ip_address,
       params->port,
       base::Bind(&GcdPrivateEstablishSessionFunction::OnConfirmCodeCallback,
                  this));
 
   return true;
 }
 
 void GcdPrivateEstablishSessionFunction::OnConfirmCodeCallback(
@@ skipping 14 matching lines @@
 
 bool GcdPrivateConfirmCodeFunction::RunAsync() {
   scoped_ptr<gcd_private::ConfirmCode::Params> params =
       gcd_private::ConfirmCode::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
 
+  if (!gcd_api)
+    return false;
+
   gcd_api->ConfirmCode(
       params->session_id,
       base::Bind(&GcdPrivateConfirmCodeFunction::OnSessionEstablishedCallback,
                  this));
 
   return true;
 }
 
 void GcdPrivateConfirmCodeFunction::OnSessionEstablishedCallback(
     api::gcd_private::Status status) {
   results_ = gcd_private::ConfirmCode::Results::Create(status);
   SendResponse(true);
 }
 
 GcdPrivateSendMessageFunction::GcdPrivateSendMessageFunction() {
 }
 
 GcdPrivateSendMessageFunction::~GcdPrivateSendMessageFunction() {
 }
 
 bool GcdPrivateSendMessageFunction::RunAsync() {
   scoped_ptr<gcd_private::PassMessage::Params> params =
       gcd_private::PassMessage::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::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 15 matching lines @@
 
 bool GcdPrivateTerminateSessionFunction::RunAsync() {
   scoped_ptr<gcd_private::TerminateSession::Params> params =
       gcd_private::TerminateSession::Params::Create(*args_);
 
   if (!params)
     return false;
 
   GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::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() {
-  GcdPrivateAPIImpl* gcd_api = GcdPrivateAPIImpl::Get(GetProfile());
-
-  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