Merge 220596 "Differentiate between 'connect-failed' and 'bad-pa..."

ash/system/chromeos/network/network_connect.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 "ash/system/chromeos/network/network_connect.h"
 
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_observer.h"
 #include "ash/system/chromeos/network/network_state_notifier.h"
 #include "ash/system/tray/system_tray_delegate.h"
@@ skipping 48 matching lines @@
 void OnConnectFailed(const std::string& service_path,
                      gfx::NativeWindow owning_window,
                      const std::string& error_name,
                      scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Connect Failed: " + error_name, service_path);
 
   // If a new connect attempt canceled this connect, no need to notify the user.
   if (error_name == NetworkConnectionHandler::kErrorConnectCanceled)
     return;
 
-  if (error_name == NetworkConnectionHandler::kErrorPassphraseRequired ||
+  if (error_name == flimflam::kErrorBadPassphrase ||
+      error_name == NetworkConnectionHandler::kErrorPassphraseRequired ||
       error_name == NetworkConnectionHandler::kErrorConfigurationRequired ||
       error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) {
     ash::Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
         service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorCertificateRequired) {
     ash::Shell::GetInstance()->system_tray_delegate()->EnrollOrConfigureNetwork(
         service_path, owning_window);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorActivationRequired) {
     network_connect::ActivateCellular(service_path);
     return;
   }
 
   if (error_name == NetworkConnectionHandler::kErrorConnected ||
       error_name == NetworkConnectionHandler::kErrorConnecting) {
     ash::Shell::GetInstance()->system_tray_delegate()->ShowNetworkSettings(
         service_path);
     return;
   }
 
   // ConnectFailed or unknown error; show a notification.
   ShowErrorNotification(error_name, service_path);
 
   // Show a configure dialog for ConnectFailed errors.
-  if (error_name != NetworkConnectionHandler::kErrorConnectFailed)
+  if (error_name != flimflam::kErrorConnectFailed)
     return;
 
   // If Shill reports an InProgress error, don't try to configure the network.
   std::string dbus_error_name;
   error_data.get()->GetString(
       chromeos::network_handler::kDbusErrorName, &dbus_error_name);
   if (dbus_error_name == kErrorInProgress)
     return;
 
   ash::Shell::GetInstance()->system_tray_delegate()->ConfigureNetwork(
@@ skipping 20 matching lines @@
       NetworkObserver::ERROR_CONNECT_FAILED);
 
   NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
       service_path,
       base::Bind(&OnConnectSucceeded, service_path),
       base::Bind(&OnConnectFailed, service_path, owning_window),
       check_error_state);
 }
 
 void OnActivateFailed(const std::string& service_path,
-                     const std::string& error_name,
+                      const std::string& error_name,
                       scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Unable to activate network", service_path);
-  ShowErrorNotification(
-      NetworkConnectionHandler::kErrorActivateFailed, service_path);
+  ShowErrorNotification(network_connect::kErrorActivateFailed, service_path);
 }
 
 void OnActivateSucceeded(const std::string& service_path) {
   NET_LOG_USER("Activation Succeeded", service_path);
 }
 
 void OnConfigureFailed(const std::string& error_name,
                        scoped_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Unable to configure network", "");
   ShowErrorNotification(NetworkConnectionHandler::kErrorConfigureFailed, "");
@@ skipping 84 matching lines @@
       base::Bind(&ClearPropertiesAndConnect,
                  service_path,
                  properties_to_clear),
       base::Bind(&SetPropertiesFailed, "SetProperties", service_path));
 }
 
 }  // namespace
 
 namespace network_connect {
 
+const char kErrorActivateFailed[] = "activate-failed";
+
 void ConnectToNetwork(const std::string& service_path,
                       gfx::NativeWindow owning_window) {
   const bool check_error_state = true;
   CallConnectToNetwork(service_path, check_error_state, owning_window);
 }
 
 void ActivateCellular(const std::string& service_path) {
   NET_LOG_USER("ActivateCellular", service_path);
   const NetworkState* cellular =
       NetworkHandler::Get()->network_state_handler()->
@@ skipping 131 matching lines @@
   if (StringToLowerASCII(error) ==
       StringToLowerASCII(std::string(flimflam::kUnknownString))) {
     return l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
   }
   return l10n_util::GetStringFUTF16(IDS_NETWORK_UNRECOGNIZED_ERROR,
                                     UTF8ToUTF16(error));
 }
 
 }  // network_connect
 }  // ash