Configure networks requiring a certificate.

chromeos/network/network_connection_handler.h

 // 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.
 
 #ifndef CHROMEOS_NETWORK_NETWORK_CONNECTION_HANDLER_H_
 #define CHROMEOS_NETWORK_NETWORK_CONNECTION_HANDLER_H_
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
+#include "chromeos/login/login_state.h"
+#include "chromeos/network/cert_loader.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "chromeos/network/network_state_handler_observer.h"
 
 namespace chromeos {
 
 class NetworkState;
+class NetworkUIData;
 
 // The NetworkConnectionHandler class is used to manage network connection
 // requests. This is the only class that should make Shill Connect calls.
 // It handles the following steps:
 // 1. Determine whether or not sufficient information (e.g. passphrase) is
 //    known to be available to connect to the network.
 // 2. Request additional information (e.g. user data which contains certificate
 //    information) and determine whether sufficient information is available.
-// 3. Send the connect request.
-// 4. Wait for the network state to change to a non connecting state.
-// 5. Invoke the appropriate callback (always) on success or failure.
+// 3. Possibly configure the network certificate info (tpm slot and pkcs11 id).
+// 4. Send the connect request.
+// 5. Wait for the network state to change to a non connecting state.
+// 6. Invoke the appropriate callback (always) on success or failure.
 //
 // NetworkConnectionHandler depends on NetworkStateHandler for immediately
 // available State information, and NetworkConfigurationHandler for any
 // configuration calls.
 
 class CHROMEOS_EXPORT NetworkConnectionHandler
-    : public NetworkStateHandlerObserver,
+    : public LoginState::Observer,
+      public CertLoader::Observer,
+      public NetworkStateHandlerObserver,
       public base::SupportsWeakPtr<NetworkConnectionHandler> {
  public:
   // Constants for |error_name| from |error_callback| for Connect.
   static const char kErrorNotFound[];
   static const char kErrorConnected[];
   static const char kErrorConnecting[];
   static const char kErrorPassphraseRequired[];
   static const char kErrorActivationRequired[];
   static const char kErrorCertificateRequired[];
   static const char kErrorConfigurationRequired[];
@@ skipping 37 matching lines @@
                          const network_handler::ErrorCallback& error_callback);
 
   // Returns true if ConnectToNetwork has been called with |service_path| and
   // has not completed (i.e. success or error callback has been called).
   bool HasConnectingNetwork(const std::string& service_path);
 
   // NetworkStateHandlerObserver
   virtual void NetworkListChanged() OVERRIDE;
   virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE;
 
+  // LoginState::Observer
+  virtual void LoggedInStateChanged(LoginState::LoggedInState state) OVERRIDE;
+
+  // CertLoader::Observer
+  virtual void OnCertificatesLoaded(const net::CertificateList& cert_list,
+                                    bool initial_load) OVERRIDE;
+
  private:
   friend class NetworkHandler;
   friend class NetworkConnectionHandlerTest;
 
   struct ConnectRequest;
 
   NetworkConnectionHandler();
 
-  void Init(NetworkStateHandler* network_state_handler,
+  void Init(CertLoader* cert_loader,
+            NetworkStateHandler* network_state_handler,
             NetworkConfigurationHandler* network_configuration_handler);
 
   ConnectRequest* pending_request(const std::string& service_path);
 
   // Callback from Shill.Service.GetProperties. Parses |properties| to verify
   // whether or not the network appears to be configured. If configured,
   // attempts a connection, otherwise invokes error_callback from
   // pending_requests_[service_path].
   void VerifyConfiguredAndConnect(const std::string& service_path,
                                   const base::DictionaryValue& properties);
 
   // Calls Shill.Manager.Connect asynchronously.
   void CallShillConnect(const std::string& service_path);
 
   // Handle failure from ConfigurationHandler calls.
   void HandleConfigurationFailure(
       const std::string& service_path,
       const std::string& error_name,
       scoped_ptr<base::DictionaryValue> error_data);
 
   // Handle success or failure from Shill.Service.Connect.
   void HandleShillConnectSuccess(const std::string& service_path);
   void HandleShillConnectFailure(const std::string& service_path,
                                  const std::string& error_name,
                                  const std::string& error_message);
 
   void CheckPendingRequest(const std::string service_path);
   void CheckAllPendingRequests();
+  bool CertificateIsConfigured(NetworkUIData* ui_data, std::string* pkcs11_id);
+  void ErrorCallbackForPendingRequest(const std::string& service_path,
+                                      const std::string& error_name);
 
   // Calls Shill.Manager.Disconnect asynchronously.
   void CallShillDisconnect(
       const std::string& service_path,
       const base::Closure& success_callback,
       const network_handler::ErrorCallback& error_callback);
 
   // Handle success or failure from Shill.Service.Disconnect.
   void HandleShillDisconnectSuccess(const std::string& service_path,
                                     const base::Closure& success_callback);
   void HandleShillDisconnectFailure(
       const std::string& service_path,
       const network_handler::ErrorCallback& error_callback,
       const std::string& error_name,
       const std::string& error_message);
 
   // Local references to the associated handler instances.
+  CertLoader* cert_loader_;
   NetworkStateHandler* network_state_handler_;
   NetworkProfileHandler* network_profile_handler_;
   NetworkConfigurationHandler* network_configuration_handler_;
 
-  // Map of pending connect requests, used to prevent repeat attempts while
+  // Map of pending connect requests, used to prevent repeated attempts while
   // waiting for Shill and to trigger callbacks on eventual success or failure.
   std::map<std::string, ConnectRequest> pending_requests_;
+  scoped_ptr<ConnectRequest> queued_connect_;
+
+  // Track certificate loading state.
+  bool logged_in_;
+  bool certificates_loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_NETWORK_NETWORK_CONNECTION_HANDLER_H_