Use NetworkConnectionObserver to trigger connect failure notifications

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/json/json_reader.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 14 matching lines @@
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/shill_property_util.h"
 #include "dbus/object_path.h"
 #include "net/cert/x509_certificate.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
-void InvokeErrorCallback(const std::string& service_path,
-                         const network_handler::ErrorCallback& error_callback,
-                         const std::string& error_name) {
-  NET_LOG_ERROR("Connect Error: " + error_name, service_path);
-  network_handler::RunErrorCallback(
-      error_callback, service_path, error_name, "");
-}
-
 bool IsAuthenticationError(const std::string& error) {
   return (error == shill::kErrorBadWEPKey ||
           error == shill::kErrorPppAuthFailed ||
           error == shill::kErrorEapLocalTlsFailed ||
           error == shill::kErrorEapRemoteTlsFailed ||
           error == shill::kErrorEapAuthenticationFailed);
 }
 
 bool VPNRequiresCredentials(const std::string& service_path,
                            const std::string& provider_type,
@@ skipping 48 matching lines @@
 }
 
 }  // namespace
 
 const char NetworkConnectionHandler::kErrorNotFound[] = "not-found";
 const char NetworkConnectionHandler::kErrorConnected[] = "connected";
 const char NetworkConnectionHandler::kErrorConnecting[] = "connecting";
 const char NetworkConnectionHandler::kErrorNotConnected[] = "not-connected";
 const char NetworkConnectionHandler::kErrorPassphraseRequired[] =
     "passphrase-required";
-const char NetworkConnectionHandler::kErrorActivationRequired[] =
-    "activation-required";
+const char NetworkConnectionHandler::kErrorBadPassphrase[] = "bad-passphrase";
 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::kErrorDisconnectFailed[] =
