Use NetworkConnectionObserver to trigger connect failure notifications

ui/chromeos/network/network_state_notifier.cc

 // Copyright (c) 2012 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 "ui/chromeos/network/network_state_notifier.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
@@ skipping 82 matching lines @@
 
 NetworkStateNotifier::NetworkStateNotifier(NetworkConnect* network_connect)
     : network_connect_(network_connect),
       did_show_out_of_credits_(false),
       weak_ptr_factory_(this) {
   if (!NetworkHandler::IsInitialized())
     return;
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   handler->AddObserver(this, FROM_HERE);
   UpdateDefaultNetwork(handler->DefaultNetwork());
+  NetworkHandler::Get()->network_connection_handler()->AddObserver(this);
 }
 
 NetworkStateNotifier::~NetworkStateNotifier() {
   if (!NetworkHandler::IsInitialized())
     return;
   NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
                                                                  FROM_HERE);
+  NetworkHandler::Get()->network_connection_handler()->RemoveObserver(this);
+}
+
+void NetworkStateNotifier::ConnectFailed(const std::string& service_path,
+                                         const std::string& error_name) {
+  // Only show a notification for certain errors. Other failures are expected
+  // to be handled by the UI that initiated the connect request.
+  // Note: kErrorConnectFailed may also cause the configure dialog to be
+  // displayed, but we rely on the notification system to show additional
+  // details if available.
+  if (error_name != NetworkConnectionHandler::kErrorConnectFailed &&
+      error_name != NetworkConnectionHandler::kErrorNotFound &&
+      error_name != NetworkConnectionHandler::kErrorConfigureFailed &&
+      error_name != NetworkConnectionHandler::kErrorCertLoadTimeout) {
+    return;
+  }
+  ShowNetworkConnectError(error_name, service_path);
 }
 
 void NetworkStateNotifier::DefaultNetworkChanged(const NetworkState* network) {
   if (!UpdateDefaultNetwork(network))
     return;
   // If the default network changes to another network, allow the out of
   // credits notification to be shown again. A delay prevents the notification
   // from being shown too frequently (see below).
   if (network)
     did_show_out_of_credits_ = false;
@@ skipping 189 matching lines @@
                     service_path);
       if (shill_error.empty())
         shill_error = network->last_error();
     }
 
     if (ShillErrorIsIgnored(shill_error)) {
       NET_LOG_DEBUG("Notify Ignoring error: " + error_name, service_path);
       return;
     }
 
-    error = network_connect_->GetErrorString(shill_error, service_path);
+    error = network_connect_->GetShillErrorString(shill_error, service_path);
     if (error.empty())
       error = l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
   }
   NET_LOG_ERROR("Notify connect error: " + base::UTF16ToUTF8(error),
                 service_path);
 
   std::string network_name =
       chromeos::shill_property_util::GetNameFromProperties(service_path,
                                                            shill_properties);
   std::string network_error_details;
@@ skipping 26 matching lines @@
       base::Bind(&NetworkStateNotifier::ShowNetworkSettings,
                  weak_ptr_factory_.GetWeakPtr(), service_path));
 }
 
 void NetworkStateNotifier::ShowNetworkSettings(
     const std::string& service_path) {
   network_connect_->ShowNetworkSettings(service_path);
 }
 
 }  // namespace ui