Detect user initiated network connection failures.

chrome/browser/chromeos/cros/network_library.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 "chrome/browser/chromeos/cros/network_library.h"
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"  // for debug output only.
@@ skipping 200 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Network
 
 Network::Network(const std::string& service_path,
                  ConnectionType type)
     : state_(STATE_UNKNOWN),
       error_(ERROR_NO_ERROR),
       connectable_(true),
-      connection_started_(false),
+      user_connect_state_(USER_CONNECT_NONE),
       is_active_(false),
       priority_(kPriorityNotSet),
       auto_connect_(false),
       save_credentials_(false),
       priority_order_(0),
       added_(false),
       notify_failure_(false),
       profile_type_(PROFILE_NONE),
       service_path_(service_path),
       type_(type) {
@@ skipping 72 matching lines @@
       // Transition STATE_IDLE -> STATE_FAILURE sometimes happens on resume
       // but is not an actual failure as network device is not ready yet.
       notify_failure_ = true;
       // Normally error_ should be set, but if it is not we need to set it to
       // something here so that the retry logic will be triggered.
       if (error_ == ERROR_NO_ERROR) {
         VLOG(2) << "Detected NO_ERROR error state.  Setting to UNKNOWN.";
         error_ = ERROR_UNKNOWN;
       }
     }
-  } else if (new_state == STATE_IDLE && IsConnectingState(old_state)
-             && connection_started()) {
+    if (user_connect_state() == USER_CONNECT_STARTED)
+      set_user_connect_state(USER_CONNECT_FAILED);
+  } else if (new_state == STATE_IDLE && IsConnectingState(old_state) &&
+             user_connect_state() == USER_CONNECT_STARTED) {
     // If we requested a connect and never went through a connected state,
     // treat it as a failure.
     VLOG(1) << service_path() << ": Inferring Failure state.";
     notify_failure_ = true;
     error_ = ERROR_UNKNOWN;
+    if (user_connect_state() == USER_CONNECT_STARTED)
+      set_user_connect_state(USER_CONNECT_FAILED);
   } else if (new_state != STATE_UNKNOWN) {
     notify_failure_ = false;
     // State changed, so refresh IP address.
     InitIPAddress();
+    if (user_connect_state() == USER_CONNECT_STARTED) {
+      if (IsConnectedState(new_state)) {
+        set_user_connect_state(USER_CONNECT_CONNECTED);
+      } else if (!IsConnectingState(new_state)) {
+        LOG(WARNING) << "Connection started and State -> " << GetStateString();
+        set_user_connect_state(USER_CONNECT_FAILED);
+      }
+    }
   }
   VLOG(1) << name() << ".State [" << service_path() << "]: " << GetStateString()
           << " (was: " << ConnectionStateString(old_state) << ")";
-  if (!IsConnectingState(new_state) && new_state != STATE_UNKNOWN)
-    set_connection_started(false);
 }
 
 void Network::SetError(ConnectionError error) {
   error_ = error;
   if (error == ERROR_NO_ERROR)
     notify_failure_ = false;
 }
 
 void Network::SetName(const std::string& name) {
   std::string name_utf8;
@@ skipping 145 matching lines @@
     case ERROR_HTTP_GET_FAILED:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ERROR_HTTP_GET_FAILED);
     case ERROR_IPSEC_PSK_AUTH_FAILED:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ERROR_IPSEC_PSK_AUTH_FAILED);
     case ERROR_IPSEC_CERT_AUTH_FAILED:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ERROR_IPSEC_CERT_AUTH_FAILED);
     case ERROR_PPP_AUTH_FAILED:
+    case ERROR_EAP_AUTHENTICATION_FAILED:
+    case ERROR_EAP_LOCAL_TLS_FAILED:
+    case ERROR_EAP_REMOTE_TLS_FAILED:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ERROR_PPP_AUTH_FAILED);
     case ERROR_UNKNOWN:
       return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
   }
   return l10n_util::GetStringUTF8(IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED);
 }
 
 void Network::SetProxyConfig(const std::string& proxy_config) {
   SetOrClearStringProperty(
@@ skipping 710 matching lines @@
     case SECURITY_PSK:
       return "PSK";
   }
   return "Unknown";
 }
 
 bool WifiNetwork::IsPassphraseRequired() const {
   if (encryption_ == SECURITY_NONE)
     return false;
   // A connection failure might be due to a bad passphrase.
-  if (error() == ERROR_BAD_PASSPHRASE || error() == ERROR_BAD_WEPKEY ||
-      error() == ERROR_UNKNOWN)
+  if (error() == ERROR_BAD_PASSPHRASE ||
+      error() == ERROR_BAD_WEPKEY ||
+      error() == ERROR_PPP_AUTH_FAILED ||
+      error() == ERROR_EAP_LOCAL_TLS_FAILED ||
+      error() == ERROR_EAP_REMOTE_TLS_FAILED ||
+      error() == ERROR_EAP_AUTHENTICATION_FAILED ||
+      error() == ERROR_CONNECT_FAILED ||
+      error() == ERROR_UNKNOWN) {
+    VLOG(1) << "Authentication Error: " << GetErrorString();
     return true;
-  // For 802.1x networks, configuration is required if connectable is false
-  // unless we're using a certificate pattern.
-  if (encryption_ == SECURITY_8021X) {
-    if (eap_method_ != EAP_METHOD_TLS ||
-        client_cert_type() != CLIENT_CERT_TYPE_PATTERN)
-      return !connectable();
+  }
+  // If the user initiated a conenction and it failed, request credentials in

[Greg Spencer (Chromium), 2013/01/10 00:39:42]

conenction -> connection

+  // case it is a credentials error and Shill was unable to detect it.
+  if (user_connect_state() == USER_CONNECT_FAILED)
+    return true;
+  // WEP/WPA/RSN and PSK networks rely on the PassphraseRequired property.
+  if (encryption_ != SECURITY_8021X)
+    return passphrase_required_;
+  // For 802.1x networks, if we are using a certificate pattern we do not
+  // need any credentials.
+  if (eap_method_ == EAP_METHOD_TLS &&
+      client_cert_type() == CLIENT_CERT_TYPE_PATTERN) {
     return false;
   }
-  return passphrase_required_;
+  // Connectable will be false if 802.1x credentials are not set
+  return !connectable();
 }
 
 bool WifiNetwork::RequiresUserProfile() const {
   // 8021X requires certificates which are only stored for individual users.
   if (encryption_ != SECURITY_8021X)
     return false;
 
   if (eap_method_ != EAP_METHOD_TLS)
     return false;
 
@@ skipping 99 matching lines @@
   NetworkLibrary* impl;
   if (stub)
     impl = new NetworkLibraryImplStub();
   else
     impl = new NetworkLibraryImplCros();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos