src/chrome/browser/ui/webui/options/chromeos/internet_options_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler.h"
   6
   7 #include <ctype.h>
   8
   9 #include <map>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "ash/system/chromeos/network/network_connect.h"
  14 #include "base/basictypes.h"
  15 #include "base/bind.h"
  16 #include "base/bind_helpers.h"
  17 #include "base/command_line.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/values.h"
  20 #include "chrome/browser/browser_process.h"
  21 #include "chrome/browser/chromeos/mobile_config.h"
  22 #include "chrome/browser/chromeos/net/onc_utils.h"
  23 #include "chrome/browser/chromeos/options/network_config_view.h"
  24 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
  25 #include "chrome/browser/chromeos/settings/cros_settings.h"
  26 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
  27 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
  28 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
  29 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
  30 #include "chrome/browser/profiles/profile.h"
  31 #include "chrome/browser/ui/webui/chromeos/mobile_setup_dialog.h"
  32 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
  33 #include "chromeos/chromeos_switches.h"
  34 #include "chromeos/login/login_state.h"
  35 #include "chromeos/network/device_state.h"
  36 #include "chromeos/network/managed_network_configuration_handler.h"
  37 #include "chromeos/network/network_configuration_handler.h"
  38 #include "chromeos/network/network_connection_handler.h"
  39 #include "chromeos/network/network_device_handler.h"
  40 #include "chromeos/network/network_event_log.h"
  41 #include "chromeos/network/network_ip_config.h"
  42 #include "chromeos/network/network_profile.h"
  43 #include "chromeos/network/network_profile_handler.h"
  44 #include "chromeos/network/network_state.h"
  45 #include "chromeos/network/network_state_handler.h"
  46 #include "chromeos/network/network_util.h"
  47 #include "chromeos/network/onc/onc_signature.h"
  48 #include "chromeos/network/onc/onc_translation_tables.h"
  49 #include "chromeos/network/onc/onc_translator.h"
  50 #include "chromeos/network/onc/onc_utils.h"
  51 #include "components/onc/onc_constants.h"
  52 #include "content/public/browser/web_contents.h"
  53 #include "content/public/browser/web_ui.h"
  54 #include "grit/ui_chromeos_resources.h"
  55 #include "third_party/cros_system_api/dbus/service_constants.h"
  56 #include "ui/base/resource/resource_bundle.h"
  57 #include "ui/base/webui/web_ui_util.h"
  58 #include "ui/chromeos/network/network_icon.h"
  59 #include "ui/gfx/image/image_skia.h"
  60
  61 namespace chromeos {
  62 namespace options {
  63
  64 namespace {
  65
  66 // Keys for the network description dictionary passed to the web ui. Make sure
  67 // to keep the strings in sync with what the JavaScript side uses.
  68 const char kNetworkInfoKeyIconURL[] = "iconURL";
  69 const char kNetworkInfoKeyPolicyManaged[] = "policyManaged";
  70
  71 // These are types of name server selections from the web ui.
  72 const char kNameServerTypeAutomatic[] = "automatic";
  73 const char kNameServerTypeGoogle[] = "google";
  74
  75 // Google public name servers (DNS).
  76 const char kGoogleNameServers[] = "8.8.4.4,8.8.8.8";
  77
  78 // Functions we call in JavaScript.
  79 const char kRefreshNetworkDataFunction[] =
  80     "options.network.NetworkList.refreshNetworkData";
  81 const char kSetDefaultNetworkIconsFunction[] =
  82     "options.network.NetworkList.setDefaultNetworkIcons";
  83 const char kSendNetworkDetailsFunction[] =
  84     "options.internet.DetailsInternetPage.sendNetworkDetails";
  85 const char kShowDetailedInfoFunction[] =
  86     "options.internet.DetailsInternetPage.showDetailedInfo";
  87 const char kUpdateConnectionDataFunction[] =
  88     "options.internet.DetailsInternetPage.updateConnectionData";
  89 const char kUpdateCarrierFunction[] =
  90     "options.internet.DetailsInternetPage.updateCarrier";
  91
  92 // These are used to register message handlers with JavaScript.
  93 const char kNetworkCommandMessage[] = "networkCommand";
  94 const char kSetApnMessage[] = "setApn";
  95 const char kSetAutoConnectMessage[] = "setAutoConnect";
  96 const char kSetCarrierMessage[] = "setCarrier";
  97 const char kSetIPConfigMessage[] = "setIPConfig";
  98 const char kSetPreferNetworkMessage[] = "setPreferNetwork";
  99 const char kSetServerHostname[] = "setServerHostname";
 100 const char kShowMorePlanInfoMessage[] = "showMorePlanInfo";
 101 const char kSimOperationMessage[] = "simOperation";
 102
 103 // TODO(stevenjb): Replace these with the matching networkingPrivate methods.
 104 // crbug.com/279351.
 105 const char kDisableNetworkTypeMessage[] = "disableNetworkType";
 106 const char kEnableNetworkTypeMessage[] = "enableNetworkType";
 107 const char kGetManagedPropertiesMessage[] = "getManagedProperties";
 108 const char kRequestNetworkScanMessage[] = "requestNetworkScan";
 109 const char kStartConnectMessage[] = "startConnect";
 110 const char kStartDisconnectMessage[] = "startDisconnect";
 111
 112 // These are strings used to communicate with JavaScript.
 113 const char kTagActivate[] = "activate";
 114 const char kTagAddConnection[] = "add";
 115 const char kTagCarrierSelectFlag[] = "showCarrierSelect";
 116 const char kTagCellularAvailable[] = "cellularAvailable";
 117 const char kTagCellularEnabled[] = "cellularEnabled";
 118 const char kTagCellularSimAbsent[] = "cellularSimAbsent";
 119 const char kTagCellularSimLockType[] = "cellularSimLockType";
 120 const char kTagCellularSupportsScan[] = "cellularSupportsScan";
 121 const char kTagConfigure[] = "configure";
 122 const char kTagForget[] = "forget";
 123 const char kTagRememberedList[] = "rememberedList";
 124 const char kTagShowDetails[] = "showDetails";
 125 const char kTagShowViewAccountButton[] = "showViewAccountButton";
 126 const char kTagSimOpChangePin[] = "changePin";
 127 const char kTagSimOpConfigure[] = "configure";
 128 const char kTagSimOpSetLocked[] = "setLocked";
 129 const char kTagSimOpSetUnlocked[] = "setUnlocked";
 130 const char kTagSimOpUnlock[] = "unlock";
 131 const char kTagTrue[] = "true";
 132 const char kTagVpnList[] = "vpnList";
 133 const char kTagWifiAvailable[] = "wifiAvailable";
 134 const char kTagWifiEnabled[] = "wifiEnabled";
 135 const char kTagWimaxAvailable[] = "wimaxAvailable";
 136 const char kTagWimaxEnabled[] = "wimaxEnabled";
 137 const char kTagWiredList[] = "wiredList";
 138 const char kTagWirelessList[] = "wirelessList";
 139
 140 // Pseudo-ONC chrome specific properties appended to the ONC dictionary.
 141 const char kTagErrorMessage[] = "errorMessage";
 142 const char kNetworkInfoKeyServicePath[] = "servicePath";
 143 const char kNetworkInfoKeyGUID[] = "GUID";
 144
 145 const int kPreferredPriority = 1;
 146
 147 void ShillError(const std::string& function,
 148                 const std::string& error_name,
 149                 scoped_ptr<base::DictionaryValue> error_data) {
 150   // UpdateConnectionData may send requests for stale services; ignore
 151   // these errors.
 152   if (function == "UpdateConnectionData" &&
 153       error_name == network_handler::kDBusFailedError)
 154     return;
 155   NET_LOG_ERROR("Shill Error from InternetOptionsHandler: " + error_name,
 156                 function);
 157 }
 158
 159 const NetworkState* GetNetworkState(const std::string& service_path) {
 160   return NetworkHandler::Get()->network_state_handler()->
 161       GetNetworkState(service_path);
 162 }
 163
 164 void SetNetworkProperty(const std::string& service_path,
 165                         const std::string& property,
 166                         base::Value* value) {
 167   NET_LOG_EVENT("SetNetworkProperty: " + property, service_path);
 168   base::DictionaryValue properties;
 169   properties.SetWithoutPathExpansion(property, value);
 170   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
 171       service_path, properties,
 172       base::Bind(&base::DoNothing),
 173       base::Bind(&ShillError, "SetNetworkProperty"));
 174 }
 175
 176 // Builds a dictionary with network information and an icon used for the
 177 // NetworkList on the settings page. Ownership of the returned pointer is
 178 // transferred to the caller.
 179 base::DictionaryValue* BuildNetworkDictionary(
 180     const NetworkState* network,
 181     float icon_scale_factor,
 182     const PrefService* profile_prefs) {
 183   scoped_ptr<base::DictionaryValue> network_info =
 184       network_util::TranslateNetworkStateToONC(network);
 185
 186   bool has_policy = onc::HasPolicyForNetwork(
 187       profile_prefs, g_browser_process->local_state(), *network);
 188   network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, has_policy);
 189
 190   std::string icon_url = ui::network_icon::GetImageUrlForNetwork(
 191       network, ui::network_icon::ICON_TYPE_LIST, icon_scale_factor);
 192
 193   network_info->SetString(kNetworkInfoKeyIconURL, icon_url);
 194   network_info->SetString(kNetworkInfoKeyServicePath, network->path());
 195
 196   return network_info.release();
 197 }
 198
 199 bool ShowViewAccountButton(const NetworkState* cellular) {
 200   if (cellular->activation_state() != shill::kActivationStateActivating &&
 201       cellular->activation_state() != shill::kActivationStateActivated)
 202     return false;
 203
 204   const DeviceState* device =
 205       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
 206           cellular->device_path());
 207
 208   // If no online payment URL was provided by shill, Check to see if the
 209   // MobileConfig carrier indicates that "View Account" should be shown.
 210   if (cellular->payment_url().empty()) {
 211     if (!device || !MobileConfig::GetInstance()->IsReady())
 212       return false;
 213     const MobileConfig::Carrier* carrier =
 214         MobileConfig::GetInstance()->GetCarrier(device->home_provider_id());
 215     if (!carrier || !carrier->show_portal_button())
 216       return false;
 217   }
 218
 219   if (!cellular->IsConnectedState()) {
 220     // Disconnected LTE networks should show the button if we are online and
 221     // the device's MDN is set. This is to enable users to update their plan
 222     // if they are out of credits.
 223     if (!NetworkHandler::Get()->network_state_handler()->DefaultNetwork())
 224       return false;
 225     const std::string& technology = cellular->network_technology();
 226     if (technology != shill::kNetworkTechnologyLte &&
 227         technology != shill::kNetworkTechnologyLteAdvanced)
 228       return false;
 229     std::string mdn;
 230     if (device) {
 231       device->properties().GetStringWithoutPathExpansion(shill::kMdnProperty,
 232                                                          &mdn);
 233     }
 234     if (mdn.empty())
 235       return false;
 236   }
 237
 238   return true;
 239 }
 240
 241 scoped_ptr<base::DictionaryValue> PopulateConnectionDetails(
 242     const NetworkState* network,
 243     const base::DictionaryValue& onc_properties) {
 244   scoped_ptr<base::DictionaryValue> dictionary(onc_properties.DeepCopy());
 245
 246   // Append Service Path for now.
 247   dictionary->SetString(kNetworkInfoKeyServicePath, network->path());
 248   // Append a Chrome specific translated error message.
 249   dictionary->SetString(
 250       kTagErrorMessage,
 251       ash::network_connect::ErrorString(network->error(), network->path()));
 252
 253   return dictionary.Pass();
 254 }
 255
 256 // Helper methods for SetIPConfigProperties
 257 bool AppendPropertyKeyIfPresent(const std::string& key,
 258                                 const base::DictionaryValue& old_properties,
 259                                 std::vector<std::string>* property_keys) {
 260   if (old_properties.HasKey(key)) {
 261     property_keys->push_back(key);
 262     return true;
 263   }
 264   return false;
 265 }
 266
 267 bool AddStringPropertyIfChanged(const std::string& key,
 268                                 const std::string& new_value,
 269                                 const base::DictionaryValue& old_properties,
 270                                 base::DictionaryValue* new_properties) {
 271   std::string old_value;
 272   if (!old_properties.GetStringWithoutPathExpansion(key, &old_value) ||
 273       new_value != old_value) {
 274     new_properties->SetStringWithoutPathExpansion(key, new_value);
 275     return true;
 276   }
 277   return false;
 278 }
 279
 280 bool AddIntegerPropertyIfChanged(const std::string& key,
 281                                  int new_value,
 282                                  const base::DictionaryValue& old_properties,
 283                                  base::DictionaryValue* new_properties) {
 284   int old_value;
 285   if (!old_properties.GetIntegerWithoutPathExpansion(key, &old_value) ||
 286       new_value != old_value) {
 287     new_properties->SetIntegerWithoutPathExpansion(key, new_value);
 288     return true;
 289   }
 290   return false;
 291 }
 292
 293 }  // namespace
 294
 295 InternetOptionsHandler::InternetOptionsHandler()
 296     : weak_factory_(this) {
 297   NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
 298 }
 299
 300 InternetOptionsHandler::~InternetOptionsHandler() {
 301   if (NetworkHandler::IsInitialized()) {
 302     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
 303         this, FROM_HERE);
 304   }
 305 }
 306
 307 void InternetOptionsHandler::GetLocalizedValues(
 308     base::DictionaryValue* localized_strings) {
 309   DCHECK(localized_strings);
 310   internet_options_strings::RegisterLocalizedStrings(localized_strings);
 311
 312   // TODO(stevenjb): Find a better way to populate initial data before
 313   // InitializePage() gets called.
 314   std::string owner;
 315   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
 316   localized_strings->SetString("ownerUserId", base::UTF8ToUTF16(owner));
 317   bool logged_in_as_owner = LoginState::Get()->GetLoggedInUserType() ==
 318                             LoginState::LOGGED_IN_USER_OWNER;
 319   localized_strings->SetBoolean("loggedInAsOwner", logged_in_as_owner);
 320
 321   base::DictionaryValue* network_dictionary = new base::DictionaryValue;
 322   FillNetworkInfo(network_dictionary);
 323   localized_strings->Set("networkData", network_dictionary);
 324 }
 325
 326 void InternetOptionsHandler::InitializePage() {
 327   base::DictionaryValue dictionary;
 328   dictionary.SetString(::onc::network_type::kCellular,
 329       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK));
 330   dictionary.SetString(::onc::network_type::kWiFi,
 331       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK));
 332   dictionary.SetString(::onc::network_type::kVPN,
 333       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_VPN));
 334   web_ui()->CallJavascriptFunction(kSetDefaultNetworkIconsFunction,
 335                                    dictionary);
 336   NetworkHandler::Get()->network_state_handler()->RequestScan();
 337   RefreshNetworkData();
 338 }
 339
 340 void InternetOptionsHandler::RegisterMessages() {
 341   // Setup handlers specific to this panel.
 342   web_ui()->RegisterMessageCallback(kNetworkCommandMessage,
 343       base::Bind(&InternetOptionsHandler::NetworkCommandCallback,
 344                  base::Unretained(this)));
 345   web_ui()->RegisterMessageCallback(kSetPreferNetworkMessage,
 346       base::Bind(&InternetOptionsHandler::SetPreferNetworkCallback,
 347                  base::Unretained(this)));
 348   web_ui()->RegisterMessageCallback(kSetAutoConnectMessage,
 349       base::Bind(&InternetOptionsHandler::SetAutoConnectCallback,
 350                  base::Unretained(this)));
 351   web_ui()->RegisterMessageCallback(kSetIPConfigMessage,
 352       base::Bind(&InternetOptionsHandler::SetIPConfigCallback,
 353                  base::Unretained(this)));
 354   web_ui()->RegisterMessageCallback(kShowMorePlanInfoMessage,
 355       base::Bind(&InternetOptionsHandler::ShowMorePlanInfoCallback,
 356                  base::Unretained(this)));
 357   web_ui()->RegisterMessageCallback(kSetApnMessage,
 358       base::Bind(&InternetOptionsHandler::SetApnCallback,
 359                  base::Unretained(this)));
 360   web_ui()->RegisterMessageCallback(kSetCarrierMessage,
 361       base::Bind(&InternetOptionsHandler::SetCarrierCallback,
 362                  base::Unretained(this)));
 363   web_ui()->RegisterMessageCallback(kSimOperationMessage,
 364       base::Bind(&InternetOptionsHandler::SimOperationCallback,
 365                  base::Unretained(this)));
 366   web_ui()->RegisterMessageCallback(kSetServerHostname,
 367       base::Bind(&InternetOptionsHandler::SetServerHostnameCallback,
 368                  base::Unretained(this)));
 369
 370   // networkingPrivate methods
 371   web_ui()->RegisterMessageCallback(kDisableNetworkTypeMessage,
 372       base::Bind(&InternetOptionsHandler::DisableNetworkTypeCallback,
 373                  base::Unretained(this)));
 374   web_ui()->RegisterMessageCallback(kEnableNetworkTypeMessage,
 375       base::Bind(&InternetOptionsHandler::EnableNetworkTypeCallback,
 376                  base::Unretained(this)));
 377   web_ui()->RegisterMessageCallback(kGetManagedPropertiesMessage,
 378       base::Bind(&InternetOptionsHandler::GetManagedPropertiesCallback,
 379                  base::Unretained(this)));
 380   web_ui()->RegisterMessageCallback(kRequestNetworkScanMessage,
 381       base::Bind(&InternetOptionsHandler::RequestNetworkScanCallback,
 382                  base::Unretained(this)));
 383   web_ui()->RegisterMessageCallback(kStartConnectMessage,
 384       base::Bind(&InternetOptionsHandler::StartConnectCallback,
 385                  base::Unretained(this)));
 386   web_ui()->RegisterMessageCallback(kStartDisconnectMessage,
 387       base::Bind(&InternetOptionsHandler::StartDisconnectCallback,
 388                  base::Unretained(this)));
 389 }
 390
 391 void InternetOptionsHandler::ShowMorePlanInfoCallback(
 392     const base::ListValue* args) {
 393   if (!web_ui())
 394     return;
 395   std::string service_path;
 396   if (args->GetSize() != 1 || !args->GetString(0, &service_path)) {
 397     NOTREACHED();
 398     return;
 399   }
 400   ash::network_connect::ShowMobileSetup(service_path);
 401 }
 402
 403 void InternetOptionsHandler::SetApnCallback(const base::ListValue* args) {
 404   std::string service_path;
 405   if (!args->GetString(0, &service_path)) {
 406     NOTREACHED();
 407     return;
 408   }
 409   NetworkHandler::Get()->network_configuration_handler()->GetProperties(
 410       service_path,
 411       base::Bind(&InternetOptionsHandler::SetApnProperties,
 412                  weak_factory_.GetWeakPtr(), base::Owned(args->DeepCopy())),
 413       base::Bind(&ShillError, "SetApnCallback"));
 414 }
 415
 416 void InternetOptionsHandler::SetApnProperties(
 417     const base::ListValue* args,
 418     const std::string& service_path,
 419     const base::DictionaryValue& shill_properties) {
 420   std::string apn, username, password;
 421   if (!args->GetString(1, &apn) ||
 422       !args->GetString(2, &username) ||
 423       !args->GetString(3, &password)) {
 424     NOTREACHED();
 425     return;
 426   }
 427   NET_LOG_EVENT("SetApnCallback", service_path);
 428
 429   if (apn.empty()) {
 430     std::vector<std::string> properties_to_clear;
 431     properties_to_clear.push_back(shill::kCellularApnProperty);
 432     NetworkHandler::Get()->network_configuration_handler()->ClearProperties(
 433       service_path, properties_to_clear,
 434       base::Bind(&base::DoNothing),
 435       base::Bind(&ShillError, "ClearCellularApnProperties"));
 436     return;
 437   }
 438
 439   const base::DictionaryValue* shill_apn_dict = NULL;
 440   std::string network_id;
 441   if (shill_properties.GetDictionaryWithoutPathExpansion(
 442           shill::kCellularApnProperty, &shill_apn_dict)) {
 443     shill_apn_dict->GetStringWithoutPathExpansion(
 444         shill::kApnNetworkIdProperty, &network_id);
 445   }
 446   base::DictionaryValue properties;
 447   base::DictionaryValue* apn_dict = new base::DictionaryValue;
 448   apn_dict->SetStringWithoutPathExpansion(shill::kApnProperty, apn);
 449   apn_dict->SetStringWithoutPathExpansion(shill::kApnNetworkIdProperty,
 450                                           network_id);
 451   apn_dict->SetStringWithoutPathExpansion(shill::kApnUsernameProperty,
 452                                           username);
 453   apn_dict->SetStringWithoutPathExpansion(shill::kApnPasswordProperty,
 454                                           password);
 455   properties.SetWithoutPathExpansion(shill::kCellularApnProperty, apn_dict);
 456   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
 457       service_path, properties,
 458       base::Bind(&base::DoNothing),
 459       base::Bind(&ShillError, "SetApnProperties"));
 460 }
 461
 462 void InternetOptionsHandler::CarrierStatusCallback() {
 463   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 464   const DeviceState* device =
 465       handler->GetDeviceStateByType(NetworkTypePattern::Cellular());
 466   if (device && (device->carrier() == shill::kCarrierSprint)) {
 467     const NetworkState* network =
 468         handler->FirstNetworkByType(NetworkTypePattern::Cellular());
 469     if (network && network->path() == details_path_) {
 470       ash::network_connect::ActivateCellular(network->path());
 471       UpdateConnectionData(network->path());
 472     }
 473   }
 474   UpdateCarrier();
 475 }
 476
 477 void InternetOptionsHandler::SetCarrierCallback(const base::ListValue* args) {
 478   std::string service_path;
 479   std::string carrier;
 480   if (args->GetSize() != 2 ||
 481       !args->GetString(0, &service_path) ||
 482       !args->GetString(1, &carrier)) {
 483     NOTREACHED();
 484     return;
 485   }
 486   const DeviceState* device = NetworkHandler::Get()->network_state_handler()->
 487       GetDeviceStateByType(NetworkTypePattern::Cellular());
 488   if (!device) {
 489     LOG(WARNING) << "SetCarrierCallback with no cellular device.";
 490     return;
 491   }
 492   NetworkHandler::Get()->network_device_handler()->SetCarrier(
 493       device->path(),
 494       carrier,
 495       base::Bind(&InternetOptionsHandler::CarrierStatusCallback,
 496                  weak_factory_.GetWeakPtr()),
 497       base::Bind(&ShillError, "SetCarrierCallback"));
 498 }
 499
 500 void InternetOptionsHandler::SimOperationCallback(const base::ListValue* args) {
 501   std::string operation;
 502   if (args->GetSize() != 1 || !args->GetString(0, &operation)) {
 503     NOTREACHED();
 504     return;
 505   }
 506   if (operation == kTagSimOpConfigure) {
 507     mobile_config_ui::DisplayConfigDialog();
 508     return;
 509   }
 510   // 1. Bring up SIM unlock dialog, pass new RequirePin setting in URL.
 511   // 2. Dialog will ask for current PIN in any case.
 512   // 3. If card is locked it will first call PIN unlock operation
 513   // 4. Then it will call Set RequirePin, passing the same PIN.
 514   // 5. The dialog may change device properties, in which case
 515   //    DevicePropertiesUpdated() will get called which will update the UI.
 516   SimDialogDelegate::SimDialogMode mode;
 517   if (operation == kTagSimOpSetLocked) {
 518     mode = SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON;
 519   } else if (operation == kTagSimOpSetUnlocked) {
 520     mode = SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF;
 521   } else if (operation == kTagSimOpUnlock) {
 522     mode = SimDialogDelegate::SIM_DIALOG_UNLOCK;
 523   } else if (operation == kTagSimOpChangePin) {
 524     mode = SimDialogDelegate::SIM_DIALOG_CHANGE_PIN;
 525   } else {
 526     NOTREACHED();
 527     return;
 528   }
 529   SimDialogDelegate::ShowDialog(GetNativeWindow(), mode);
 530 }
 531
 532 ////////////////////////////////////////////////////////////////////////////////
 533 // networkingPrivate implementation methods. TODO(stevenjb): Use the
 534 // networkingPrivate API directly in the settings JS and deprecate these
 535 // methods. crbug.com/279351.
 536
 537 void InternetOptionsHandler::DisableNetworkTypeCallback(
 538     const base::ListValue* args) {
 539   std::string type;
 540   if (!args->GetString(0, &type)) {
 541     NOTREACHED();
 542     return;
 543   }
 544   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
 545       chromeos::onc::NetworkTypePatternFromOncType(type), false,
 546       base::Bind(&ShillError, "DisableNetworkType"));
 547 }
 548
 549 void InternetOptionsHandler::EnableNetworkTypeCallback(
 550     const base::ListValue* args) {
 551   std::string type;
 552   if (!args->GetString(0, &type)) {
 553     NOTREACHED();
 554     return;
 555   }
 556   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
 557       chromeos::onc::NetworkTypePatternFromOncType(type), true,
 558       base::Bind(&ShillError, "EnableNetworkType"));
 559 }
 560
 561 void InternetOptionsHandler::GetManagedPropertiesCallback(
 562     const base::ListValue* args) {
 563   std::string service_path;
 564   if (!args->GetString(0, &service_path)) {
 565     NOTREACHED();
 566     return;
 567   }
 568   NetworkHandler::Get()->managed_network_configuration_handler()
 569       ->GetManagedProperties(
 570           LoginState::Get()->primary_user_hash(),
 571           service_path,
 572           base::Bind(
 573               &InternetOptionsHandler::PopulateDictionaryDetailsCallback,
 574               weak_factory_.GetWeakPtr()),
 575           base::Bind(&ShillError, "GetManagedProperties"));
 576 }
 577
 578 void InternetOptionsHandler::RequestNetworkScanCallback(
 579     const base::ListValue* args) {
 580   NetworkHandler::Get()->network_state_handler()->RequestScan();
 581 }
 582
 583 void InternetOptionsHandler::StartConnectCallback(const base::ListValue* args) {
 584   std::string service_path;
 585   if (!args->GetString(0, &service_path)) {
 586     NOTREACHED();
 587     return;
 588   }
 589   ash::network_connect::ConnectToNetwork(service_path);
 590 }
 591
 592 void InternetOptionsHandler::StartDisconnectCallback(
 593     const base::ListValue* args) {
 594   std::string service_path;
 595   if (!args->GetString(0, &service_path)) {
 596     NOTREACHED();
 597     return;
 598   }
 599   NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
 600       service_path,
 601       base::Bind(&base::DoNothing),
 602       base::Bind(&ShillError, "StartDisconnectCallback"));
 603 }
 604
 605 ////////////////////////////////////////////////////////////////////////////////
 606
 607 std::string InternetOptionsHandler::GetIconDataUrl(int resource_id) const {
 608   gfx::ImageSkia* icon =
 609       ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
 610   gfx::ImageSkiaRep image_rep = icon->GetRepresentation(
 611       web_ui()->GetDeviceScaleFactor());
 612   return webui::GetBitmapDataUrl(image_rep.sk_bitmap());
 613 }
 614
 615 void InternetOptionsHandler::RefreshNetworkData() {
 616   base::DictionaryValue dictionary;
 617   FillNetworkInfo(&dictionary);
 618   web_ui()->CallJavascriptFunction(kRefreshNetworkDataFunction, dictionary);
 619 }
 620
 621 void InternetOptionsHandler::UpdateConnectionData(
 622     const std::string& service_path) {
 623   NetworkHandler::Get()
 624       ->managed_network_configuration_handler()
 625       ->GetManagedProperties(
 626           LoginState::Get()->primary_user_hash(),
 627           service_path,
 628           base::Bind(&InternetOptionsHandler::UpdateConnectionDataCallback,
 629                      weak_factory_.GetWeakPtr()),
 630           base::Bind(&ShillError, "UpdateConnectionData"));
 631 }
 632
 633 void InternetOptionsHandler::UpdateConnectionDataCallback(
 634     const std::string& service_path,
 635     const base::DictionaryValue& onc_properties) {
 636   const NetworkState* network = GetNetworkState(service_path);
 637   if (!network)
 638     return;
 639   scoped_ptr<base::DictionaryValue> dictionary =
 640       PopulateConnectionDetails(network, onc_properties);
 641   web_ui()->CallJavascriptFunction(kUpdateConnectionDataFunction, *dictionary);
 642 }
 643
 644 void InternetOptionsHandler::UpdateCarrier() {
 645   web_ui()->CallJavascriptFunction(kUpdateCarrierFunction);
 646 }
 647
 648 void InternetOptionsHandler::DeviceListChanged() {
 649   if (!web_ui())
 650     return;
 651   RefreshNetworkData();
 652 }
 653
 654 void InternetOptionsHandler::NetworkListChanged() {
 655   if (!web_ui())
 656     return;
 657   RefreshNetworkData();
 658 }
 659
 660 void InternetOptionsHandler::NetworkConnectionStateChanged(
 661     const NetworkState* network) {
 662   if (!web_ui())
 663     return;
 664   if (network->path() == details_path_)
 665     UpdateConnectionData(network->path());
 666 }
 667
 668 void InternetOptionsHandler::NetworkPropertiesUpdated(
 669     const NetworkState* network) {
 670   if (!web_ui())
 671     return;
 672   RefreshNetworkData();
 673   if (network->path() == details_path_)
 674     UpdateConnectionData(network->path());
 675 }
 676
 677 void InternetOptionsHandler::DevicePropertiesUpdated(
 678     const DeviceState* device) {
 679   if (!web_ui())
 680     return;
 681   if (device->type() != shill::kTypeCellular)
 682     return;
 683   const NetworkState* network =
 684       NetworkHandler::Get()->network_state_handler()->FirstNetworkByType(
 685           NetworkTypePattern::Cellular());
 686   if (network && network->path() == details_path_)
 687     UpdateConnectionData(network->path());
 688 }
 689
 690 void InternetOptionsHandler::SetServerHostnameCallback(
 691     const base::ListValue* args) {
 692   std::string service_path, server_hostname;
 693   if (args->GetSize() < 2 ||
 694       !args->GetString(0, &service_path) ||
 695       !args->GetString(1, &server_hostname)) {
 696     NOTREACHED();
 697     return;
 698   }
 699   SetNetworkProperty(service_path,
 700                      shill::kProviderHostProperty,
 701                      new base::StringValue(server_hostname));
 702 }
 703
 704 void InternetOptionsHandler::SetPreferNetworkCallback(
 705     const base::ListValue* args) {
 706   std::string service_path, prefer_network_str;
 707   if (args->GetSize() < 2 ||
 708       !args->GetString(0, &service_path) ||
 709       !args->GetString(1, &prefer_network_str)) {
 710     NOTREACHED();
 711     return;
 712   }
 713   int priority = (prefer_network_str == kTagTrue) ? kPreferredPriority : 0;
 714   SetNetworkProperty(service_path,
 715                      shill::kPriorityProperty,
 716                      new base::FundamentalValue(priority));
 717 }
 718
 719 void InternetOptionsHandler::SetAutoConnectCallback(
 720     const base::ListValue* args) {
 721   std::string service_path, auto_connect_str;
 722   if (args->GetSize() < 2 ||
 723       !args->GetString(0, &service_path) ||
 724       !args->GetString(1, &auto_connect_str)) {
 725     NOTREACHED();
 726     return;
 727   }
 728   bool auto_connect = auto_connect_str == kTagTrue;
 729   SetNetworkProperty(service_path,
 730                      shill::kAutoConnectProperty,
 731                      new base::FundamentalValue(auto_connect));
 732 }
 733
 734 void InternetOptionsHandler::SetIPConfigCallback(const base::ListValue* args) {
 735   std::string service_path;
 736   if (!args->GetString(0, &service_path)) {
 737     NOTREACHED();
 738     return;
 739   }
 740   NetworkHandler::Get()->network_configuration_handler()->GetProperties(
 741       service_path,
 742       base::Bind(&InternetOptionsHandler::SetIPConfigProperties,
 743                  weak_factory_.GetWeakPtr(), base::Owned(args->DeepCopy())),
 744       base::Bind(&ShillError, "SetIPConfigCallback"));
 745 }
 746
 747 void InternetOptionsHandler::SetIPConfigProperties(
 748     const base::ListValue* args,
 749     const std::string& service_path,
 750     const base::DictionaryValue& shill_properties) {
 751   std::string address, netmask, gateway, name_server_type, name_servers;
 752   bool dhcp_for_ip;
 753   if (!args->GetBoolean(1, &dhcp_for_ip) ||
 754       !args->GetString(2, &address) ||
 755       !args->GetString(3, &netmask) ||
 756       !args->GetString(4, &gateway) ||
 757       !args->GetString(5, &name_server_type) ||
 758       !args->GetString(6, &name_servers)) {
 759     NOTREACHED();
 760     return;
 761   }
 762   NET_LOG_USER("SetIPConfigProperties: " + name_server_type, service_path);
 763
 764   std::vector<std::string> properties_to_clear;
 765   base::DictionaryValue properties_to_set;
 766
 767   if (dhcp_for_ip) {
 768     AppendPropertyKeyIfPresent(shill::kStaticIPAddressProperty,
 769                                shill_properties,
 770                                &properties_to_clear);
 771     AppendPropertyKeyIfPresent(shill::kStaticIPPrefixlenProperty,
 772                                shill_properties,
 773                                &properties_to_clear);
 774     AppendPropertyKeyIfPresent(shill::kStaticIPGatewayProperty,
 775                                shill_properties,
 776                                &properties_to_clear);
 777   } else {
 778     AddStringPropertyIfChanged(shill::kStaticIPAddressProperty,
 779                                address,
 780                                shill_properties,
 781                                &properties_to_set);
 782     int prefixlen = network_util::NetmaskToPrefixLength(netmask);
 783     if (prefixlen < 0) {
 784       LOG(ERROR) << "Invalid prefix length for: " << service_path
 785                  << " with netmask " << netmask;
 786       prefixlen = 0;
 787     }
 788     AddIntegerPropertyIfChanged(shill::kStaticIPPrefixlenProperty,
 789                                 prefixlen,
 790                                 shill_properties,
 791                                 &properties_to_set);
 792     AddStringPropertyIfChanged(shill::kStaticIPGatewayProperty,
 793                                gateway,
 794                                shill_properties,
 795                                &properties_to_set);
 796   }
 797
 798   if (name_server_type == kNameServerTypeAutomatic) {
 799     AppendPropertyKeyIfPresent(shill::kStaticIPNameServersProperty,
 800                                shill_properties,
 801                                &properties_to_clear);
 802   } else {
 803     if (name_server_type == kNameServerTypeGoogle)
 804       name_servers = kGoogleNameServers;
 805     AddStringPropertyIfChanged(shill::kStaticIPNameServersProperty,
 806                                name_servers,
 807                                shill_properties,
 808                                &properties_to_set);
 809   }
 810
 811   if (!properties_to_clear.empty()) {
 812     NetworkHandler::Get()->network_configuration_handler()->ClearProperties(
 813         service_path,
 814         properties_to_clear,
 815         base::Bind(&base::DoNothing),
 816         base::Bind(&ShillError, "ClearIPConfigProperties"));
 817   }
 818   if (!properties_to_set.empty()) {
 819     NetworkHandler::Get()->network_configuration_handler()->SetProperties(
 820         service_path,
 821         properties_to_set,
 822         base::Bind(&base::DoNothing),
 823         base::Bind(&ShillError, "SetIPConfigProperties"));
 824   }
 825   std::string device_path;
 826   shill_properties.GetStringWithoutPathExpansion(shill::kDeviceProperty,
 827                                                  &device_path);
 828   if (!device_path.empty()) {
 829     NetworkHandler::Get()->network_device_handler()->RequestRefreshIPConfigs(
 830         device_path,
 831         base::Bind(&base::DoNothing),
 832         base::Bind(&ShillError, "RequestRefreshIPConfigs"));
 833   }
 834 }
 835
 836 void InternetOptionsHandler::PopulateDictionaryDetailsCallback(
 837     const std::string& service_path,
 838     const base::DictionaryValue& onc_properties) {
 839   const NetworkState* network = GetNetworkState(service_path);
 840   if (!network) {
 841     LOG(ERROR) << "Network properties not found: " << service_path;
 842     return;
 843   }
 844   scoped_ptr<base::DictionaryValue> dictionary =
 845       PopulateConnectionDetails(network, onc_properties);
 846
 847   // Show details dialog
 848   web_ui()->CallJavascriptFunction(kSendNetworkDetailsFunction, *dictionary);
 849 }
 850
 851 gfx::NativeWindow InternetOptionsHandler::GetNativeWindow() const {
 852   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 853 }
 854
 855 float InternetOptionsHandler::GetScaleFactor() const {
 856   return web_ui()->GetDeviceScaleFactor();
 857 }
 858
 859 const PrefService* InternetOptionsHandler::GetPrefs() const {
 860   return Profile::FromWebUI(web_ui())->GetPrefs();
 861 }
 862
 863 void InternetOptionsHandler::NetworkCommandCallback(
 864     const base::ListValue* args) {
 865   std::string onc_type;
 866   std::string service_path;
 867   std::string command;
 868   if (args->GetSize() != 3 ||
 869       !args->GetString(0, &onc_type) ||
 870       !args->GetString(1, &service_path) ||
 871       !args->GetString(2, &command)) {
 872     NOTREACHED();
 873     return;
 874   }
 875   std::string type;  // Shill type
 876   if (!onc_type.empty()) {
 877     type = network_util::TranslateONCTypeToShill(onc_type);
 878     if (type.empty())
 879       LOG(ERROR) << "Unable to translate ONC type: " << onc_type;
 880   }
 881   // Process commands that do not require an existing network.
 882   if (command == kTagAddConnection) {
 883     AddConnection(type);
 884   } else if (command == kTagForget) {
 885     NetworkHandler::Get()->network_configuration_handler()->
 886         RemoveConfiguration(
 887             service_path,
 888             base::Bind(&base::DoNothing),
 889             base::Bind(&ShillError, "NetworkCommand: " + command));
 890   } else if (command == kTagShowDetails) {
 891     SendShowDetailedInfo(service_path);
 892   } else if (command == kTagConfigure) {
 893     NetworkConfigView::Show(service_path, GetNativeWindow());
 894   } else if (command == kTagActivate && type == shill::kTypeCellular) {
 895     ash::network_connect::ActivateCellular(service_path);
 896     // Activation may update network properties (e.g. ActivationState), so
 897     // request them here in case they change.
 898     UpdateConnectionData(service_path);
 899   } else {
 900     LOG(ERROR) << "Unknown internet options command: " << command;
 901     NOTREACHED();
 902   }
 903 }
 904
 905 void InternetOptionsHandler::AddConnection(const std::string& type) {
 906   if (type == shill::kTypeWifi) {
 907     NetworkConfigView::ShowForType(shill::kTypeWifi, GetNativeWindow());
 908   } else if (type == shill::kTypeVPN) {
 909     NetworkConfigView::ShowForType(shill::kTypeVPN, GetNativeWindow());
 910   } else if (type == shill::kTypeCellular) {
 911     ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
 912   } else {
 913     LOG(ERROR) << "Unsupported type for AddConnection";
 914   }
 915 }
 916
 917 void InternetOptionsHandler::SendShowDetailedInfo(
 918     const std::string& service_path) {
 919   details_path_ = service_path;
 920
 921   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
 922   const NetworkState* network = GetNetworkState(service_path);
 923   if (network) {
 924     dictionary->SetString(kNetworkInfoKeyServicePath, service_path);
 925     dictionary->SetString(kNetworkInfoKeyGUID, network->guid());
 926     if (network->type() == shill::kTypeCellular) {
 927       dictionary->SetBoolean(
 928           kTagCarrierSelectFlag,
 929           CommandLine::ForCurrentProcess()
 930           ->HasSwitch(chromeos::switches::kEnableCarrierSwitching));
 931       dictionary->SetBoolean(kTagShowViewAccountButton,
 932                              ShowViewAccountButton(network));
 933     }
 934   }
 935   web_ui()->CallJavascriptFunction(kShowDetailedInfoFunction, *dictionary);
 936 }
 937
 938 base::ListValue* InternetOptionsHandler::GetWiredList() {
 939   base::ListValue* list = new base::ListValue();
 940   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
 941       FirstNetworkByType(NetworkTypePattern::Ethernet());
 942   if (!network)
 943     return list;
 944   list->Append(BuildNetworkDictionary(network, GetScaleFactor(), GetPrefs()));
 945   return list;
 946 }
 947
 948 base::ListValue* InternetOptionsHandler::GetWirelessList() {
 949   base::ListValue* list = new base::ListValue();
 950
 951   NetworkStateHandler::NetworkStateList networks;
 952   NetworkHandler::Get()->network_state_handler()->GetVisibleNetworkListByType(
 953       NetworkTypePattern::Wireless(), &networks);
 954   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
 955            networks.begin(); iter != networks.end(); ++iter) {
 956     list->Append(BuildNetworkDictionary(*iter, GetScaleFactor(), GetPrefs()));
 957   }
 958
 959   return list;
 960 }
 961
 962 base::ListValue* InternetOptionsHandler::GetVPNList() {
 963   base::ListValue* list = new base::ListValue();
 964
 965   NetworkStateHandler::NetworkStateList networks;
 966   NetworkHandler::Get()->network_state_handler()->GetVisibleNetworkListByType(
 967       NetworkTypePattern::VPN(), &networks);
 968   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
 969            networks.begin(); iter != networks.end(); ++iter) {
 970     list->Append(BuildNetworkDictionary(*iter, GetScaleFactor(), GetPrefs()));
 971   }
 972
 973   return list;
 974 }
 975
 976 base::ListValue* InternetOptionsHandler::GetRememberedList() {
 977   base::ListValue* list = new base::ListValue();
 978
 979   NetworkStateHandler::NetworkStateList networks;
 980   NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
 981       NetworkTypePattern::Default(),
 982       true /* configured_only */,
 983       false /* visible_only */,
 984       0 /* no limit */,
 985       &networks);
 986   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
 987            networks.begin(); iter != networks.end(); ++iter) {
 988     const NetworkState* network = *iter;
 989     if (network->type() != shill::kTypeWifi &&
 990         network->type() != shill::kTypeVPN)
 991       continue;
 992     list->Append(
 993         BuildNetworkDictionary(network,
 994                                web_ui()->GetDeviceScaleFactor(),
 995                                Profile::FromWebUI(web_ui())->GetPrefs()));
 996   }
 997
 998   return list;
 999 }
