Add support for different type of encyrption when adding a network....

chrome/browser/chromeos/options/wifi_config_view.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 #include "app/resource_bundle.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"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "views/controls/button/image_button.h"
 #include "views/controls/button/native_button.h"
 #include "views/controls/label.h"
 #include "views/grid_layout.h"
 #include "views/standard_layout.h"
 #include "views/window/window.h"
 
 namespace chromeos {
 
 // The width of the password field.
 const int kPasswordWidth = 150;
 
+enum SecurityComboboxIndex {
+  INDEX_NONE  = 0,
+  INDEX_WEP   = 1,
+  INDEX_WPA   = 2,
+  INDEX_RSN   = 3,
+  INDEX_COUNT = 4
+};
+
+int WifiConfigView::SecurityComboboxModel::GetItemCount() {
+  return INDEX_COUNT;
+}
+
+string16 WifiConfigView::SecurityComboboxModel::GetItemAt(int index) {
+  if (index == INDEX_NONE)
+    return l10n_util::GetStringUTF16(
+        IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_NONE);
+  else if (index == INDEX_WEP)
+    return l10n_util::GetStringUTF16(
+        IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_WEP);
+  else if (index == INDEX_WPA)
+    return l10n_util::GetStringUTF16(
+        IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_WPA);
+  else if (index == INDEX_RSN)
+    return l10n_util::GetStringUTF16(
+        IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_RSN);
+  NOTREACHED();
+  return string16();
+}
+
 WifiConfigView::WifiConfigView(NetworkConfigView* parent,
                                const WifiNetwork* wifi)
     : parent_(parent),
       other_network_(false),
       can_login_(false),
       wifi_(new WifiNetwork(*wifi)),
       ssid_textfield_(NULL),
       identity_textfield_(NULL),
       certificate_browse_button_(NULL),
       certificate_path_(),
+      security_combobox_(NULL),
       passphrase_textfield_(NULL),
       passphrase_visible_button_(NULL),
       autoconnect_checkbox_(NULL) {
   Init();
 }
 
 WifiConfigView::WifiConfigView(NetworkConfigView* parent)
     : parent_(parent),
       other_network_(true),
       can_login_(false),
       ssid_textfield_(NULL),
       identity_textfield_(NULL),
       certificate_browse_button_(NULL),
       certificate_path_(),
+      security_combobox_(NULL),
       passphrase_textfield_(NULL),
       passphrase_visible_button_(NULL),
       autoconnect_checkbox_(NULL) {
   Init();
 }
 
 WifiConfigView::~WifiConfigView() {
 }
 
 void WifiConfigView::UpdateCanLogin(void) {
   bool can_login = true;
   if (other_network_) {
-    // Since the user can try to connect to a non-encrypted hidden network,
-    // only enforce ssid is non-empty.
-    can_login = !ssid_textfield_->text().empty();
+    // Enforce ssid is non empty.
+    // If security is not none, also enforce passphrase is non empty.
+    can_login = !ssid_textfield_->text().empty() &&
+        (security_combobox_->selected_item() == INDEX_NONE ||
+            !passphrase_textfield_->text().empty());
   } else {
     // Connecting to an encrypted network
     if (passphrase_textfield_ != NULL) {
       // if the network requires a passphrase, make sure it is non empty.
       can_login &= !passphrase_textfield_->text().empty();
     }
     if (identity_textfield_ != NULL) {
       // If we have an identity field, we can login if we have a non empty
       // identity and a certificate path
       can_login &= !identity_textfield_->text().empty() &&
@@ skipping 46 matching lines @@
                                     std::string(),
                                     parent_->is_browser_mode() ?
                                         NULL :
                                         parent_->GetNativeWindow(),
                                     NULL);
   } else {
     NOTREACHED();
   }
 }
 
+void WifiConfigView::ItemChanged(views::Combobox* combo_box,
+                                 int prev_index, int new_index) {
+  // If changed to no security, then disable combobox and clear it.
+  // Otherwise, enable it. Also, update can login.
+  if (new_index == INDEX_NONE) {
+    passphrase_textfield_->SetEnabled(false);
+    passphrase_textfield_->SetText(string16());
+  } else {
+    passphrase_textfield_->SetEnabled(true);
+  }
+  UpdateCanLogin();
+}
+
 void WifiConfigView::FileSelected(const FilePath& path,
                                    int index, void* params) {
   certificate_path_ = path.value();
   if (certificate_browse_button_)
     certificate_browse_button_->SetLabel(path.BaseName().ToWStringHack());
   UpdateCanLogin();  // TODO(njw) Check if the passphrase decrypts the key.
 }
 
 bool WifiConfigView::Login() {
   std::string identity_string;
   if (identity_textfield_ != NULL) {
     identity_string = UTF16ToUTF8(identity_textfield_->text());
   }
   if (other_network_) {
+    ConnectionSecurity sec = SECURITY_UNKNOWN;
+    int index = security_combobox_->selected_item();
+    if (index == INDEX_NONE)
+      sec = SECURITY_NONE;
+    else if (index == INDEX_WEP)
+      sec = SECURITY_WEP;
+    else if (index == INDEX_WPA)
+      sec = SECURITY_WPA;
+    else if (index == INDEX_RSN)
+      sec = SECURITY_RSN;
     CrosLibrary::Get()->GetNetworkLibrary()->ConnectToWifiNetwork(
-        GetSSID(), GetPassphrase(),
+        sec, GetSSID(), GetPassphrase(),
         identity_string, certificate_path_,
         autoconnect_checkbox_ ? autoconnect_checkbox_->checked() : true);
   } else {
     Save();
     CrosLibrary::Get()->GetNetworkLibrary()->ConnectToWifiNetwork(
         wifi_.get(), GetPassphrase(),
         identity_string, certificate_path_);
   }
   return true;
 }
@@ skipping 58 matching lines @@
   // Label
   column_set->AddColumn(views::GridLayout::LEADING, views::GridLayout::FILL, 1,
                         views::GridLayout::USE_PREF, 0, 0);
   // Textfield
   column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
                         views::GridLayout::USE_PREF, 0, kPasswordWidth);
   // Password visible button
   column_set->AddColumn(views::GridLayout::CENTER, views::GridLayout::FILL, 1,
                         views::GridLayout::USE_PREF, 0, 0);
 
