views: Convert IsEnabled() to just enabled() since it's just a simple accessor.

chrome/browser/chromeos/options/wifi_config_view.cc

 // 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/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
@@ skipping 296 matching lines @@
 
 bool WifiConfigView::CanLogin() {
   static const size_t kMinWirelessPasswordLen = 5;
 
   // We either have an existing wifi network or the user entered an SSID.
   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
-      && passphrase_textfield_->IsEnabled()
+      && passphrase_textfield_->enabled()
       && passphrase_textfield_->text().length() < kMinWirelessPasswordLen)
     return false;
 
   // If we're using EAP, we must have a method.
   if (eap_method_combobox_
-      && eap_method_combobox_->IsEnabled()
+      && eap_method_combobox_->enabled()
       && eap_method_combobox_->selected_item() == 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.
   // Only EAP-TLS requires a user certificate.
   if (eap_method_combobox_ &&
-      eap_method_combobox_->IsEnabled() &&
+      eap_method_combobox_->enabled() &&
       eap_method_combobox_->selected_item() == EAP_METHOD_INDEX_TLS) {
     return true;
   }
   return false;
 }
 
 bool WifiConfigView::HaveUserCerts() const {
   return cert_library_->GetUserCertificates().Size() > 0;
 }
 
 bool WifiConfigView::IsUserCertValid() const {
-  if (!user_cert_combobox_ || !user_cert_combobox_->IsEnabled())
+  if (!user_cert_combobox_ || !user_cert_combobox_->enabled())
     return false;
   int selected = user_cert_combobox_->selected_item();
   if (selected < 0)
     return false;
   // Currently only hardware-backed user certificates are valid.
   if (cert_library_->IsHardwareBacked() &&
       !cert_library_->GetUserCertificates().IsHardwareBackedAt(selected))
     return false;
   return true;
 }
 
 void WifiConfigView::UpdateDialogButtons() {
   parent_->GetDialogClientView()->UpdateDialogButtons();
 }
 
 void WifiConfigView::RefreshEapFields() {
   DCHECK(cert_library_);
   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_ui_data_.editable());
-  phase_2_auth_label_->SetEnabled(phase_2_auth_combobox_->IsEnabled());
+  phase_2_auth_label_->SetEnabled(phase_2_auth_combobox_->enabled());
 
   // No password for EAP-TLS
   passphrase_textfield_->SetEnabled(selected != EAP_METHOD_INDEX_NONE &&
                                     selected != EAP_METHOD_INDEX_TLS &&
                                     passphrase_ui_data_.editable());
-  passphrase_label_->SetEnabled(passphrase_textfield_->IsEnabled());
-  if (!passphrase_textfield_->IsEnabled())
+  passphrase_label_->SetEnabled(passphrase_textfield_->enabled());
+  if (!passphrase_textfield_->enabled())
     passphrase_textfield_->SetText(string16());
 
   // User certs only for EAP-TLS
   bool certs_loading = cert_library_->CertificatesLoading();
   bool user_cert_enabled = (selected == EAP_METHOD_INDEX_TLS);
   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);
 
   // No server CA certs for LEAP
   bool ca_cert_enabled =
       (selected != EAP_METHOD_INDEX_NONE && selected != EAP_METHOD_INDEX_LEAP);
   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);
 
   // No anonymous identity if no phase 2 auth.
   identity_anonymous_textfield_->SetEnabled(
-      phase_2_auth_combobox_->IsEnabled() &&
+      phase_2_auth_combobox_->enabled() &&
       identity_anonymous_ui_data_.editable());
   identity_anonymous_label_->SetEnabled(
-      identity_anonymous_textfield_->IsEnabled());
-  if (!identity_anonymous_textfield_->IsEnabled())
+      identity_anonymous_textfield_->enabled());
+  if (!identity_anonymous_textfield_->enabled())
     identity_anonymous_textfield_->SetText(string16());
 
   RefreshShareCheckbox();
 }
 
 void WifiConfigView::RefreshShareCheckbox() {
   if (!share_network_checkbox_)
     return;
 
   if (security_combobox_ &&
@@ skipping 217 matching lines @@
   return result;
 }
 
 bool WifiConfigView::GetSaveCredentials() const {
   if (!save_credentials_checkbox_)
     return true;  // share networks by default (e.g. non 8021x).
   return save_credentials_checkbox_->checked();
 }
 
 bool WifiConfigView::GetShareNetwork(bool share_default) const {
-  if (!share_network_checkbox_ || !share_network_checkbox_->IsEnabled())
+  if (!share_network_checkbox_ || !share_network_checkbox_->enabled())
     return share_default;
   return share_network_checkbox_->checked();
 }
 
 EAPMethod WifiConfigView::GetEapMethod() const {
   DCHECK(eap_method_combobox_);
   switch (eap_method_combobox_->selected_item()) {
     case EAP_METHOD_INDEX_NONE:
       return EAP_METHOD_UNKNOWN;
     case EAP_METHOD_INDEX_PEAP:
@@ skipping 363 matching lines @@
         break;
       case EAP_METHOD_LEAP:
         eap_method_combobox_->SetSelectedItem(EAP_METHOD_INDEX_LEAP);
         break;
       default:
         break;
     }
     RefreshEapFields();
 
     // Phase 2 authentication
-    if (phase_2_auth_combobox_->IsEnabled()) {
+    if (phase_2_auth_combobox_->enabled()) {
       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);
           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()) {
+    if (server_ca_cert_combobox_->enabled()) {
       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);
         } 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 =
             cert_library_->GetCACertificates().FindCertByNickname(nss_nickname);
         if (cert_index >= 0) {
           // Skip item for "Default"
           server_ca_cert_combobox_->SetSelectedItem(1 + cert_index);
         }
       }
     }
 
     // User certificate
-    if (user_cert_combobox_->IsEnabled()) {
+    if (user_cert_combobox_->enabled()) {
       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);
         }
       }
     }
 
     // Identity
-    if (identity_textfield_->IsEnabled()) {
+    if (identity_textfield_->enabled()) {
       const std::string& eap_identity =
           (wifi ? wifi->eap_identity() : std::string());
       identity_textfield_->SetText(UTF8ToUTF16(eap_identity));
     }
 
     // Anonymous identity
-    if (identity_anonymous_textfield_->IsEnabled()) {
+    if (identity_anonymous_textfield_->enabled()) {
       const std::string& eap_anonymous_identity =
           (wifi ? wifi->eap_anonymous_identity() : std::string());
       identity_anonymous_textfield_->SetText(
           UTF8ToUTF16(eap_anonymous_identity));
     }
 
     // Passphrase
-    if (passphrase_textfield_->IsEnabled()) {
+    if (passphrase_textfield_->enabled()) {
       const std::string& eap_passphrase =
           (wifi ? wifi->eap_passphrase() : std::string());
       passphrase_textfield_->SetText(UTF8ToUTF16(eap_passphrase));
     }
 
     // Save credentials
     bool save_credentials = (wifi ? wifi->save_credentials() : false);
     save_credentials_checkbox_->SetChecked(save_credentials);
   }
 
   RefreshShareCheckbox();
   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())
+  else if (passphrase_textfield_ && passphrase_textfield_->enabled())
     passphrase_textfield_->RequestFocus();
 }
 
 }  // namespace chromeos