cros vpn config: Read UI data from the correct VPN dictionaries.

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/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
@@ skipping 33 matching lines @@
     case chromeos::PROVIDER_TYPE_OPEN_VPN:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_OPEN_VPN);
     case chromeos::PROVIDER_TYPE_MAX:
       break;
   }
   NOTREACHED();
   return string16();
 }
 
+// Translates the provider type to the name of the respective ONC dictionary
+// containing configuration data for the type.
+std::string ProviderTypeToONCDictKey(chromeos::ProviderType type) {
+  switch (type) {
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+      return chromeos::onc::vpn::kIPsec;
+    case chromeos::PROVIDER_TYPE_OPEN_VPN:
+      return chromeos::onc::vpn::kOpenVPN;
+    case chromeos::PROVIDER_TYPE_MAX:
+      break;
+  }
+
+  NOTREACHED() << "Unhandled provider type " << type;
+  return std::string();
+}
+
 }  // namespace
 
 namespace chromeos {
 
 namespace internal {
 
 class ProviderTypeComboboxModel : public ui::ComboboxModel {
  public:
   ProviderTypeComboboxModel();
   virtual ~ProviderTypeComboboxModel();
@@ skipping 363 matching lines @@
     return std::string();  // "None installed"
   } else {
     // Certificates are listed in the order they appear in the model.
     int index = user_cert_combobox_ ? user_cert_combobox_->selected_index() : 0;
     return cert_library_->GetUserCertificates().GetPkcs11IdAt(index);
   }
 }
 
 void VPNConfigView::Init(VirtualNetwork* vpn) {
   if (vpn) {
-    ParseVPNUIProperty(&ca_cert_ui_data_, vpn, onc::vpn::kServerCARef);
-    ParseVPNUIProperty(&psk_passphrase_ui_data_, vpn, onc::vpn::kPSK);
-    ParseVPNUIProperty(&user_cert_ui_data_, vpn, onc::vpn::kClientCertRef);
-    ParseVPNUIProperty(&username_ui_data_, vpn, onc::vpn::kUsername);
-    ParseVPNUIProperty(&user_passphrase_ui_data_, vpn, onc::vpn::kPassword);
-    ParseVPNUIProperty(&group_name_ui_data_, vpn, onc::vpn::kGroup);
+    ProviderType type = vpn->provider_type();
+    std::string type_dict_name = ProviderTypeToONCDictKey(type);
+    ParseVPNUIProperty(&ca_cert_ui_data_, vpn, type_dict_name,
+                       onc::vpn::kServerCARef);
+    ParseVPNUIProperty(&psk_passphrase_ui_data_, vpn, type_dict_name,
+                       onc::vpn::kPSK);
+    ParseVPNUIProperty(&user_cert_ui_data_, vpn, type_dict_name,
+                       onc::vpn::kClientCertRef);
+    ParseVPNUIProperty(&group_name_ui_data_, vpn, type_dict_name,
+                       onc::vpn::kGroup);
+
+    const std::string credentials_dict_name(
+        type == PROVIDER_TYPE_L2TP_IPSEC_PSK ?
+            onc::vpn::kL2TP : type_dict_name);
+    ParseVPNUIProperty(&username_ui_data_, vpn, credentials_dict_name,
+                       onc::vpn::kUsername);
+    ParseVPNUIProperty(&user_passphrase_ui_data_, vpn, credentials_dict_name,
+                       onc::vpn::kPassword);
   }
 
   views::GridLayout* layout = views::GridLayout::CreatePanel(this);
   SetLayoutManager(layout);
 
   // VPN may require certificates, so always set the library and observe.
   cert_library_ = CrosLibrary::Get()->GetCertLibrary();
 
   // Setup a callback if certificates are yet to be loaded.
   if (!cert_library_->CertificatesLoaded())
@@ skipping 393 matching lines @@
 
 const std::string VPNConfigView::GetPassphraseFromField(
     PassphraseTextfield* textfield) const {
   if (!textfield)
     return std::string();
   return textfield->GetPassphrase();
 }
 
 void VPNConfigView::ParseVPNUIProperty(NetworkPropertyUIData* property_ui_data,
                                        Network* network,
+                                       const std::string& dict_key,
                                        const std::string& key) {
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   const base::DictionaryValue* onc =
       network_library->FindOncForNetwork(network->unique_id());
 
-  base::DictionaryValue* vpn_dict = NULL;
-  if (!onc || !onc->GetDictionary(onc::kVPN, &vpn_dict))
-    return;
-
-  std::string vpn_type;
-  if (!vpn_dict || !vpn_dict->GetString(onc::kType, &vpn_type))
-    return;
-
   property_ui_data->ParseOncProperty(
       network->ui_data(), onc,
-      base::StringPrintf("%s.%s.%s", onc::kVPN, vpn_type.c_str(), key.c_str()));
+      base::StringPrintf("%s.%s.%s", onc::kVPN, dict_key.c_str(), key.c_str()));
 }
 
 }  // namespace chromeos