Show notifications for Network Config errors

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 101 matching lines @@
 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 103 matching lines @@
   }
   if (network->IsConnectingState()) {
     InvokeErrorCallback(service_path, error_callback, kErrorConnecting);
     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);
+      return;
+    }
+
+    if (IsAuthenticationError(error)) {
+      InvokeErrorCallback(
+          service_path, error_callback, kErrorAuthenticationRequired);
+      return;
+    }
+  }
+
   // All synchronous checks passed, add |service_path| to connecting list.
   pending_requests_.insert(std::make_pair(
       service_path,
       ConnectRequest(service_path, success_callback, error_callback)));
 
   // Connect immediately to 'connectable' networks.
   // TODO(stevenjb): Shill needs to properly set Connectable for VPN.
   if (network->connectable() && network->type() != flimflam::kTypeVPN) {
     CallShillConnect(service_path);
     return;
@@ skipping 76 matching lines @@
 }
 
 // ConnectToNetwork implementation
 
 void NetworkConnectionHandler::VerifyConfiguredAndConnect(
     bool check_error_state,
     const std::string& service_path,
     const base::DictionaryValue& service_properties) {
   NET_LOG_EVENT("VerifyConfiguredAndConnect", service_path);
 
-  std::string type;
-  service_properties.GetStringWithoutPathExpansion(
-      flimflam::kTypeProperty, &type);
-
-  if (check_error_state) {
-    std::string error;
-    service_properties.GetStringWithoutPathExpansion(
-        flimflam::kErrorProperty, &error);
-    if (error == flimflam::kErrorConnectFailed) {
-      ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired);
-      return;
-    }
-    if (error == flimflam::kErrorBadPassphrase) {
-      ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired);
-      return;
-    }
-
-    if (IsAuthenticationError(error)) {
-      ErrorCallbackForPendingRequest(service_path,
-                                     kErrorAuthenticationRequired);
-      return;
-    }
-  }
-
   // If 'passphrase_required' is still true, then the 'Passphrase' property
   // has not been set to a minimum length value.
   bool passphrase_required = false;
   service_properties.GetBooleanWithoutPathExpansion(
       flimflam::kPassphraseRequiredProperty, &passphrase_required);
   if (passphrase_required) {
     ErrorCallbackForPendingRequest(service_path, kErrorPassphraseRequired);
     return;
   }
 
+  std::string type;
+  service_properties.GetStringWithoutPathExpansion(
+      flimflam::kTypeProperty, &type);
+
   // Get VPN provider type and host (required for configuration) and ensure
   // that required VPN non-cert properties are set.
   std::string vpn_provider_type, vpn_provider_host;
   if (type == flimflam::kTypeVPN) {
     // VPN Provider values are read from the "Provider" dictionary, not the
     // "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(
@@ skipping 146 matching lines @@
 
 void NetworkConnectionHandler::HandleConfigurationFailure(
     const std::string& service_path,
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   ConnectRequest* request = pending_request(service_path);
   DCHECK(request);
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   if (!error_callback.is_null())
-    error_callback.Run(error_name, error_data.Pass());
+    error_callback.Run(kErrorConfigureFailed, error_data.Pass());
 }
 
 void NetworkConnectionHandler::HandleShillConnectSuccess(
     const std::string& service_path) {
   ConnectRequest* request = pending_request(service_path);
   DCHECK(request);
   request->connect_state = ConnectRequest::CONNECT_STARTED;
   NET_LOG_EVENT("Connect Request Acknowledged", service_path);
   // Do not call success_callback here, wait for one of the following
   // conditions:
@@ skipping 38 matching lines @@
     pending_requests_.erase(service_path);
     return;
   }
   if (network->connection_state() == flimflam::kStateIdle &&
       request->connect_state != ConnectRequest::CONNECT_CONNECTING) {
     // Connection hasn't started yet, keep waiting.
     return;
   }
 
   // Network is neither connecting or connected; an error occurred.
-  std::string error_name = kErrorConnectFailed;
-  std::string 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_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_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);
 
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   if (error_callback.is_null())
     return;
   scoped_ptr<base::DictionaryValue> error_data(
       network_handler::CreateErrorData(service_path, error_name, error_msg));
@@ skipping 74 matching lines @@
 
 void NetworkConnectionHandler::HandleShillActivateSuccess(
     const std::string& service_path,
     const base::Closure& success_callback) {
   NET_LOG_EVENT("Activate Request Sent", service_path);
   if (!success_callback.is_null())
     success_callback.Run();
 }
 
 }  // namespace chromeos