Differentiate between 'connect-failed' and 'bad-passphrase'

chromeos/network/network_connection_handler.cc

 // Copyright (c) 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 "chromeos/network/network_connection_handler.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 100 matching lines @@
     "passphrase-required";
 const char NetworkConnectionHandler::kErrorActivationRequired[] =
     "activation-required";
 const char NetworkConnectionHandler::kErrorCertificateRequired[] =
     "certificate-required";
 const char NetworkConnectionHandler::kErrorConfigurationRequired[] =
     "configuration-required";
 const char NetworkConnectionHandler::kErrorAuthenticationRequired[] =
     "authentication-required";
 const char NetworkConnectionHandler::kErrorShillError[] = "shill-error";
-const char NetworkConnectionHandler::kErrorConnectFailed[] = "connect-failed";
 const char NetworkConnectionHandler::kErrorConfigureFailed[] =
     "configure-failed";
-const char NetworkConnectionHandler::kErrorActivateFailed[] =
-    "activate-failed";
-const char NetworkConnectionHandler::kErrorMissingProvider[] =
-    "missing-provider";
 const char NetworkConnectionHandler::kErrorConnectCanceled[] =
     "connect-canceled";
-const char NetworkConnectionHandler::kErrorUnknown[] = "unknown-error";
 
 struct NetworkConnectionHandler::ConnectRequest {
   ConnectRequest(const std::string& service_path,
                  const base::Closure& success,
                  const network_handler::ErrorCallback& error)
       : service_path(service_path),
         connect_state(CONNECT_REQUESTED),
         success_callback(success),
         error_callback(error) {
   }
@@ skipping 106 matching lines @@
       return;
     }
     if (NetworkRequiresActivation(network)) {
       InvokeErrorCallback(service_path, error_callback,
                           kErrorActivationRequired);
       return;
     }
 
     if (check_error_state) {
       const std::string& error = network->error();
-      if (error == flimflam::kErrorConnectFailed) {
-        InvokeErrorCallback(
-            service_path, error_callback, kErrorPassphraseRequired);
-        return;
-      }
       if (error == flimflam::kErrorBadPassphrase) {
-        InvokeErrorCallback(
-            service_path, error_callback, kErrorPassphraseRequired);
+        InvokeErrorCallback(service_path, error_callback, error);
         return;
       }
       if (IsAuthenticationError(error)) {
         InvokeErrorCallback(
             service_path, error_callback, kErrorAuthenticationRequired);
         return;
       }
     }
   }
 
@@ skipping 108 matching lines @@
     // "Provider.Type", etc keys (which are used only to set the values).
     const base::DictionaryValue* provider_properties;
     if (service_properties.GetDictionaryWithoutPathExpansion(
             flimflam::kProviderProperty, &provider_properties)) {
       provider_properties->GetStringWithoutPathExpansion(
           flimflam::kTypeProperty, &vpn_provider_type);
       provider_properties->GetStringWithoutPathExpansion(
           flimflam::kHostProperty, &vpn_provider_host);
     }
     if (vpn_provider_type.empty() || vpn_provider_host.empty()) {
-      ErrorCallbackForPendingRequest(service_path, kErrorMissingProvider);
+      ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
       return;
     }
     // VPN requires a host and username to be set.
     if (!VPNIsConfigured(
             service_path, vpn_provider_type, *provider_properties)) {
       NET_LOG_ERROR("VPN Not Configured", service_path);
       ErrorCallbackForPendingRequest(service_path, kErrorConfigurationRequired);
       return;
     }
   }
@@ skipping 152 matching lines @@
     const std::string& dbus_error_message) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("HandleShillConnectFailure called with no pending request.",
                   service_path);
     return;
   }
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   network_handler::ShillErrorCallbackFunction(
-      kErrorConnectFailed, service_path, error_callback,
+      flimflam::kErrorConnectFailed, service_path, error_callback,
       dbus_error_name, dbus_error_message);
 }
 
 void NetworkConnectionHandler::CheckPendingRequest(
     const std::string service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   DCHECK(request);
   if (request->connect_state == ConnectRequest::CONNECT_REQUESTED)
     return;  // Request has not started, ignore update
   const NetworkState* network =
@@ skipping 19 matching lines @@
   }
 
   // Network is neither connecting or connected; an error occurred.
   std::string error_name, error_detail;
   if (network->connection_state() == flimflam::kStateIdle &&
       pending_requests_.size() > 1) {
     // Another connect request canceled this one.
     error_name = kErrorConnectCanceled;
     error_detail = "";
   } else {
-    error_name = kErrorConnectFailed;
+    error_name = flimflam::kErrorConnectFailed;
     error_detail = network->error();
     if (error_detail.empty()) {
       if (network->connection_state() == flimflam::kStateFailure)
         error_detail = flimflam::kUnknownString;
       else
         error_detail = "Unexpected State: " + network->connection_state();
     }
   }
   std::string error_msg = error_name + ": " + error_detail;
   NET_LOG_ERROR(error_msg, service_path);
@@ skipping 58 matching lines @@
 
 void NetworkConnectionHandler::HandleShillDisconnectSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Disconnect Request Sent", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos