views: Rename Combobox "selected getter/setter" accessors to something more accurate.

chrome/browser/chromeos/options/wifi_config_view.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/options/wifi_config_view.h"
 
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
@@ skipping 111 matching lines @@
 };
 
 class Phase2AuthComboboxModel : public ui::ComboboxModel {
  public:
   explicit Phase2AuthComboboxModel(views::Combobox* eap_method_combobox)
       : eap_method_combobox_(eap_method_combobox) {}
   virtual ~Phase2AuthComboboxModel() {}
 
   // Overridden from ui::ComboboxModel:
   virtual int GetItemCount() const OVERRIDE {
-    switch (eap_method_combobox_->selected_item()) {
+    switch (eap_method_combobox_->selected_index()) {
       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();
@@ skipping 197 matching lines @@
   if (service_path_.empty() && GetSsid().empty())
     return false;
 
   // If the network requires a passphrase, make sure it is the right length.
   if (passphrase_textfield_ != NULL
       && PassphraseActive()
       && passphrase_textfield_->text().length() < kMinWirelessPasswordLen)
     return false;
 
   // If we're using EAP, we must have a method.
-  if (eap_method_combobox_
-      && eap_method_combobox_->selected_item() == EAP_METHOD_INDEX_NONE)
+  if (eap_method_combobox_ &&
+      eap_method_combobox_->selected_index() == EAP_METHOD_INDEX_NONE)
     return false;
 
   // Block login if certs are required but user has none.
   if (UserCertRequired() && (!HaveUserCerts() || !IsUserCertValid()))
       return false;
 
   return true;
 }
 
 bool WifiConfigView::UserCertRequired() const {
   if (!cert_library_)
     return false;  // return false until cert_library_ is initialized.
   return UserCertActive();
 }
 
 bool WifiConfigView::HaveUserCerts() const {
   return cert_library_->GetUserCertificates().Size() > 0;
 }
 
 bool WifiConfigView::IsUserCertValid() const {
   if (!UserCertActive())
     return false;
-  int selected = user_cert_combobox_->selected_item();
-  if (selected < 0)
+  int index = user_cert_combobox_->selected_index();
+  if (index < 0)
     return false;
   // Currently only hardware-backed user certificates are valid.
   if (cert_library_->IsHardwareBacked() &&
-      !cert_library_->GetUserCertificates().IsHardwareBackedAt(selected))
+      !cert_library_->GetUserCertificates().IsHardwareBackedAt(index))
     return false;
   return true;
 }
 
 bool WifiConfigView::Phase2AuthActive() const {
   if (phase_2_auth_combobox_)
     return phase_2_auth_combobox_->model()->GetItemCount() > 1;
-
   return false;
 }
 
 bool WifiConfigView::PassphraseActive() const {
   if (eap_method_combobox_) {
     // No password for EAP-TLS.
-    int selected = eap_method_combobox_->selected_item();
-    return (selected != EAP_METHOD_INDEX_NONE &&
-            selected != EAP_METHOD_INDEX_TLS);
+    int index = eap_method_combobox_->selected_index();
+    return index != EAP_METHOD_INDEX_NONE && index != EAP_METHOD_INDEX_TLS;
   } else if (security_combobox_) {
-    return security_combobox_->selected_item() != SECURITY_INDEX_NONE;
+    return security_combobox_->selected_index() != SECURITY_INDEX_NONE;
   }
-
   return false;
 }
 
 bool WifiConfigView::UserCertActive() const {
   // User certs only for EAP-TLS.
   if (eap_method_combobox_)
-    return eap_method_combobox_->selected_item() == EAP_METHOD_INDEX_TLS;
+    return eap_method_combobox_->selected_index() == EAP_METHOD_INDEX_TLS;
 
   return false;
 }
 
 bool WifiConfigView::CaCertActive() const {
   // No server CA certs for LEAP.
   if (eap_method_combobox_) {
-    int selected = eap_method_combobox_->selected_item();
-    return (selected != EAP_METHOD_INDEX_NONE &&
-            selected != EAP_METHOD_INDEX_LEAP);
+    int index = eap_method_combobox_->selected_index();
+    return index != EAP_METHOD_INDEX_NONE && index != EAP_METHOD_INDEX_LEAP;
   }
-
   return false;
 }
 
 void WifiConfigView::UpdateDialogButtons() {
   parent_->GetDialogClientView()->UpdateDialogButtons();
 }
 
 void WifiConfigView::RefreshEapFields() {
   DCHECK(cert_library_);
 
   // 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_->SetSelectedIndex(0);
   bool phase_2_auth_enabled = Phase2AuthActive();
   phase_2_auth_combobox_->SetEnabled(phase_2_auth_enabled &&
                                      phase_2_auth_ui_data_.editable());
   phase_2_auth_label_->SetEnabled(phase_2_auth_enabled);
 
   // Passphrase.
   bool passphrase_enabled = PassphraseActive();
   passphrase_textfield_->SetEnabled(passphrase_enabled &&
                                     passphrase_ui_data_.editable());
   passphrase_label_->SetEnabled(passphrase_enabled);
   if (!passphrase_enabled)
     passphrase_textfield_->SetText(string16());
 
   // User cert.
   bool certs_loading = cert_library_->CertificatesLoading();
   bool user_cert_enabled = UserCertActive();
   user_cert_label_->SetEnabled(user_cert_enabled);
   bool have_user_certs = !certs_loading && HaveUserCerts();
   user_cert_combobox_->SetEnabled(user_cert_enabled &&
                                   have_user_certs &&
                                   user_cert_ui_data_.editable());
   user_cert_combobox_->ModelChanged();
-  user_cert_combobox_->SetSelectedItem(0);
+  user_cert_combobox_->SetSelectedIndex(0);
 
   // Server CA.
   bool ca_cert_enabled = CaCertActive();
   server_ca_cert_label_->SetEnabled(ca_cert_enabled);
   server_ca_cert_combobox_->SetEnabled(ca_cert_enabled &&
                                        !certs_loading &&
                                        server_ca_cert_ui_data_.editable());
   server_ca_cert_combobox_->ModelChanged();
-  server_ca_cert_combobox_->SetSelectedItem(0);
+  server_ca_cert_combobox_->SetSelectedIndex(0);
 
   // No anonymous identity if no phase 2 auth.
   bool identity_anonymous_enabled = phase_2_auth_enabled;
   identity_anonymous_textfield_->SetEnabled(
       identity_anonymous_enabled && identity_anonymous_ui_data_.editable());
   identity_anonymous_label_->SetEnabled(identity_anonymous_enabled);
   if (!identity_anonymous_enabled)
     identity_anonymous_textfield_->SetText(string16());
 
   RefreshShareCheckbox();
 }
 
 void WifiConfigView::RefreshShareCheckbox() {
   if (!share_network_checkbox_)
     return;
 
   if (security_combobox_ &&
-      security_combobox_->selected_item() == SECURITY_INDEX_NONE) {
+      security_combobox_->selected_index() == SECURITY_INDEX_NONE) {
     share_network_checkbox_->SetEnabled(false);
     share_network_checkbox_->SetChecked(true);
   } else if (eap_method_combobox_ &&
-             (eap_method_combobox_->selected_item() == EAP_METHOD_INDEX_TLS ||
-              user_cert_combobox_->selected_item() != 0)) {
+             (eap_method_combobox_->selected_index() == EAP_METHOD_INDEX_TLS ||
+              user_cert_combobox_->selected_index() != 0)) {
     // Can not share TLS network (requires certificate), or any network where
     // user certificates are enabled.
     share_network_checkbox_->SetEnabled(false);
     share_network_checkbox_->SetChecked(false);
   } else if (!UserManager::Get()->IsUserLoggedIn()) {
     // If not logged in, networks must be shared.
     share_network_checkbox_->SetEnabled(false);
     share_network_checkbox_->SetChecked(true);
   } else {
     share_network_checkbox_->SetEnabled(true);
@@ skipping 103 matching lines @@
   UpdateErrorLabel();
 }
 
 bool WifiConfigView::Login() {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   if (service_path_.empty()) {
     const bool share_default = true;  // share networks by default
     if (!eap_method_combobox_) {
       // Hidden ordinary Wi-Fi connection.
       ConnectionSecurity security = SECURITY_UNKNOWN;
-      switch (security_combobox_->selected_item()) {
+      switch (security_combobox_->selected_index()) {
         case SECURITY_INDEX_NONE:
           security = SECURITY_NONE;
           break;
         case SECURITY_INDEX_WEP:
           security = SECURITY_WEP;
           break;
         case SECURITY_INDEX_PSK:
           security = SECURITY_PSK;
           break;
       }
@@ skipping 80 matching lines @@
 }
 
 bool WifiConfigView::GetShareNetwork(bool share_default) const {
   if (!share_network_checkbox_)
     return share_default;
   return share_network_checkbox_->checked();
 }
 
 EAPMethod WifiConfigView::GetEapMethod() const {
   DCHECK(eap_method_combobox_);
-  switch (eap_method_combobox_->selected_item()) {
+  switch (eap_method_combobox_->selected_index()) {
     case EAP_METHOD_INDEX_NONE:
       return EAP_METHOD_UNKNOWN;
     case EAP_METHOD_INDEX_PEAP:
       return EAP_METHOD_PEAP;
     case EAP_METHOD_INDEX_TLS:
       return EAP_METHOD_TLS;
     case EAP_METHOD_INDEX_TTLS:
       return EAP_METHOD_TTLS;
     case EAP_METHOD_INDEX_LEAP:
       return EAP_METHOD_LEAP;
     default:
       return EAP_METHOD_UNKNOWN;
   }
 }
 
 EAPPhase2Auth WifiConfigView::GetEapPhase2Auth() const {
   DCHECK(phase_2_auth_combobox_);
-  switch (phase_2_auth_combobox_->selected_item()) {
+  switch (phase_2_auth_combobox_->selected_index()) {
     case PHASE_2_AUTH_INDEX_AUTO:
       return EAP_PHASE_2_AUTH_AUTO;
     case PHASE_2_AUTH_INDEX_MD5:
       return EAP_PHASE_2_AUTH_MD5;
     case PHASE_2_AUTH_INDEX_MSCHAPV2:
       return EAP_PHASE_2_AUTH_MSCHAPV2;
     case PHASE_2_AUTH_INDEX_MSCHAP:
       return EAP_PHASE_2_AUTH_MSCHAP;
     case PHASE_2_AUTH_INDEX_PAP:
       return EAP_PHASE_2_AUTH_PAP;
     case PHASE_2_AUTH_INDEX_CHAP:
       return EAP_PHASE_2_AUTH_CHAP;
     default:
       return EAP_PHASE_2_AUTH_AUTO;
   }
 }
 
 std::string WifiConfigView::GetEapServerCaCertNssNickname() const {
   DCHECK(server_ca_cert_combobox_);
   DCHECK(cert_library_);
-  int selected = server_ca_cert_combobox_->selected_item();
-  if (selected == 0) {
+  int index = server_ca_cert_combobox_->selected_index();
+  if (index == 0) {
     // First item is "Default".
     return std::string();
-  } else if (selected ==
-      server_ca_cert_combobox_->model()->GetItemCount() - 1) {
+  } else if (index == server_ca_cert_combobox_->model()->GetItemCount() - 1) {
     // Last item is "Do not check".
     return std::string();
   } else {
     DCHECK(cert_library_);
-    int cert_index = selected - 1;
+    int cert_index = index - 1;
     return cert_library_->GetCACertificates().GetNicknameAt(cert_index);
   }
 }
 
 bool WifiConfigView::GetEapUseSystemCas() const {
   DCHECK(server_ca_cert_combobox_);
   // Only use system CAs if the first item ("Default") is selected.
-  return server_ca_cert_combobox_->selected_item() == 0;
+  return server_ca_cert_combobox_->selected_index() == 0;
 }
 
 std::string WifiConfigView::GetEapClientCertPkcs11Id() const {
   DCHECK(user_cert_combobox_);
   DCHECK(cert_library_);
   if (!HaveUserCerts()) {
     return std::string();  // "None installed"
   } else {
     // Certificates are listed in the order they appear in the model.
-    int selected = user_cert_combobox_->selected_item();
-    return cert_library_->GetUserCertificates().GetPkcs11IdAt(selected);
+    int index = user_cert_combobox_->selected_index();
+    return cert_library_->GetUserCertificates().GetPkcs11IdAt(index);
   }
 }
 
 std::string WifiConfigView::GetEapIdentity() const {
   DCHECK(identity_textfield_);
   return UTF16ToUTF8(identity_textfield_->text());
 }
 
 std::string WifiConfigView::GetEapAnonymousIdentity() const {
   DCHECK(identity_anonymous_textfield_);
@@ skipping 262 matching lines @@
   layout->AddView(error_label_);
 
   // Initialize the field and checkbox values.
 
   // After creating the fields, we set the values. Fields need to be created
   // first because RefreshEapFields() will enable/disable them as appropriate.
   if (show_8021x) {
     EAPMethod eap_method = (wifi ? wifi->eap_method() : EAP_METHOD_UNKNOWN);
     switch (eap_method) {
       case EAP_METHOD_PEAP:
-        eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_PEAP);
+        eap_method_combobox_->SetSelectedIndex(EAP_METHOD_INDEX_PEAP);
         break;
       case EAP_METHOD_TTLS:
-        eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_TTLS);
+        eap_method_combobox_->SetSelectedIndex(EAP_METHOD_INDEX_TTLS);
         break;
       case EAP_METHOD_TLS:
-        eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_TLS);
+        eap_method_combobox_->SetSelectedIndex(EAP_METHOD_INDEX_TLS);
         break;
       case EAP_METHOD_LEAP:
-        eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_LEAP);
+        eap_method_combobox_->SetSelectedIndex(EAP_METHOD_INDEX_LEAP);
         break;
       default:
         break;
     }
     RefreshEapFields();
 
     // Phase 2 authentication and anonymous identity.
     if (Phase2AuthActive()) {
       EAPPhase2Auth eap_phase_2_auth =
           (wifi ? wifi->eap_phase_2_auth() : EAP_PHASE_2_AUTH_AUTO);
       switch (eap_phase_2_auth) {
         case EAP_PHASE_2_AUTH_MD5:
-          phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_MD5);
+          phase_2_auth_combobox_->SetSelectedIndex(PHASE_2_AUTH_INDEX_MD5);
           break;
         case EAP_PHASE_2_AUTH_MSCHAPV2:
-          phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_MSCHAPV2);
+          phase_2_auth_combobox_->SetSelectedIndex(PHASE_2_AUTH_INDEX_MSCHAPV2);
           break;
         case EAP_PHASE_2_AUTH_MSCHAP:
-          phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_MSCHAP);
+          phase_2_auth_combobox_->SetSelectedIndex(PHASE_2_AUTH_INDEX_MSCHAP);
           break;
         case EAP_PHASE_2_AUTH_PAP:
-          phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_PAP);
+          phase_2_auth_combobox_->SetSelectedIndex(PHASE_2_AUTH_INDEX_PAP);
           break;
         case EAP_PHASE_2_AUTH_CHAP:
-          phase_2_auth_combobox_->SetSelectedItem(PHASE_2_AUTH_INDEX_CHAP);
+          phase_2_auth_combobox_->SetSelectedIndex(PHASE_2_AUTH_INDEX_CHAP);
           break;
         default:
           break;
       }
 
       const std::string& eap_anonymous_identity =
           (wifi ? wifi->eap_anonymous_identity() : std::string());
       identity_anonymous_textfield_->SetText(
           UTF8ToUTF16(eap_anonymous_identity));
     }
 
-    // Server CA certificate
+    // Server CA certificate.
     if (CaCertActive()) {
       const std::string& nss_nickname =
           (wifi ? wifi->eap_server_ca_cert_nss_nickname() : std::string());
       if (nss_nickname.empty()) {
         if (wifi->eap_use_system_cas()) {
-          // "Default"
-          server_ca_cert_combobox_->SetSelectedItem(0);
+          // "Default".
+          server_ca_cert_combobox_->SetSelectedIndex(0);
         } else {
-          // "Do not check"
-          server_ca_cert_combobox_->SetSelectedItem(
+          // "Do not check".
+          server_ca_cert_combobox_->SetSelectedIndex(
               server_ca_cert_combobox_->model()->GetItemCount() - 1);
         }
       } else {
-        // select the certificate if available
+        // Select the certificate if available.
         int cert_index =
             cert_library_->GetCACertificates().FindCertByNickname(nss_nickname);
         if (cert_index >= 0) {
-          // Skip item for "Default"
-          server_ca_cert_combobox_->SetSelectedItem(1 + cert_index);
+          // Skip item for "Default".
+          server_ca_cert_combobox_->SetSelectedIndex(1 + cert_index);
         }
       }
     }
 
-    // User certificate
+    // User certificate.
     if (UserCertActive()) {
       const std::string& pkcs11_id =
           (wifi ? wifi->eap_client_cert_pkcs11_id() : std::string());
       if (!pkcs11_id.empty()) {
         int cert_index =
             cert_library_->GetUserCertificates().FindCertByPkcs11Id(pkcs11_id);
         if (cert_index >= 0) {
-          user_cert_combobox_->SetSelectedItem(cert_index);
+          user_cert_combobox_->SetSelectedIndex(cert_index);
         }
       }
     }
 
     // Identity is always active.
     const std::string& eap_identity =
         (wifi ? wifi->eap_identity() : std::string());
     identity_textfield_->SetText(UTF8ToUTF16(eap_identity));
 
     // Passphrase
@@ skipping 32 matching lines @@
 void WifiConfigView::ParseWiFiEAPUIProperty(
     NetworkPropertyUIData* property_ui_data,
     Network* network,
     const std::string& key) {
   ParseWiFiUIProperty(
       property_ui_data, network,
       base::StringPrintf("%s.%s", onc::wifi::kEAP, key.c_str()));
 }
 
 }  // namespace chromeos