1000
1001 void InternetOptionsHandler::FillNetworkInfo(
1002     base::DictionaryValue* dictionary) {
1003   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
1004   dictionary->Set(kTagWiredList, GetWiredList());
1005   dictionary->Set(kTagWirelessList, GetWirelessList());
1006   dictionary->Set(kTagVpnList, GetVPNList());
1007   dictionary->Set(kTagRememberedList, GetRememberedList());
1008
1009   dictionary->SetBoolean(
1010       kTagWifiAvailable,
1011       handler->IsTechnologyAvailable(NetworkTypePattern::WiFi()));
1012   dictionary->SetBoolean(
1013       kTagWifiEnabled,
1014       handler->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
1015
1016   const DeviceState* cellular =
1017       handler->GetDeviceStateByType(NetworkTypePattern::Mobile());
1018   dictionary->SetBoolean(
1019       kTagCellularAvailable,
1020       handler->IsTechnologyAvailable(NetworkTypePattern::Mobile()));
1021   dictionary->SetBoolean(
1022       kTagCellularEnabled,
1023       handler->IsTechnologyEnabled(NetworkTypePattern::Mobile()));
1024   dictionary->SetBoolean(kTagCellularSupportsScan,
1025                          cellular && cellular->support_network_scan());
1026   dictionary->SetBoolean(kTagCellularSimAbsent,
1027                          cellular && cellular->IsSimAbsent());
1028   dictionary->SetString(kTagCellularSimLockType,
1029                         cellular ? cellular->sim_lock_type() : "");
1030
1031   dictionary->SetBoolean(
1032       kTagWimaxAvailable,
1033       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
1034   dictionary->SetBoolean(
1035       kTagWimaxEnabled,
1036       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
1037 }
1038
1039 }  // namespace options
1040 }  // namespace chromeos