+    "disconnect-failed";
 const char NetworkConnectionHandler::kErrorConfigureFailed[] =
     "configure-failed";
 const char NetworkConnectionHandler::kErrorConnectCanceled[] =
     "connect-canceled";
 const char NetworkConnectionHandler::kErrorCertLoadTimeout[] =
     "cert-load-timeout";
 
 struct NetworkConnectionHandler::ConnectRequest {
   ConnectRequest(const std::string& service_path,
                  const std::string& profile_path,
@@ skipping 61 matching lines @@
   configuration_handler_ = network_configuration_handler;
   managed_configuration_handler_ = managed_network_configuration_handler;
 
   // After this point, the NetworkConnectionHandler is fully initialized (all
   // handler references set, observers registered, ...).
 
   if (LoginState::IsInitialized())
     LoggedInStateChanged();
 }
 
-void NetworkConnectionHandler::AddObserver(Observer* observer) {
+void NetworkConnectionHandler::AddObserver(
+    NetworkConnectionObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void NetworkConnectionHandler::RemoveObserver(Observer* observer) {
+void NetworkConnectionHandler::RemoveObserver(
+    NetworkConnectionObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void NetworkConnectionHandler::LoggedInStateChanged() {
   LoginState* login_state = LoginState::Get();
   if (logged_in_ || !login_state->IsUserLoggedIn())
     return;
 
   NET_LOG_EVENT("Logged In", "");
   logged_in_ = true;
   logged_in_time_ = base::TimeTicks::Now();
 }
 
 void NetworkConnectionHandler::OnCertificatesLoaded(
     const net::CertificateList& cert_list,
     bool initial_load) {
   certificates_loaded_ = true;
   NET_LOG_EVENT("Certificates Loaded", "");
   if (queued_connect_)
     ConnectToQueuedNetwork();
 }
 
 void NetworkConnectionHandler::ConnectToNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback,
     bool check_error_state) {
   NET_LOG_USER("ConnectToNetwork", service_path);
-  FOR_EACH_OBSERVER(Observer, observers_,
+  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
                     ConnectToNetworkRequested(service_path));
 
   // Clear any existing queued connect request.
   queued_connect_.reset();
   if (HasConnectingNetwork(service_path)) {
     NET_LOG_USER("Connect Request While Pending", service_path);
     InvokeErrorCallback(service_path, error_callback, kErrorConnecting);
     return;
   }
 
@@ skipping 11 matching lines @@
       return;
     }
     if (network->IsConnectingState()) {
       InvokeErrorCallback(service_path, error_callback, kErrorConnecting);
       return;
     }
 
     if (check_error_state) {
       const std::string& error = network->last_error();
       if (error == shill::kErrorBadPassphrase) {
-        InvokeErrorCallback(service_path, error_callback, error);
+        InvokeErrorCallback(service_path, error_callback, kErrorBadPassphrase);
         return;
       }
       if (IsAuthenticationError(error)) {
         InvokeErrorCallback(
             service_path, error_callback, kErrorAuthenticationRequired);
         return;
       }
     }
   }
 
@@ skipping 26 matching lines @@
                  AsWeakPtr(), check_error_state),
       base::Bind(&NetworkConnectionHandler::HandleConfigurationFailure,
                  AsWeakPtr(), service_path));
 }
 
 void NetworkConnectionHandler::DisconnectNetwork(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG_USER("DisconnectNetwork", service_path);
+  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
+                    DiconnectRequested(service_path));
+
   const NetworkState* network =
       network_state_handler_->GetNetworkState(service_path);
   if (!network) {
-    InvokeErrorCallback(service_path, error_callback, kErrorNotFound);
+    NET_LOG_ERROR("Disconnect Error: Not Found", service_path);
+    network_handler::RunErrorCallback(
+        error_callback, service_path, kErrorNotFound, "");
     return;
   }
   if (!network->IsConnectedState() && !network->IsConnectingState()) {
-    InvokeErrorCallback(service_path, error_callback, kErrorNotConnected);
+    NET_LOG_ERROR("Disconnect Error: Not Connected", service_path);
+    network_handler::RunErrorCallback(
+        error_callback, service_path, kErrorNotConnected, "");
     return;
   }
   pending_requests_.erase(service_path);
   CallShillDisconnect(service_path, success_callback, error_callback);
 }
 
 bool NetworkConnectionHandler::HasConnectingNetwork(
     const std::string& service_path) {
   return pending_requests_.count(service_path) != 0;
 }
@@ skipping 273 matching lines @@
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("HandleConfigurationFailure called with no pending request.",
                   service_path);
     return;
   }
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
-  if (!error_callback.is_null())
-    error_callback.Run(kErrorConfigureFailed, error_data.Pass());
+  InvokeErrorCallback(service_path, error_callback, kErrorConfigureFailed);
 }
 
 void NetworkConnectionHandler::HandleShillConnectSuccess(
     const std::string& service_path) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("HandleShillConnectSuccess called with no pending request.",
                   service_path);
     return;
   }
