| // Copyright (c) 2011 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/options/wifi_config_view.h" |
| |
| #include "base/command_line.h" // TODO(jamescook): Remove. |
| #include "base/string_util.h" |
| #include "base/utf_string_conversions.h" |
| #include "chrome/browser/chromeos/cros/cros_library.h" |
| #include "chrome/browser/chromeos/login/user_manager.h" |
| #include "chrome/browser/chromeos/options/wifi_config_model.h" |
| #include "chrome/common/chrome_switches.h" // TODO(jamescook): Remove. |
| #include "grit/chromium_strings.h" |
| #include "grit/generated_resources.h" |
| #include "grit/locale_settings.h" |
| #include "grit/theme_resources.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/base/resource/resource_bundle.h" |
| #include "views/controls/button/checkbox.h" |
| #include "views/controls/button/image_button.h" |
| #include "views/controls/button/native_button.h" |
| #include "views/controls/label.h" |
| #include "views/controls/textfield/textfield.h" |
| #include "views/layout/grid_layout.h" |
| #include "views/layout/layout_constants.h" |
| #include "views/window/window.h" |
| |
| namespace chromeos { |
| |
| namespace { |
| |
| enum SecurityComboboxIndex { |
| SECURITY_INDEX_NONE = 0, |
| SECURITY_INDEX_WEP = 1, |
| SECURITY_INDEX_WPA = 2, |
| SECURITY_INDEX_RSN = 3, |
| SECURITY_INDEX_COUNT = 4 |
| }; |
| |
| class SecurityComboboxModel : public ui::ComboboxModel { |
| public: |
| SecurityComboboxModel() {} |
| virtual ~SecurityComboboxModel() {} |
| virtual int GetItemCount() { |
| return SECURITY_INDEX_COUNT; |
| } |
| virtual string16 GetItemAt(int index) { |
| if (index == SECURITY_INDEX_NONE) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_NONE); |
| else if (index == SECURITY_INDEX_WEP) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_WEP); |
| else if (index == SECURITY_INDEX_WPA) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_WPA); |
| else if (index == SECURITY_INDEX_RSN) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_RSN); |
| NOTREACHED(); |
| return string16(); |
| } |
| private: |
| DISALLOW_COPY_AND_ASSIGN(SecurityComboboxModel); |
| }; |
| |
| // TODO(jamescook): For M12 we only expose PEAP and EAP-TTLS. Later, when |
| // when we support all methods by default, order this list to be alphabetical. |
| enum EAPMethodComboboxIndex { |
| EAP_METHOD_INDEX_NONE = 0, |
| EAP_METHOD_INDEX_PEAP = 1, |
| EAP_METHOD_INDEX_TTLS = 2, // By default we support up to here. |
| EAP_METHOD_INDEX_TLS = 3, |
| EAP_METHOD_INDEX_LEAP = 4, // Flag "--enable-all-eap" allows up to here. |
| EAP_METHOD_INDEX_COUNT = 5 |
| }; |
| |
| class EAPMethodComboboxModel : public ui::ComboboxModel { |
| public: |
| EAPMethodComboboxModel() {} |
| virtual ~EAPMethodComboboxModel() {} |
| virtual int GetItemCount() { |
| // TODO(jamescook): For M12 we only expose PEAP and EAP-TTLS by default. |
| // Remove this switch when all methods are supported. |
| if (!CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableExperimentalEap)) |
| return EAP_METHOD_INDEX_TTLS + 1; |
| return EAP_METHOD_INDEX_COUNT; |
| } |
| virtual string16 GetItemAt(int index) { |
| if (index == EAP_METHOD_INDEX_NONE) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EAP_METHOD_NONE); |
| else if (index == EAP_METHOD_INDEX_PEAP) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EAP_METHOD_PEAP); |
| else if (index == EAP_METHOD_INDEX_TLS) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EAP_METHOD_TLS); |
| else if (index == EAP_METHOD_INDEX_TTLS) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EAP_METHOD_TTLS); |
| else if (index == EAP_METHOD_INDEX_LEAP) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EAP_METHOD_LEAP); |
| NOTREACHED(); |
| return string16(); |
| } |
| private: |
| DISALLOW_COPY_AND_ASSIGN(EAPMethodComboboxModel); |
| }; |
| |
| enum Phase2AuthComboboxIndex { |
| PHASE_2_AUTH_INDEX_AUTO = 0, // LEAP, EAP-TLS have only this auth. |
| PHASE_2_AUTH_INDEX_MD5 = 1, |
| PHASE_2_AUTH_INDEX_MSCHAPV2 = 2, // PEAP has up to this auth. |
| PHASE_2_AUTH_INDEX_MSCHAP = 3, |
| PHASE_2_AUTH_INDEX_PAP = 4, |
| PHASE_2_AUTH_INDEX_CHAP = 5, // EAP-TTLS has up to this auth. |
| PHASE_2_AUTH_INDEX_COUNT = 6 |
| }; |
| |
| class Phase2AuthComboboxModel : public ui::ComboboxModel { |
| public: |
| explicit Phase2AuthComboboxModel(views::Combobox* eap_method_combobox) |
| : eap_method_combobox_(eap_method_combobox) {} |
| virtual ~Phase2AuthComboboxModel() {} |
| virtual int GetItemCount() { |
| switch (eap_method_combobox_->selected_item()) { |
| case EAP_METHOD_INDEX_NONE: |
| case EAP_METHOD_INDEX_TLS: |
| case EAP_METHOD_INDEX_LEAP: |
| return PHASE_2_AUTH_INDEX_AUTO + 1; |
| case EAP_METHOD_INDEX_PEAP: |
| return PHASE_2_AUTH_INDEX_MSCHAPV2 + 1; |
| case EAP_METHOD_INDEX_TTLS: |
| return PHASE_2_AUTH_INDEX_CHAP + 1; |
| } |
| NOTREACHED(); |
| return 0; |
| } |
| virtual string16 GetItemAt(int index) { |
| if (index == PHASE_2_AUTH_INDEX_AUTO) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH_AUTO); |
| else if (index == PHASE_2_AUTH_INDEX_MD5) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH_MD5); |
| else if (index == PHASE_2_AUTH_INDEX_MSCHAPV2) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH_MSCHAPV2); |
| else if (index == PHASE_2_AUTH_INDEX_MSCHAP) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH_MSCHAP); |
| else if (index == PHASE_2_AUTH_INDEX_PAP) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH_PAP); |
| else if (index == PHASE_2_AUTH_INDEX_CHAP) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH_CHAP); |
| NOTREACHED(); |
| return string16(); |
| } |
| private: |
| views::Combobox* eap_method_combobox_; |
| DISALLOW_COPY_AND_ASSIGN(Phase2AuthComboboxModel); |
| }; |
| |
| // Combobox that supports a preferred width. Used by Server CA combobox |
| // because the strings inside it are too wide. |
| class ComboboxWithWidth : public views::Combobox { |
| public: |
| ComboboxWithWidth(ui::ComboboxModel* model, int width) |
| : Combobox(model), |
| width_(width) { |
| } |
| virtual ~ComboboxWithWidth() {} |
| virtual gfx::Size GetPreferredSize() OVERRIDE { |
| gfx::Size size = Combobox::GetPreferredSize(); |
| size.set_width(width_); |
| return size; |
| } |
| private: |
| int width_; |
| DISALLOW_COPY_AND_ASSIGN(ComboboxWithWidth); |
| }; |
| |
| class ServerCACertComboboxModel : public ui::ComboboxModel { |
| public: |
| explicit ServerCACertComboboxModel(WifiConfigModel* wifi_config_model) |
| : wifi_config_model_(wifi_config_model) { |
| } |
| virtual ~ServerCACertComboboxModel() {} |
| virtual int GetItemCount() { |
| // First "Default", then the certs, then "Do not check". |
| return wifi_config_model_->GetServerCaCertCount() + 2; |
| } |
| virtual string16 GetItemAt(int combo_index) { |
| if (combo_index == 0) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_SERVER_CA_DEFAULT); |
| if (combo_index == GetItemCount() - 1) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_SERVER_CA_DO_NOT_CHECK); |
| int cert_index = combo_index - 1; |
| return wifi_config_model_->GetServerCaCertName(cert_index); |
| } |
| private: |
| WifiConfigModel* wifi_config_model_; |
| DISALLOW_COPY_AND_ASSIGN(ServerCACertComboboxModel); |
| }; |
| |
| class ClientCertComboboxModel : public ui::ComboboxModel { |
| public: |
| explicit ClientCertComboboxModel(WifiConfigModel* wifi_config_model) |
| : wifi_config_model_(wifi_config_model) { |
| } |
| virtual ~ClientCertComboboxModel() {} |
| virtual int GetItemCount() { |
| // One initial item "None", then the certs. |
| return 1 + wifi_config_model_->GetUserCertCount(); |
| } |
| virtual string16 GetItemAt(int combo_index) { |
| if (combo_index == 0) |
| return l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_NONE); |
| int cert_index = combo_index - 1; |
| return wifi_config_model_->GetUserCertName(cert_index); |
| } |
| private: |
| WifiConfigModel* wifi_config_model_; |
| DISALLOW_COPY_AND_ASSIGN(ClientCertComboboxModel); |
| }; |
| |
| } // namespace |
| |
| WifiConfigView::WifiConfigView(NetworkConfigView* parent, WifiNetwork* wifi) |
| : ChildNetworkConfigView(parent, wifi), |
| wifi_config_model_(new WifiConfigModel()), |
| is_8021x_(false), |
| ssid_textfield_(NULL), |
| eap_method_combobox_(NULL), |
| phase_2_auth_label_(NULL), |
| phase_2_auth_combobox_(NULL), |
| client_cert_label_(NULL), |
| client_cert_combobox_(NULL), |
| server_ca_cert_label_(NULL), |
| server_ca_cert_combobox_(NULL), |
| identity_label_(NULL), |
| identity_textfield_(NULL), |
| identity_anonymous_label_(NULL), |
| identity_anonymous_textfield_(NULL), |
| save_credentials_checkbox_(NULL), |
| security_combobox_(NULL), |
| passphrase_label_(NULL), |
| passphrase_textfield_(NULL), |
| passphrase_visible_button_(NULL), |
| error_label_(NULL) { |
| Init(wifi); |
| } |
| |
| WifiConfigView::WifiConfigView(NetworkConfigView* parent) |
| : ChildNetworkConfigView(parent), |
| wifi_config_model_(new WifiConfigModel()), |
| is_8021x_(false), |
| ssid_textfield_(NULL), |
| eap_method_combobox_(NULL), |
| phase_2_auth_label_(NULL), |
| phase_2_auth_combobox_(NULL), |
| client_cert_label_(NULL), |
| client_cert_combobox_(NULL), |
| server_ca_cert_label_(NULL), |
| server_ca_cert_combobox_(NULL), |
| identity_label_(NULL), |
| identity_textfield_(NULL), |
| identity_anonymous_label_(NULL), |
| identity_anonymous_textfield_(NULL), |
| save_credentials_checkbox_(NULL), |
| security_combobox_(NULL), |
| passphrase_label_(NULL), |
| passphrase_textfield_(NULL), |
| passphrase_visible_button_(NULL), |
| error_label_(NULL) { |
| Init(NULL); |
| } |
| |
| WifiConfigView::~WifiConfigView() { |
| } |
| |
| string16 WifiConfigView::GetTitle() { |
| return l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_JOIN_WIFI_NETWORKS); |
| } |
| |
| bool WifiConfigView::CanLogin() { |
| static const size_t kMinWirelessPasswordLen = 5; |
| |
| if (service_path_.empty()) { |
| // Enforce ssid is non empty. |
| if (GetSSID().empty()) |
| return false; |
| |
| // If security is not none, also enforce passphrase is non empty. |
| if (security_combobox_->selected_item() != SECURITY_INDEX_NONE && |
| passphrase_textfield_->text().length() < kMinWirelessPasswordLen) |
| return false; |
| } else { |
| if (is_8021x_) { |
| // Make sure the EAP method is set |
| if (eap_method_combobox_->selected_item() == EAP_METHOD_INDEX_NONE) |
| return false; |
| } else { |
| // if the network requires a passphrase, make sure it is the right length. |
| if (passphrase_textfield_ != NULL && |
| passphrase_textfield_->text().length() < kMinWirelessPasswordLen) |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void WifiConfigView::UpdateDialogButtons() { |
| parent_->GetDialogClientView()->UpdateDialogButtons(); |
| } |
| |
| void WifiConfigView::RefreshEAPFields() { |
| int selected = eap_method_combobox_->selected_item(); |
| |
| // If EAP method changes, the phase 2 auth choices may have changed also. |
| phase_2_auth_combobox_->ModelChanged(); |
| phase_2_auth_combobox_->SetSelectedItem(0); |
| phase_2_auth_combobox_->SetEnabled( |
| phase_2_auth_combobox_->model()->GetItemCount() > 1); |
| phase_2_auth_label_->SetEnabled(phase_2_auth_combobox_->IsEnabled()); |
| |
| // No password for EAP-TLS |
| passphrase_textfield_->SetEnabled(selected != EAP_METHOD_INDEX_NONE && |
| selected != EAP_METHOD_INDEX_TLS); |
| passphrase_label_->SetEnabled(passphrase_textfield_->IsEnabled()); |
| if (!passphrase_textfield_->IsEnabled()) |
| passphrase_textfield_->SetText(string16()); |
| |
| // Client certs only for EAP-TLS |
| if (client_cert_combobox_) { |
| client_cert_combobox_->SetEnabled(selected == EAP_METHOD_INDEX_TLS); |
| client_cert_label_->SetEnabled(client_cert_combobox_->IsEnabled()); |
| } |
| |
| // No server CA certs for LEAP |
| server_ca_cert_combobox_->SetEnabled(selected != EAP_METHOD_INDEX_NONE && |
| selected != EAP_METHOD_INDEX_LEAP); |
| server_ca_cert_label_->SetEnabled(server_ca_cert_combobox_->IsEnabled()); |
| |
| // No anonymous identity if no phase 2 auth. |
| identity_anonymous_textfield_->SetEnabled( |
| phase_2_auth_combobox_->IsEnabled()); |
| identity_anonymous_label_->SetEnabled( |
| identity_anonymous_textfield_->IsEnabled()); |
| if (!identity_anonymous_textfield_->IsEnabled()) |
| identity_anonymous_textfield_->SetText(string16()); |
| } |
| |
| void WifiConfigView::UpdateErrorLabel() { |
| std::string error_msg; |
| if (!service_path_.empty()) { |
| NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary(); |
| const WifiNetwork* wifi = cros->FindWifiNetworkByPath(service_path_); |
| if (wifi && wifi->failed()) { |
| bool passphrase_empty = wifi->GetPassphrase().empty(); |
| switch (wifi->error()) { |
| case ERROR_BAD_PASSPHRASE: |
| if (!passphrase_empty) { |
| error_msg = l10n_util::GetStringUTF8( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_BAD_PASSPHRASE); |
| } |
| break; |
| case ERROR_BAD_WEPKEY: |
| if (!passphrase_empty) { |
| error_msg = l10n_util::GetStringUTF8( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_BAD_WEPKEY); |
| } |
| break; |
| default: |
| error_msg = wifi->GetErrorString(); |
| break; |
| } |
| } |
| } |
| if (!error_msg.empty()) { |
| error_label_->SetText(UTF8ToWide(error_msg)); |
| error_label_->SetVisible(true); |
| } else { |
| error_label_->SetVisible(false); |
| } |
| } |
| |
| void WifiConfigView::ContentsChanged(views::Textfield* sender, |
| const string16& new_contents) { |
| UpdateDialogButtons(); |
| } |
| |
| bool WifiConfigView::HandleKeyEvent(views::Textfield* sender, |
| const views::KeyEvent& key_event) { |
| if (sender == passphrase_textfield_ && |
| key_event.key_code() == ui::VKEY_RETURN) { |
| parent_->GetDialogClientView()->AcceptWindow(); |
| } |
| return false; |
| } |
| |
| void WifiConfigView::ButtonPressed(views::Button* sender, |
| const views::Event& event) { |
| if (sender == passphrase_visible_button_) { |
| if (passphrase_textfield_) |
| passphrase_textfield_->SetPassword(!passphrase_textfield_->IsPassword()); |
| } else { |
| NOTREACHED(); |
| } |
| } |
| |
| void WifiConfigView::ItemChanged(views::Combobox* combo_box, |
| int prev_index, int new_index) { |
| if (new_index == prev_index) |
| return; |
| if (combo_box == security_combobox_) { |
| // If changed to no security, then disable combobox and clear it. |
| // Otherwise, enable it. Also, update can login. |
| if (new_index == SECURITY_INDEX_NONE) { |
| passphrase_label_->SetEnabled(false); |
| passphrase_textfield_->SetEnabled(false); |
| passphrase_textfield_->SetText(string16()); |
| } else { |
| passphrase_label_->SetEnabled(true); |
| passphrase_textfield_->SetEnabled(true); |
| } |
| } else if (combo_box == eap_method_combobox_) { |
| RefreshEAPFields(); |
| } |
| UpdateDialogButtons(); |
| } |
| |
| bool WifiConfigView::Login() { |
| NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary(); |
| if (service_path_.empty()) { |
| ConnectionSecurity sec = SECURITY_UNKNOWN; |
| switch (security_combobox_->selected_item()) { |
| case SECURITY_INDEX_NONE: |
| sec = SECURITY_NONE; |
| break; |
| case SECURITY_INDEX_WEP: |
| sec = SECURITY_WEP; |
| break; |
| case SECURITY_INDEX_WPA: |
| sec = SECURITY_WPA; |
| break; |
| case SECURITY_INDEX_RSN: |
| sec = SECURITY_RSN; |
| break; |
| } |
| cros->ConnectToWifiNetwork( |
| sec, GetSSID(), GetPassphrase(), std::string(), std::string()); |
| } else { |
| WifiNetwork* wifi = cros->FindWifiNetworkByPath(service_path_); |
| if (!wifi) { |
| // Flimflam no longer knows about this wifi network (edge case). |
| // TODO(stevenjb): Add a notification (chromium-os13225). |
| LOG(WARNING) << "Wifi network: " << service_path_ << " no longer exists."; |
| return true; |
| } |
| if (is_8021x_) { |
| // EAP method |
| EAPMethod method = EAP_METHOD_UNKNOWN; |
| switch (eap_method_combobox_->selected_item()) { |
| case EAP_METHOD_INDEX_PEAP: |
| method = EAP_METHOD_PEAP; |
| break; |
| case EAP_METHOD_INDEX_TLS: |
| method = EAP_METHOD_TLS; |
| break; |
| case EAP_METHOD_INDEX_TTLS: |
| method = EAP_METHOD_TTLS; |
| break; |
| case EAP_METHOD_INDEX_LEAP: |
| method = EAP_METHOD_LEAP; |
| break; |
| } |
| DCHECK(method != EAP_METHOD_UNKNOWN); |
| wifi->SetEAPMethod(method); |
| |
| // Phase 2 authentication |
| if (phase_2_auth_combobox_->IsEnabled()) { |
| EAPPhase2Auth auth = EAP_PHASE_2_AUTH_AUTO; |
| switch (phase_2_auth_combobox_->selected_item()) { |
| case PHASE_2_AUTH_INDEX_MD5: |
| auth = EAP_PHASE_2_AUTH_MD5; |
| break; |
| case PHASE_2_AUTH_INDEX_MSCHAPV2: |
| auth = EAP_PHASE_2_AUTH_MSCHAPV2; |
| break; |
| case PHASE_2_AUTH_INDEX_MSCHAP: |
| auth = EAP_PHASE_2_AUTH_MSCHAP; |
| break; |
| case PHASE_2_AUTH_INDEX_PAP: |
| auth = EAP_PHASE_2_AUTH_PAP; |
| break; |
| case PHASE_2_AUTH_INDEX_CHAP: |
| auth = EAP_PHASE_2_AUTH_CHAP; |
| break; |
| } |
| wifi->SetEAPPhase2Auth(auth); |
| } |
| |
| // Server CA certificate |
| if (server_ca_cert_combobox_->IsEnabled()) { |
| int selected = server_ca_cert_combobox_->selected_item(); |
| if (selected == 0) { |
| // First item is "Default". |
| wifi->SetEAPServerCaCertNssNickname(std::string()); |
| wifi->SetEAPUseSystemCAs(true); |
| } else if (selected == |
| server_ca_cert_combobox_->model()->GetItemCount() - 1) { |
| // Last item is "Do not check". |
| wifi->SetEAPServerCaCertNssNickname(std::string()); |
| wifi->SetEAPUseSystemCAs(false); |
| } else { |
| int cert_index = selected - 1; |
| std::string nss_nickname = |
| wifi_config_model_->GetServerCaCertNssNickname(cert_index); |
| wifi->SetEAPServerCaCertNssNickname(nss_nickname); |
| } |
| } |
| |
| // Client certificate |
| if (client_cert_combobox_ && client_cert_combobox_->IsEnabled()) { |
| int selected = client_cert_combobox_->selected_item(); |
| if (selected == 0) { |
| // First item is "None". |
| wifi->SetEAPClientCertPkcs11Id(std::string()); |
| } else { |
| // Send cert ID to flimflam. |
| int cert_index = selected - 1; |
| std::string cert_pkcs11_id = |
| wifi_config_model_->GetUserCertPkcs11Id(cert_index); |
| wifi->SetEAPClientCertPkcs11Id(cert_pkcs11_id); |
| } |
| } |
| |
| // Identity |
| if (identity_textfield_->IsEnabled()) { |
| wifi->SetEAPIdentity(UTF16ToUTF8(identity_textfield_->text())); |
| } |
| |
| // Anonymous identity |
| if (identity_anonymous_textfield_->IsEnabled()) { |
| wifi->SetEAPAnonymousIdentity( |
| UTF16ToUTF8(identity_anonymous_textfield_->text())); |
| } |
| |
| // Passphrase |
| if (passphrase_textfield_->IsEnabled()) { |
| wifi->SetEAPPassphrase(UTF16ToUTF8(passphrase_textfield_->text())); |
| } |
| |
| // Save credentials |
| wifi->SetSaveCredentials(save_credentials_checkbox_->checked()); |
| } else { |
| const std::string passphrase = GetPassphrase(); |
| if (passphrase != wifi->passphrase()) |
| wifi->SetPassphrase(passphrase); |
| } |
| |
| cros->ConnectToWifiNetwork(wifi); |
| // Connection failures are responsible for updating the UI, including |
| // reopening dialogs. |
| } |
| return true; // dialog will be closed |
| } |
| |
| void WifiConfigView::Cancel() { |
| } |
| |
| std::string WifiConfigView::GetSSID() const { |
| std::string result; |
| if (ssid_textfield_ != NULL) { |
| std::string untrimmed = UTF16ToUTF8(ssid_textfield_->text()); |
| TrimWhitespaceASCII(untrimmed, TRIM_ALL, &result); |
| } |
| return result; |
| } |
| |
| std::string WifiConfigView::GetPassphrase() const { |
| std::string result; |
| if (passphrase_textfield_ != NULL) |
| result = UTF16ToUTF8(passphrase_textfield_->text()); |
| return result; |
| } |
| |
| // This will initialize the view depending on if we have a wifi network or not. |
| // And if we are doing simple password encyption or the more complicated |
| // 802.1x encryption. |
| // If we are creating the "Join other network..." dialog, we will allow user |
| // to enter the data. And if they select the 802.1x encryption, we will show |
| // the 802.1x fields. |
| void WifiConfigView::Init(WifiNetwork* wifi) { |
| views::GridLayout* layout = views::GridLayout::CreatePanel(this); |
| SetLayoutManager(layout); |
| |
| int column_view_set_id = 0; |
| views::ColumnSet* column_set = layout->AddColumnSet(column_view_set_id); |
| // Label |
| column_set->AddColumn(views::GridLayout::LEADING, views::GridLayout::FILL, 1, |
| views::GridLayout::USE_PREF, 0, 0); |
| // Textfield |
| column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1, |
| views::GridLayout::USE_PREF, 0, |
| ChildNetworkConfigView::kPassphraseWidth); |
| // Password visible button |
| column_set->AddColumn(views::GridLayout::CENTER, views::GridLayout::FILL, 1, |
| views::GridLayout::USE_PREF, 0, 0); |
| |
| // SSID input |
| layout->StartRow(0, column_view_set_id); |
| layout->AddView(new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_ID)))); |
| if (!wifi) { |
| ssid_textfield_ = new views::Textfield(views::Textfield::STYLE_DEFAULT); |
| ssid_textfield_->SetController(this); |
| ssid_textfield_->SetAccessibleName(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_ID)); |
| layout->AddView(ssid_textfield_); |
| } else { |
| views::Label* label = new views::Label(UTF8ToWide(wifi->name())); |
| label->SetHorizontalAlignment(views::Label::ALIGN_LEFT); |
| layout->AddView(label); |
| } |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| |
| // Security select |
| if (!wifi) { |
| layout->StartRow(0, column_view_set_id); |
| layout->AddView(new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY)))); |
| security_combobox_ = new views::Combobox(new SecurityComboboxModel()); |
| security_combobox_->set_listener(this); |
| layout->AddView(security_combobox_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| } |
| |
| is_8021x_ = wifi && wifi->encrypted() && |
| wifi->encryption() == SECURITY_8021X; |
| if (is_8021x_) { |
| // Only enumerate certificates in the data model for 802.1X networks. |
| wifi_config_model_->UpdateCertificates(); |
| |
| // EAP method |
| layout->StartRow(0, column_view_set_id); |
| layout->AddView(new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EAP_METHOD)))); |
| eap_method_combobox_ = new views::Combobox(new EAPMethodComboboxModel()); |
| eap_method_combobox_->set_listener(this); |
| layout->AddView(eap_method_combobox_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| |
| // Phase 2 authentication |
| layout->StartRow(0, column_view_set_id); |
| phase_2_auth_label_ = |
| new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PHASE_2_AUTH))); |
| layout->AddView(phase_2_auth_label_); |
| phase_2_auth_combobox_ = new views::Combobox( |
| new Phase2AuthComboboxModel(eap_method_combobox_)); |
| phase_2_auth_label_->SetEnabled(false); |
| phase_2_auth_combobox_->SetEnabled(false); |
| phase_2_auth_combobox_->set_listener(this); |
| layout->AddView(phase_2_auth_combobox_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| |
| // Server CA certificate |
| layout->StartRow(0, column_view_set_id); |
| server_ca_cert_label_ = |
| new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_SERVER_CA))); |
| layout->AddView(server_ca_cert_label_); |
| server_ca_cert_combobox_ = new ComboboxWithWidth( |
| new ServerCACertComboboxModel(wifi_config_model_.get()), |
| ChildNetworkConfigView::kPassphraseWidth); |
| server_ca_cert_label_->SetEnabled(false); |
| server_ca_cert_combobox_->SetEnabled(false); |
| server_ca_cert_combobox_->set_listener(this); |
| layout->AddView(server_ca_cert_combobox_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| |
| // TODO(jamescook): Add back client certificate combobox when we support |
| // EAP-TLS by default. |
| if (CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableExperimentalEap)) { |
| // Client certificate |
| layout->StartRow(0, column_view_set_id); |
| client_cert_label_ = new views::Label( |
| UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT))); |
| layout->AddView(client_cert_label_); |
| client_cert_combobox_ = new views::Combobox( |
| new ClientCertComboboxModel(wifi_config_model_.get())); |
| client_cert_label_->SetEnabled(false); |
| client_cert_combobox_->SetEnabled(false); |
| client_cert_combobox_->set_listener(this); |
| layout->AddView(client_cert_combobox_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| } |
| |
| // Identity |
| layout->StartRow(0, column_view_set_id); |
| identity_label_ = new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_IDENTITY))); |
| layout->AddView(identity_label_); |
| identity_textfield_ = new views::Textfield( |
| views::Textfield::STYLE_DEFAULT); |
| identity_textfield_->SetController(this); |
| if (!wifi->identity().empty()) |
| identity_textfield_->SetText(UTF8ToUTF16(wifi->identity())); |
| layout->AddView(identity_textfield_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| } |
| |
| // Passphrase input |
| layout->StartRow(0, column_view_set_id); |
| int label_text_id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PASSPHRASE; |
| passphrase_label_ = new views::Label( |
| UTF16ToWide(l10n_util::GetStringUTF16(label_text_id))); |
| layout->AddView(passphrase_label_); |
| passphrase_textfield_ = new views::Textfield( |
| views::Textfield::STYLE_PASSWORD); |
| passphrase_textfield_->SetController(this); |
| if (wifi && !wifi->GetPassphrase().empty()) |
| passphrase_textfield_->SetText(UTF8ToUTF16(wifi->GetPassphrase())); |
| // Disable passphrase input initially for other network. |
| if (!wifi) { |
| passphrase_label_->SetEnabled(false); |
| passphrase_textfield_->SetEnabled(false); |
| } |
| passphrase_textfield_->SetAccessibleName(l10n_util::GetStringUTF16( |
| label_text_id)); |
| layout->AddView(passphrase_textfield_); |
| // Password visible button. |
| passphrase_visible_button_ = new views::ImageButton(this); |
| passphrase_visible_button_->SetImage( |
| views::ImageButton::BS_NORMAL, |
| ResourceBundle::GetSharedInstance(). |
| GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE)); |
| passphrase_visible_button_->SetImageAlignment( |
| views::ImageButton::ALIGN_CENTER, views::ImageButton::ALIGN_MIDDLE); |
| layout->AddView(passphrase_visible_button_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| |
| if (is_8021x_) { |
| // Anonymous identity |
| layout->StartRow(0, column_view_set_id); |
| identity_anonymous_label_ = |
| new views::Label(UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_IDENTITY_ANONYMOUS))); |
| layout->AddView(identity_anonymous_label_); |
| identity_anonymous_textfield_ = new views::Textfield( |
| views::Textfield::STYLE_DEFAULT); |
| identity_anonymous_label_->SetEnabled(false); |
| identity_anonymous_textfield_->SetEnabled(false); |
| identity_anonymous_textfield_->SetController(this); |
| layout->AddView(identity_anonymous_textfield_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| |
| // Save credentials |
| layout->StartRow(0, column_view_set_id); |
| save_credentials_checkbox_ = new views::Checkbox( |
| UTF16ToWide(l10n_util::GetStringUTF16( |
| IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SAVE_CREDENTIALS))); |
| layout->SkipColumns(1); |
| layout->AddView(save_credentials_checkbox_); |
| layout->AddPaddingRow(0, views::kRelatedControlVerticalSpacing); |
| } |
| |
| // After creating the fields, we set the values. Fields need to be created |
| // first because RefreshEAPFields() will enable/disable them as appropriate. |
| if (is_8021x_) { |
| // EAP Method |
| switch (wifi->eap_method()) { |
| case EAP_METHOD_PEAP: |
| eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_PEAP); |
| break; |
| case EAP_METHOD_TTLS: |
| eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_TTLS); |
| break; |
| case EAP_METHOD_TLS: |
| if (CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableExperimentalEap)) |
| eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_TLS); |
| else // Clean up from previous run with the switch set. |
| eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_NONE); |
| break; |
| case EAP_METHOD_LEAP: |
| if (CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kEnableExperimentalEap)) |
| eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_LEAP); |
| else // Clean up from previous run with the switch set. |
| eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_NONE); |
| break; |
| default: |
| break; |
| } |
| RefreshEAPFields(); |
| |
| // Phase 2 authentication |
| if (phase_2_auth_combobox_->IsEnabled()) { |
| switch (wifi->eap_phase_2_auth()) { |
| case EAP_PHASE_2_AUTH_MD5: |
| phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_MD5); |
| break; |
| case EAP_PHASE_2_AUTH_MSCHAPV2: |
| phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_MSCHAPV2); |
| break; |
| case EAP_PHASE_2_AUTH_MSCHAP: |
| phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_MSCHAP); |
| break; |
| case EAP_PHASE_2_AUTH_PAP: |
| phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_PAP); |
| break; |
| case EAP_PHASE_2_AUTH_CHAP: |
| phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_CHAP); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| // Server CA certificate |
| if (server_ca_cert_combobox_->IsEnabled()) { |
| const std::string& nss_nickname = wifi->eap_server_ca_cert_nss_nickname(); |
| if (nss_nickname.empty()) { |
| if (wifi->eap_use_system_cas()) { |
| // "Default" |
| server_ca_cert_combobox_->SetSelectedItem(0); |
| } else { |
| // "Do not check" |
| server_ca_cert_combobox_->SetSelectedItem( |
| server_ca_cert_combobox_->model()->GetItemCount() - 1); |
| } |
| } else { |
| // select the certificate if available |
| int cert_index = wifi_config_model_->GetServerCaCertIndex(nss_nickname); |
| if (cert_index >= 0) { |
| // Skip item for "Default" |
| server_ca_cert_combobox_->SetSelectedItem(1 + cert_index); |
| } |
| } |
| } |
| |
| // Client certificate |
| if (client_cert_combobox_ && client_cert_combobox_->IsEnabled()) { |
| const std::string& pkcs11_id = wifi->eap_client_cert_pkcs11_id(); |
| if (pkcs11_id.empty()) { |
| // First item is "None". |
| client_cert_combobox_->SetSelectedItem(0); |
| } else { |
| int cert_index = wifi_config_model_->GetUserCertIndex(pkcs11_id); |
| if (cert_index >= 0) { |
| // Skip item for "None" |
| client_cert_combobox_->SetSelectedItem(1 + cert_index); |
| } |
| } |
| } |
| |
| // Identity |
| if (identity_textfield_->IsEnabled()) |
| identity_textfield_->SetText(UTF8ToUTF16(wifi->eap_identity())); |
| |
| // Anonymous identity |
| if (identity_anonymous_textfield_->IsEnabled()) |
| identity_anonymous_textfield_->SetText( |
| UTF8ToUTF16(wifi->eap_anonymous_identity())); |
| |
| // Passphrase |
| if (passphrase_textfield_->IsEnabled()) |
| passphrase_textfield_->SetText(UTF8ToUTF16(wifi->eap_passphrase())); |
| |
| // Save credentials |
| bool save_credentials = (wifi ? wifi->save_credentials() : false); |
| save_credentials_checkbox_->SetChecked(save_credentials); |
| } |
| |
| // Create an error label. |
| layout->StartRow(0, column_view_set_id); |
| layout->SkipColumns(1); |
| error_label_ = new views::Label(); |
| error_label_->SetHorizontalAlignment(views::Label::ALIGN_LEFT); |
| error_label_->SetColor(SK_ColorRED); |
| layout->AddView(error_label_); |
| |
| // Set or hide the error text. |
| UpdateErrorLabel(); |
| } |
| |
| void WifiConfigView::InitFocus() { |
| // Set focus to a reasonable widget, depending on what we're showing. |
| if (ssid_textfield_) |
| ssid_textfield_->RequestFocus(); |
| else if (eap_method_combobox_) |
| eap_method_combobox_->RequestFocus(); |
| else if (passphrase_textfield_ && passphrase_textfield_->IsEnabled()) |
| passphrase_textfield_->RequestFocus(); |
| } |
| |
| } // namespace chromeos |
