Fix VPN dialog password field focus

chrome/browser/chromeos/options/vpn_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/vpn_config_view.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 210 matching lines @@
 
 VPNConfigView::VPNConfigView(NetworkConfigView* parent,
                              const std::string& service_path)
     : ChildNetworkConfigView(parent, service_path),
       service_text_modified_(false),
       enable_psk_passphrase_(false),
       enable_user_cert_(false),
       enable_server_ca_cert_(false),
       enable_otp_(false),
       enable_group_name_(false),
+      user_passphrase_required_(false),
       title_(0),
       layout_(NULL),
       server_textfield_(NULL),
       service_text_(NULL),
       service_textfield_(NULL),
       provider_type_combobox_(NULL),
       provider_type_text_label_(NULL),
       psk_passphrase_label_(NULL),
       psk_passphrase_textfield_(NULL),
       user_cert_label_(NULL),
@@ skipping 32 matching lines @@
       return service_textfield_;
     else if (provider_type_combobox_)
       return provider_type_combobox_;
     else if (psk_passphrase_textfield_ && psk_passphrase_textfield_->enabled())
       return psk_passphrase_textfield_;
     else if (user_cert_combobox_ && user_cert_combobox_->enabled())
       return user_cert_combobox_;
     else if (server_ca_cert_combobox_ && server_ca_cert_combobox_->enabled())
       return server_ca_cert_combobox_;
   }
-  if (user_passphrase_textfield_)
+  if (user_passphrase_textfield_ && user_passphrase_required_)
     return user_passphrase_textfield_;
   else if (otp_textfield_)
     return otp_textfield_;
   return NULL;
 }
 
 bool VPNConfigView::CanLogin() {
   // Username is always required.
   if (GetUsername().empty())
     return false;
@@ skipping 412 matching lines @@
     const base::DictionaryValue& service_properties) {
   const NetworkState* vpn = NetworkHandler::Get()->network_state_handler()->
       GetNetworkState(service_path);
   if (!vpn) {
     NET_LOG_ERROR("Shill Error getting properties VpnConfigView", service_path);
     return;
   }
 
   std::string provider_type, server_hostname, username, group_name;
   bool psk_passphrase_required = false;
-  bool user_passphrase_required = true;
+  user_passphrase_required_ = true;
   const base::DictionaryValue* provider_properties;
   if (service_properties.GetDictionaryWithoutPathExpansion(
           shill::kProviderProperty, &provider_properties)) {
     provider_properties->GetStringWithoutPathExpansion(
         shill::kTypeProperty, &provider_type);
     provider_properties->GetStringWithoutPathExpansion(
         shill::kHostProperty, &server_hostname);
     if (provider_type == shill::kProviderL2tpIpsec) {
       provider_properties->GetStringWithoutPathExpansion(
           shill::kL2tpIpsecClientCertIdProperty, &client_cert_id_);
       ca_cert_pem_ = GetPemFromDictionary(
           provider_properties, shill::kL2tpIpsecCaCertPemProperty);
       provider_properties->GetBooleanWithoutPathExpansion(
           shill::kL2tpIpsecPskRequiredProperty, &psk_passphrase_required);
       provider_properties->GetStringWithoutPathExpansion(
           shill::kL2tpIpsecUserProperty, &username);
       provider_properties->GetStringWithoutPathExpansion(
           shill::kL2tpIpsecTunnelGroupProperty, &group_name);
     } else if (provider_type == shill::kProviderOpenVpn) {
       provider_properties->GetStringWithoutPathExpansion(
           shill::kOpenVPNClientCertIdProperty, &client_cert_id_);
       ca_cert_pem_ = GetPemFromDictionary(
           provider_properties, shill::kOpenVPNCaCertPemProperty);
       provider_properties->GetStringWithoutPathExpansion(
           shill::kOpenVPNUserProperty, &username);
       provider_properties->GetBooleanWithoutPathExpansion(
-          shill::kPassphraseRequiredProperty, &user_passphrase_required);
+          shill::kPassphraseRequiredProperty, &user_passphrase_required_);
     }
   }
   bool save_credentials = false;
   service_properties.GetBooleanWithoutPathExpansion(
       shill::kSaveCredentialsProperty, &save_credentials);
 
   provider_type_index_ = ProviderTypeToIndex(provider_type, client_cert_id_);
 
   if (service_text_)
     service_text_->SetText(base::ASCIIToUTF16(vpn->name()));
   if (provider_type_text_label_)
     provider_type_text_label_->SetText(
         ProviderTypeIndexToString(provider_type_index_));
 
   if (server_textfield_ && !server_hostname.empty())
     server_textfield_->SetText(base::UTF8ToUTF16(server_hostname));
   if (username_textfield_ && !username.empty())
     username_textfield_->SetText(base::UTF8ToUTF16(username));
   if (group_name_textfield_ && !group_name.empty())
     group_name_textfield_->SetText(base::UTF8ToUTF16(group_name));
   if (psk_passphrase_textfield_)
     psk_passphrase_textfield_->SetShowFake(!psk_passphrase_required);
   if (user_passphrase_textfield_)
-    user_passphrase_textfield_->SetShowFake(!user_passphrase_required);
+    user_passphrase_textfield_->SetShowFake(!user_passphrase_required_);
   if (save_credentials_checkbox_)
     save_credentials_checkbox_->SetChecked(save_credentials);
 
   Refresh();
   UpdateCanLogin();
 }
 
 void VPNConfigView::ParseUIProperties(const NetworkState* vpn) {
   std::string type_dict_name =
       ProviderTypeIndexToONCDictKey(provider_type_index_);
@@ skipping 286 matching lines @@
   property_ui_data->ParseOncProperty(
       onc_source,
       onc,
       base::StringPrintf("%s.%s.%s",
                          ::onc::network_config::kVPN,
                          dict_key.c_str(),
                          key.c_str()));
 }
 
 }  // namespace chromeos