This factors out all of the parsing code from the network library

chrome/browser/chromeos/options/vpn_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/vpn_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/login/user_manager.h"
@@ skipping 10 matching lines @@
 #include "views/controls/label.h"
 #include "views/controls/textfield/textfield.h"
 #include "views/layout/grid_layout.h"
 #include "views/layout/layout_constants.h"
 
 namespace {
 
 // Root CA certificates that are built into Chrome use this token name.
 const char* const kRootCertificateTokenName = "Builtin Object Token";
 
-string16 ProviderTypeToString(chromeos::VirtualNetwork::ProviderType type) {
+string16 ProviderTypeToString(chromeos::ProviderType type) {
   switch (type) {
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_PSK);
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_USER_CERT);
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+    case chromeos::PROVIDER_TYPE_OPEN_VPN:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_OPEN_VPN);
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_MAX:
+    case chromeos::PROVIDER_TYPE_MAX:
       break;
   }
   NOTREACHED();
   return string16();
 }
 
 }  // namespace
 
 namespace chromeos {
 
 class ProviderTypeComboboxModel : public ui::ComboboxModel {
  public:
   ProviderTypeComboboxModel() {}
   virtual ~ProviderTypeComboboxModel() {}
   virtual int GetItemCount() {
     // TODO(stevenjb): Include OpenVPN option once enabled.
-    return VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT + 1;
+    return PROVIDER_TYPE_L2TP_IPSEC_USER_CERT + 1;
     // return VirtualNetwork::PROVIDER_TYPE_MAX;
   }
   virtual string16 GetItemAt(int index) {
-    VirtualNetwork::ProviderType type =
-        static_cast<VirtualNetwork::ProviderType>(index);
+    ProviderType type = static_cast<ProviderType>(index);
     return ProviderTypeToString(type);
   }
  private:
   DISALLOW_COPY_AND_ASSIGN(ProviderTypeComboboxModel);
 };
 
 class ServerCACertComboboxModel : public ui::ComboboxModel {
  public:
   explicit ServerCACertComboboxModel(CertLibrary* cert_library)
       : cert_library_(cert_library) {
@@ skipping 117 matching lines @@
 
 void VPNConfigView::ButtonPressed(views::Button* sender,
                                   const views::Event& event) {
 }
 
 void VPNConfigView::ItemChanged(views::Combobox* combo_box,
                                 int prev_index, int new_index) {
   if (prev_index == new_index)
     return;
   if (combo_box == provider_type_combobox_) {
-    provider_type_ = static_cast<VirtualNetwork::ProviderType>(new_index);
+    provider_type_ = static_cast<ProviderType>(new_index);
     UpdateControls();
-  } else if (combo_box == user_cert_combobox_) {
-  } else if (combo_box == server_ca_cert_combobox_) {
+  } else if (combo_box == user_cert_combobox_ ||
+             combo_box == server_ca_cert_combobox_) {
+    // Do nothing.
   } else {
     NOTREACHED();
   }
   UpdateErrorLabel();
   UpdateCanLogin();
 }
 
 void VPNConfigView::OnCertificatesLoaded(bool initial_load) {
   Refresh();
 }
 
 bool VPNConfigView::Login() {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   if (service_path_.empty()) {
     switch (provider_type_) {
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+      case PROVIDER_TYPE_L2TP_IPSEC_PSK:
         cros->ConnectToVirtualNetworkPSK(GetService(),
                                          GetServer(),
                                          GetPSKPassphrase(),
                                          GetUsername(),
                                          GetUserPassphrase());
         break;
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
+      case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
         cros->ConnectToVirtualNetworkCert(GetService(),
                                           GetServer(),
                                           GetServerCACertNssNickname(),
                                           GetUserCertID(),
                                           GetUsername(),
                                           GetUserPassphrase());
         break;
       }
-      case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+      case PROVIDER_TYPE_OPEN_VPN:
         // TODO(stevenjb): Add support for OpenVPN.
         LOG(WARNING) << "Unsupported provider type: " << provider_type_;
         break;
-      case VirtualNetwork::PROVIDER_TYPE_MAX:
+      case PROVIDER_TYPE_MAX:
         break;
     }
   } else {
     VirtualNetwork* vpn = cros->FindVirtualNetworkByPath(service_path_);
     if (!vpn) {
       // TODO(stevenjb): Add notification for this.
       LOG(WARNING) << "VPN no longer exists: " << service_path_;
       return true;  // Close dialog.
     }
     switch (provider_type_) {
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+      case PROVIDER_TYPE_L2TP_IPSEC_PSK:
         vpn->SetPSKPassphrase(GetPSKPassphrase());
         break;
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
+      case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
         vpn->SetClientCertID(GetUserCertID());
         break;
       }
-      case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN: {
+      case PROVIDER_TYPE_OPEN_VPN: {
         LOG(WARNING) << "OpenVPN not yet supported.";
         break;
       }
-      case VirtualNetwork::PROVIDER_TYPE_MAX:
+      case PROVIDER_TYPE_MAX:
         break;
     }
     vpn->SetUsername(GetUsername());
     vpn->SetUserPassphrase(GetUserPassphrase());
 
     cros->ConnectToVirtualNetwork(vpn);
   }
   // Connection failures are responsible for updating the UI, including
   // reopening dialogs.
   return true;  // Close dialog.
@@ skipping 90 matching lines @@
   // Textfield, combobox.
   column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
                         views::GridLayout::USE_PREF, 0,
                         ChildNetworkConfigView::kInputFieldMinWidth);
   column_set->AddPaddingColumn(0, views::kRelatedControlSmallHorizontalSpacing);
 
   // Initialize members.
   service_text_modified_ = false;
   provider_type_ = vpn ?
       vpn->provider_type() :
-      chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK;
+      chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK;
 
   // Server label and input.
   layout->StartRow(0, column_view_set_id);
   layout->AddView(new views::Label(UTF16ToWide(l10n_util::GetStringUTF16(
       IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_SERVER_HOSTNAME))));
   if (!vpn) {
     server_textfield_ = new views::Textfield(views::Textfield::STYLE_DEFAULT);
     server_textfield_->SetController(this);
     layout->AddView(server_textfield_);
     server_text_ = NULL;
@@ skipping 150 matching lines @@
   } else {
     user_cert_combobox_->SetSelectedItem(0);
   }
 
   UpdateErrorLabel();
 }
 
 void VPNConfigView::UpdateControls() {
   // Enable controls.
   switch (provider_type_) {
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case PROVIDER_TYPE_L2TP_IPSEC_PSK:
       psk_passphrase_label_->SetEnabled(true);
       psk_passphrase_textfield_->SetEnabled(true);
       server_ca_cert_label_->SetEnabled(false);
       server_ca_cert_combobox_->SetEnabled(false);
       user_cert_label_->SetEnabled(false);
       user_cert_combobox_->SetEnabled(false);
       break;
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+    case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       psk_passphrase_label_->SetEnabled(false);
       psk_passphrase_textfield_->SetEnabled(false);
       server_ca_cert_label_->SetEnabled(true);
       server_ca_cert_combobox_->SetEnabled(true);
       user_cert_label_->SetEnabled(true);
       // Only enable the combobox if the user actually has a cert to select.
       user_cert_combobox_->SetEnabled(HaveUserCerts());
       break;
-    case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+    case PROVIDER_TYPE_OPEN_VPN:
       psk_passphrase_label_->SetEnabled(false);
       psk_passphrase_textfield_->SetEnabled(false);
       server_ca_cert_label_->SetEnabled(false);
       server_ca_cert_combobox_->SetEnabled(false);
       user_cert_label_->SetEnabled(true);
       // Only enable the combobox if the user actually has a cert to select.
       user_cert_combobox_->SetEnabled(HaveUserCerts());
       break;
     default:
       NOTREACHED();
@@ skipping 33 matching lines @@
   } else {
     error_label_->SetVisible(false);
   }
 }
 
 void VPNConfigView::UpdateCanLogin() {
   parent_->GetDialogClientView()->UpdateDialogButtons();
 }
 
 bool VPNConfigView::UserCertRequired() const {
-  return provider_type_ == VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT
-      || provider_type_ == VirtualNetwork::PROVIDER_TYPE_OPEN_VPN;
+  return provider_type_ == PROVIDER_TYPE_L2TP_IPSEC_USER_CERT
+      || provider_type_ == PROVIDER_TYPE_OPEN_VPN;
 }
 
 bool VPNConfigView::HaveUserCerts() const {
   return cert_library_->GetUserCertificates().Size() > 0;
 }
 
 bool VPNConfigView::IsUserCertValid() const {
   if (!user_cert_combobox_ || !user_cert_combobox_->IsEnabled())
     return false;
   int selected = user_cert_combobox_->selected_item();
@@ skipping 10 matching lines @@
     views::Textfield* textfield, bool trim_whitespace) const {
   std::string untrimmed = UTF16ToUTF8(textfield->text());
   if (!trim_whitespace)
     return untrimmed;
   std::string result;
   TrimWhitespaceASCII(untrimmed, TRIM_ALL, &result);
   return result;
 }
 
 }  // namespace chromeos