+  // SSID input
   layout->StartRow(0, column_view_set_id);
   layout->AddView(new views::Label(l10n_util::GetString(
       IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_ID)));
   if (other_network_) {
     ssid_textfield_ = new views::Textfield(views::Textfield::STYLE_DEFAULT);
     ssid_textfield_->SetController(this);
     layout->AddView(ssid_textfield_);
   } else {
     views::Label* label = new views::Label(ASCIIToWide(wifi_->name()));
     label->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
     layout->AddView(label);
   }
   layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
 
+  // Certificate input
   // Loaded certificates (i.e. stored in a pkcs11 device) do not require
   // a passphrase.
   bool certificate_loaded = false;
 
   // Add ID and cert password if we're using 802.1x
   // XXX we're cheating and assuming 802.1x means EAP-TLS - not true
   // in general, but very common. WPA Supplicant doesn't report the
   // EAP type because it's unknown until the process begins, and we'd
   // need some kind of callback.
   if (wifi_.get() && wifi_->encrypted() &&
@@ skipping 27 matching lines @@
         label = UTF8ToWide(certificate_path_);
       else
         label = l10n_util::GetString(
             IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CERT_BUTTON);
       certificate_browse_button_ = new views::NativeButton(this, label);
       layout->AddView(certificate_browse_button_);
     }
     layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
   }
 
+  // Security select
+  if (other_network_) {
+    layout->StartRow(0, column_view_set_id);
+    layout->AddView(new views::Label(l10n_util::GetString(
+          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY)));
+    security_combobox_ = new views::Combobox(new SecurityComboboxModel());
+    security_combobox_->set_listener(this);
+    layout->AddView(security_combobox_);
+    layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
+  }
+
+  // Passphrase input
   // Add passphrase if other_network or wifi is encrypted.
   if (other_network_ || (wifi_.get() && wifi_->encrypted() &&
                          !certificate_loaded)) {
     layout->StartRow(0, column_view_set_id);
     int label_text_id;
     if (wifi_.get() && wifi_->encryption() == SECURITY_8021X)
       label_text_id =
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PRIVATE_KEY_PASSWORD;
     else
       label_text_id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PASSPHRASE;
     layout->AddView(new views::Label(l10n_util::GetString(label_text_id)));
     passphrase_textfield_ = new views::Textfield(
         views::Textfield::STYLE_PASSWORD);
     passphrase_textfield_->SetController(this);
     if (wifi_.get() && !wifi_->passphrase().empty())
       passphrase_textfield_->SetText(UTF8ToUTF16(wifi_->passphrase()));
+    // Disable passphrase input initially for other network.
+    if (other_network_)
+      passphrase_textfield_->SetEnabled(false);
     layout->AddView(passphrase_textfield_);
     // Password visible button.
     passphrase_visible_button_ = new views::ImageButton(this);
     passphrase_visible_button_->SetImage(views::ImageButton::BS_NORMAL,
         ResourceBundle::GetSharedInstance().
         GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE));
     passphrase_visible_button_->SetImageAlignment(
         views::ImageButton::ALIGN_CENTER, views::ImageButton::ALIGN_MIDDLE);
     // Disable viewing password by unauthenticated user.
     if (wifi_.get() && !wifi_->passphrase().empty() &&
         chromeos::UserManager::Get()->logged_in_user().email().empty()) {
       passphrase_visible_button_->SetVisible(false);
     }
     layout->AddView(passphrase_visible_button_);
     layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
   }
 
+  // Error label
   // If there's an error, add an error message label.
   // Right now, only displaying bad_passphrase and bad_wepkey errors.
   if (wifi_.get() && (wifi_->error() == ERROR_BAD_PASSPHRASE ||
       wifi_->error() == ERROR_BAD_WEPKEY)) {
     layout->StartRow(0, column_view_set_id);
     layout->SkipColumns(1);
     int id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_BAD_PASSPHRASE;
     if (wifi_->error() == ERROR_BAD_WEPKEY)
       id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_BAD_WEPKEY;
     views::Label* label_error = new views::Label(l10n_util::GetString(id));
@@ skipping 11 matching lines @@
     // For other network, default to autoconnect.
     bool autoconnect = other_network_ || wifi_->auto_connect();
     autoconnect_checkbox_->SetChecked(autoconnect);
     layout->StartRow(0, column_view_set_id);
     layout->AddView(autoconnect_checkbox_, 3, 1);
     layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
   }
 }
 
 }  // namespace chromeos