@@ skipping 11 matching lines @@
     const std::string& dbus_error_name,
     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(
-      shill::kErrorConnectFailed, service_path, error_callback,
-      dbus_error_name, dbus_error_message);
+  std::string error;
+  if (dbus_error_name == shill::kErrorResultAlreadyConnected) {
+    error = kErrorConnected;
+  } else if (dbus_error_name == shill::kErrorResultInProgress) {
+    error = kErrorConnecting;
+  } else {
+    NET_LOG_ERROR("Connect Failure, Shill error: " + dbus_error_name,
+                  service_path);
+    error = kErrorConnectFailed;
+  }
+  InvokeErrorCallback(service_path, error_callback, error);
 }
 
 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 =
       network_state_handler_->GetNetworkState(service_path);
   if (!network)
     return;  // NetworkState may not be be updated yet.
 
   if (network->IsConnectingState()) {
     request->connect_state = ConnectRequest::CONNECT_CONNECTING;
     return;
   }
   if (network->IsConnectedState()) {
-    NET_LOG_EVENT("Connect Request Succeeded", service_path);
     if (!request->profile_path.empty()) {
       // If a profile path was specified, set it on a successful connection.
       configuration_handler_->SetNetworkProfile(
           service_path,
           request->profile_path,
           NetworkConfigurationObserver::SOURCE_USER_ACTION,
           base::Bind(&base::DoNothing),
           chromeos::network_handler::ErrorCallback());
     }
-    if (!request->success_callback.is_null())
-      request->success_callback.Run();
+    InvokeSuccessCallback(request->service_path, request->success_callback);
     pending_requests_.erase(service_path);
     return;
   }
   if (network->connection_state() == shill::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;  // 'Canceled' or 'Failed'
   if (network->connection_state() == shill::kStateIdle &&
       pending_requests_.size() > 1) {
     // Another connect request canceled this one.
     error_name = kErrorConnectCanceled;
   } else {
-    error_name = shill::kErrorConnectFailed;
+    error_name = kErrorConnectFailed;
     if (network->connection_state() != shill::kStateFailure) {
       NET_LOG_ERROR("Unexpected State: " + network->connection_state(),
                     service_path);
     }
   }
 
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
-  if (error_callback.is_null()) {
-    NET_LOG_ERROR("Connect Error, no callback: " + error_name, service_path);
-    return;
-  }
   InvokeErrorCallback(service_path, error_callback, error_name);
 }
 
 void NetworkConnectionHandler::CheckAllPendingRequests() {
   for (std::map<std::string, ConnectRequest>::iterator iter =
            pending_requests_.begin(); iter != pending_requests_.end(); ++iter) {
     CheckPendingRequest(iter->first);
   }
 }
 
+// Connect callbacks
+
+void NetworkConnectionHandler::InvokeSuccessCallback(
+    const std::string& service_path,
+    const base::Closure& success_callback) {
+  NET_LOG_EVENT("Connect Request Succeeded", service_path);
+  if (!success_callback.is_null())
+    success_callback.Run();
+  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
+                    ConnectSucceeded(service_path));
+}
+
 void NetworkConnectionHandler::ErrorCallbackForPendingRequest(
     const std::string& service_path,
     const std::string& error_name) {
   ConnectRequest* request = GetPendingRequest(service_path);
   if (!request) {
     NET_LOG_ERROR("ErrorCallbackForPendingRequest with no pending request.",
                   service_path);
     return;
   }
   // Remove the entry before invoking the callback in case it triggers a retry.
   network_handler::ErrorCallback error_callback = request->error_callback;
   pending_requests_.erase(service_path);
   InvokeErrorCallback(service_path, error_callback, error_name);
 }
 
+void NetworkConnectionHandler::InvokeErrorCallback(
+    const std::string& service_path,
+    const network_handler::ErrorCallback& error_callback,
+    const std::string& error_name) {
+  NET_LOG_ERROR("Connect Failure: " + error_name, service_path);
+  network_handler::RunErrorCallback(
+      error_callback, service_path, error_name, "");
+  FOR_EACH_OBSERVER(NetworkConnectionObserver, observers_,
+                    ConnectFailed(service_path, error_name));
+}
+
 // Disconnect
 
 void NetworkConnectionHandler::CallShillDisconnect(
     const std::string& service_path,
     const base::Closure& success_callback,
     const network_handler::ErrorCallback& error_callback) {
   NET_LOG_USER("Disconnect Request", service_path);
   DBusThreadManager::Get()->GetShillServiceClient()->Disconnect(
       dbus::ObjectPath(service_path),
       base::Bind(&NetworkConnectionHandler::HandleShillDisconnectSuccess,
                  AsWeakPtr(), service_path, success_callback),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
-                 kErrorShillError, service_path, error_callback));
+                 kErrorDisconnectFailed, service_path, error_callback));
 }
 
 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