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/shell.h" 14 #include "ash/shell_delegate.h" 15 #include "ash/system/chromeos/network/network_connect.h" 16 #include "ash/system/chromeos/network/network_icon.h" 17 #include "base/base64.h" 18 #include "base/basictypes.h" 19 #include "base/bind.h" 20 #include "base/bind_helpers.h" 21 #include "base/command_line.h" 22 #include "base/i18n/time_formatting.h" 23 #include "base/json/json_writer.h" 24 #include "base/strings/string16.h" 25 #include "base/strings/string_number_conversions.h" 26 #include "base/strings/stringprintf.h" 27 #include "base/strings/utf_string_conversions.h" 28 #include "base/time/time.h" 29 #include "base/values.h" 30 #include "chrome/browser/browser_process.h" 31 #include "chrome/browser/chrome_notification_types.h" 32 #include "chrome/browser/chromeos/choose_mobile_network_dialog.h" 33 #include "chrome/browser/chromeos/enrollment_dialog_view.h" 34 #include "chrome/browser/chromeos/login/user.h" 35 #include "chrome/browser/chromeos/login/user_manager.h" 36 #include "chrome/browser/chromeos/mobile_config.h" 37 #include "chrome/browser/chromeos/net/onc_utils.h" 38 #include "chrome/browser/chromeos/options/network_config_view.h" 39 #include "chrome/browser/chromeos/options/network_property_ui_data.h" 40 #include "chrome/browser/chromeos/settings/cros_settings.h" 41 #include "chrome/browser/chromeos/sim_dialog_delegate.h" 42 #include "chrome/browser/chromeos/ui_proxy_config_service.h" 43 #include "chrome/browser/profiles/profile_manager.h" 44 #include "chrome/browser/ui/browser.h" 45 #include "chrome/browser/ui/browser_window.h" 46 #include "chrome/browser/ui/host_desktop.h" 47 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h" 48 #include "chrome/browser/ui/singleton_tabs.h" 49 #include "chrome/browser/ui/webui/options/chromeos/core_chromeos_options_handler.h" 50 #include "chromeos/chromeos_switches.h" 51 #include "chromeos/network/device_state.h" 52 #include "chromeos/network/favorite_state.h" 53 #include "chromeos/network/managed_network_configuration_handler.h" 54 #include "chromeos/network/network_configuration_handler.h" 55 #include "chromeos/network/network_connection_handler.h" 56 #include "chromeos/network/network_device_handler.h" 57 #include "chromeos/network/network_event_log.h" 58 #include "chromeos/network/network_ip_config.h" 59 #include "chromeos/network/network_profile.h" 60 #include "chromeos/network/network_profile_handler.h" 61 #include "chromeos/network/network_state.h" 62 #include "chromeos/network/network_state_handler.h" 63 #include "chromeos/network/network_ui_data.h" 64 #include "chromeos/network/network_util.h" 65 #include "chromeos/network/shill_property_util.h" 66 #include "components/onc/onc_constants.h" 67 #include "content/public/browser/notification_service.h" 68 #include "content/public/browser/web_contents.h" 69 #include "content/public/browser/web_contents_view.h" 70 #include "content/public/browser/web_ui.h" 71 #include "grit/ash_resources.h" 72 #include "grit/ash_strings.h" 73 #include "grit/chromium_strings.h" 74 #include "grit/generated_resources.h" 75 #include "grit/locale_settings.h" 76 #include "grit/theme_resources.h" 77 #include "third_party/cros_system_api/dbus/service_constants.h" 78 #include "ui/base/l10n/l10n_util.h" 79 #include "ui/base/layout.h" 80 #include "ui/base/resource/resource_bundle.h" 81 #include "ui/base/webui/web_ui_util.h" 82 #include "ui/gfx/display.h" 83 #include "ui/gfx/image/image_skia.h" 84 #include "ui/gfx/screen.h" 85 #include "ui/views/widget/widget.h" 86 87 namespace chromeos { 88 namespace options { 89 90 namespace { 91 92 // Keys for the network description dictionary passed to the web ui. Make sure 93 // to keep the strings in sync with what the JavaScript side uses. 94 const char kNetworkInfoKeyConnectable[] = "connectable"; 95 const char kNetworkInfoKeyConnected[] = "connected"; 96 const char kNetworkInfoKeyConnecting[] = "connecting"; 97 const char kNetworkInfoKeyIconURL[] = "iconURL"; 98 const char kNetworkInfoKeyNetworkName[] = "networkName"; 99 const char kNetworkInfoKeyNetworkType[] = "networkType"; 100 const char kNetworkInfoKeyServicePath[] = "servicePath"; 101 const char kNetworkInfoKeyPolicyManaged[] = "policyManaged"; 102 103 // These are keys for getting IP information from the web ui. 104 const char kIpConfigAddress[] = "address"; 105 const char kIpConfigPrefixLength[] = "prefixLength"; 106 const char kIpConfigNetmask[] = "netmask"; 107 const char kIpConfigGateway[] = "gateway"; 108 const char kIpConfigNameServers[] = "nameServers"; 109 const char kIpConfigAutoConfig[] = "ipAutoConfig"; 110 const char kIpConfigWebProxyAutoDiscoveryUrl[] = "webProxyAutoDiscoveryUrl"; 111 112 // These are types of name server selections from the web ui. 113 const char kNameServerTypeAutomatic[] = "automatic"; 114 const char kNameServerTypeGoogle[] = "google"; 115 const char kNameServerTypeUser[] = "user"; 116 117 // These are dictionary names used to send data to the web ui. 118 const char kDictionaryIpConfig[] = "ipconfig"; 119 const char kDictionaryStaticIp[] = "staticIP"; 120 const char kDictionarySavedIp[] = "savedIP"; 121 122 // Google public name servers (DNS). 123 const char kGoogleNameServers[] = "8.8.4.4,8.8.8.8"; 124 125 // Functions we call in JavaScript. 126 const char kRefreshNetworkDataFunction[] = 127 "options.network.NetworkList.refreshNetworkData"; 128 const char kSetDefaultNetworkIconsFunction[] = 129 "options.network.NetworkList.setDefaultNetworkIcons"; 130 const char kShowDetailedInfoFunction[] = 131 "options.internet.DetailsInternetPage.showDetailedInfo"; 132 const char kUpdateConnectionDataFunction[] = 133 "options.internet.DetailsInternetPage.updateConnectionData"; 134 const char kUpdateCarrierFunction[] = 135 "options.internet.DetailsInternetPage.updateCarrier"; 136 const char kUpdateLoggedInUserTypeFunction[] = 137 "options.network.NetworkList.updateLoggedInUserType"; 138 const char kUpdateSecurityTabFunction[] = 139 "options.internet.DetailsInternetPage.updateSecurityTab"; 140 141 // These are used to register message handlers with JavaScript. 142 const char kBuyDataPlanMessage[] = "buyDataPlan"; 143 const char kChangePinMessage[] = "changePin"; 144 const char kDisableCellularMessage[] = "disableCellular"; 145 const char kDisableWifiMessage[] = "disableWifi"; 146 const char kDisableWimaxMessage[] = "disableWimax"; 147 const char kEnableCellularMessage[] = "enableCellular"; 148 const char kEnableWifiMessage[] = "enableWifi"; 149 const char kEnableWimaxMessage[] = "enableWimax"; 150 const char kNetworkCommandMessage[] = "networkCommand"; 151 const char kRefreshNetworksMessage[] = "refreshNetworks"; 152 const char kSetApnMessage[] = "setApn"; 153 const char kSetAutoConnectMessage[] = "setAutoConnect"; 154 const char kSetCarrierMessage[] = "setCarrier"; 155 const char kSetIPConfigMessage[] = "setIPConfig"; 156 const char kSetPreferNetworkMessage[] = "setPreferNetwork"; 157 const char kSetServerHostname[] = "setServerHostname"; 158 const char kSetSimCardLockMessage[] = "setSimCardLock"; 159 const char kShowMorePlanInfoMessage[] = "showMorePlanInfo"; 160 161 // These are strings used to communicate with JavaScript. 162 const char kTagActivate[] = "activate"; 163 const char kTagActivationState[] = "activationState"; 164 const char kTagAddConnection[] = "add"; 165 const char kTagApn[] = "apn"; 166 const char kTagAutoConnect[] = "autoConnect"; 167 const char kTagBssid[] = "bssid"; 168 const char kTagCarrierSelectFlag[] = "showCarrierSelect"; 169 const char kTagCarrierUrl[] = "carrierUrl"; 170 const char kTagCellular[] = "cellular"; 171 const char kTagCellularAvailable[] = "cellularAvailable"; 172 const char kTagCellularEnabled[] = "cellularEnabled"; 173 const char kTagCellularSupportsScan[] = "cellularSupportsScan"; 174 const char kTagConfigure[] = "configure"; 175 const char kTagConnect[] = "connect"; 176 const char kTagConnected[] = "connected"; 177 const char kTagConnecting[] = "connecting"; 178 const char kTagConnectionState[] = "connectionState"; 179 const char kTagControlledBy[] = "controlledBy"; 180 const char kTagDeviceConnected[] = "deviceConnected"; 181 const char kTagDisableConnectButton[] = "disableConnectButton"; 182 const char kTagDisconnect[] = "disconnect"; 183 const char kTagEncryption[] = "encryption"; 184 const char kTagErrorState[] = "errorState"; 185 const char kTagEsn[] = "esn"; 186 const char kTagFirmwareRevision[] = "firmwareRevision"; 187 const char kTagForget[] = "forget"; 188 const char kTagFrequency[] = "frequency"; 189 const char kTagGsm[] = "gsm"; 190 const char kTagHardwareAddress[] = "hardwareAddress"; 191 const char kTagHardwareRevision[] = "hardwareRevision"; 192 const char kTagIdentity[] = "identity"; 193 const char kTagIccid[] = "iccid"; 194 const char kTagImei[] = "imei"; 195 const char kTagImsi[] = "imsi"; 196 const char kTagLanguage[] = "language"; 197 const char kTagLastGoodApn[] = "lastGoodApn"; 198 const char kTagLocalizedName[] = "localizedName"; 199 const char kTagManufacturer[] = "manufacturer"; 200 const char kTagMdn[] = "mdn"; 201 const char kTagMeid[] = "meid"; 202 const char kTagMin[] = "min"; 203 const char kTagModelId[] = "modelId"; 204 const char kTagName[] = "name"; 205 const char kTagNameServersGoogle[] = "nameServersGoogle"; 206 const char kTagNameServerType[] = "nameServerType"; 207 const char kTagNetworkId[] = "networkId"; 208 const char kTagNetworkName[] = "networkName"; 209 const char kTagNetworkTechnology[] = "networkTechnology"; 210 const char kTagOperatorCode[] = "operatorCode"; 211 const char kTagOperatorName[] = "operatorName"; 212 const char kTagOptions[] = "options"; 213 const char kTagPassword[] = "password"; 214 const char kTagPolicy[] = "policy"; 215 const char kTagPreferred[] = "preferred"; 216 const char kTagPrlVersion[] = "prlVersion"; 217 const char kTagProviderType[] = "providerType"; 218 const char kTagProviderApnList[] = "providerApnList"; 219 const char kTagRecommended[] = "recommended"; 220 const char kTagRecommendedValue[] = "recommendedValue"; 221 const char kTagRemembered[] = "remembered"; 222 const char kTagRememberedList[] = "rememberedList"; 223 const char kTagRestrictedPool[] = "restrictedPool"; 224 const char kTagRoamingState[] = "roamingState"; 225 const char kTagServerHostname[] = "serverHostname"; 226 const char kTagCarriers[] = "carriers"; 227 const char kTagCurrentCarrierIndex[] = "currentCarrierIndex"; 228 const char kTagServiceName[] = "serviceName"; 229 const char kTagServicePath[] = "servicePath"; 230 const char kTagShared[] = "shared"; 231 const char kTagShowActivateButton[] = "showActivateButton"; 232 const char kTagShowPreferred[] = "showPreferred"; 233 const char kTagShowProxy[] = "showProxy"; 234 const char kTagShowStaticIPConfig[] = "showStaticIPConfig"; 235 const char kTagShowViewAccountButton[] = "showViewAccountButton"; 236 const char kTagSimCardLockEnabled[] = "simCardLockEnabled"; 237 const char kTagSsid[] = "ssid"; 238 const char kTagStrength[] = "strength"; 239 const char kTagSupportUrl[] = "supportUrl"; 240 const char kTagTrue[] = "true"; 241 const char kTagType[] = "type"; 242 const char kTagUsername[] = "username"; 243 const char kTagValue[] = "value"; 244 const char kTagVpn[] = "vpn"; 245 const char kTagVpnList[] = "vpnList"; 246 const char kTagWifi[] = "wifi"; 247 const char kTagWifiAvailable[] = "wifiAvailable"; 248 const char kTagWifiEnabled[] = "wifiEnabled"; 249 const char kTagWimaxAvailable[] = "wimaxAvailable"; 250 const char kTagWimaxEnabled[] = "wimaxEnabled"; 251 const char kTagWiredList[] = "wiredList"; 252 const char kTagWirelessList[] = "wirelessList"; 253 254 const int kPreferredPriority = 1; 255 256 void ShillError(const std::string& function, 257 const std::string& error_name, 258 scoped_ptr<base::DictionaryValue> error_data) { 259 // UpdateConnectionData may send requests for stale services; ignore 260 // these errors. 261 if (function == "UpdateConnectionData" && 262 error_name == network_handler::kDBusFailedError) 263 return; 264 NET_LOG_ERROR("Shill Error from InternetOptionsHandler: " + error_name, 265 function); 266 } 267 268 const NetworkState* GetNetworkState(const std::string& service_path) { 269 return NetworkHandler::Get()->network_state_handler()-> 270 GetNetworkState(service_path); 271 } 272 273 void SetNetworkProperty(const std::string& service_path, 274 const std::string& property, 275 base::Value* value) { 276 NET_LOG_EVENT("SetNetworkProperty: " + property, service_path); 277 base::DictionaryValue properties; 278 properties.SetWithoutPathExpansion(property, value); 279 NetworkHandler::Get()->network_configuration_handler()->SetProperties( 280 service_path, properties, 281 base::Bind(&base::DoNothing), 282 base::Bind(&ShillError, "SetNetworkProperty")); 283 } 284 285 std::string ActivationStateString(const std::string& activation_state) { 286 int id; 287 if (activation_state == shill::kActivationStateActivated) 288 id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATED; 289 else if (activation_state == shill::kActivationStateActivating) 290 id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_ACTIVATING; 291 else if (activation_state == shill::kActivationStateNotActivated) 292 id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_NOT_ACTIVATED; 293 else if (activation_state == shill::kActivationStatePartiallyActivated) 294 id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_PARTIALLY_ACTIVATED; 295 else 296 id = IDS_CHROMEOS_NETWORK_ACTIVATION_STATE_UNKNOWN; 297 return l10n_util::GetStringUTF8(id); 298 } 299 300 std::string RoamingStateString(const std::string& roaming_state) { 301 int id; 302 if (roaming_state == shill::kRoamingStateHome) 303 id = IDS_CHROMEOS_NETWORK_ROAMING_STATE_HOME; 304 else if (roaming_state == shill::kRoamingStateRoaming) 305 id = IDS_CHROMEOS_NETWORK_ROAMING_STATE_ROAMING; 306 else 307 id = IDS_CHROMEOS_NETWORK_ROAMING_STATE_UNKNOWN; 308 return l10n_util::GetStringUTF8(id); 309 } 310 311 std::string ConnectionStateString(const std::string& state) { 312 int id; 313 if (state == shill::kUnknownString) 314 id = IDS_CHROMEOS_NETWORK_STATE_UNKNOWN; 315 else if (state == shill::kStateIdle) 316 id = IDS_CHROMEOS_NETWORK_STATE_IDLE; 317 else if (state == shill::kStateCarrier) 318 id = IDS_CHROMEOS_NETWORK_STATE_CARRIER; 319 else if (state == shill::kStateAssociation) 320 id = IDS_CHROMEOS_NETWORK_STATE_ASSOCIATION; 321 else if (state == shill::kStateConfiguration) 322 id = IDS_CHROMEOS_NETWORK_STATE_CONFIGURATION; 323 else if (state == shill::kStateReady) 324 id = IDS_CHROMEOS_NETWORK_STATE_READY; 325 else if (state == shill::kStateDisconnect) 326 id = IDS_CHROMEOS_NETWORK_STATE_DISCONNECT; 327 else if (state == shill::kStateFailure) 328 id = IDS_CHROMEOS_NETWORK_STATE_FAILURE; 329 else if (state == shill::kStateActivationFailure) 330 id = IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE; 331 else if (state == shill::kStatePortal) 332 id = IDS_CHROMEOS_NETWORK_STATE_PORTAL; 333 else if (state == shill::kStateOnline) 334 id = IDS_CHROMEOS_NETWORK_STATE_ONLINE; 335 else 336 id = IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED; 337 return l10n_util::GetStringUTF8(id); 338 } 339 340 std::string LoggedInUserTypeToString( 341 LoginState::LoggedInUserType type) { 342 switch (type) { 343 case LoginState::LOGGED_IN_USER_NONE: 344 return "none"; 345 case LoginState::LOGGED_IN_USER_REGULAR: 346 return "regular"; 347 case LoginState::LOGGED_IN_USER_OWNER: 348 return "owner"; 349 case LoginState::LOGGED_IN_USER_GUEST: 350 return "guest"; 351 case LoginState::LOGGED_IN_USER_RETAIL_MODE: 352 return "retail-mode"; 353 case LoginState::LOGGED_IN_USER_PUBLIC_ACCOUNT: 354 return "public-account"; 355 case LoginState::LOGGED_IN_USER_LOCALLY_MANAGED: 356 return "locally-managed"; 357 case LoginState::LOGGED_IN_USER_KIOSK_APP: 358 return "kiosk-app"; 359 default: 360 return ""; 361 } 362 } 363 364 std::string EncryptionString(const std::string& security, 365 const std::string& eap_method) { 366 if (security == shill::kSecurityNone) 367 return ""; 368 if (security == shill::kSecurityWpa) 369 return "WPA"; 370 if (security == shill::kSecurityWep) 371 return "WEP"; 372 if (security == shill::kSecurityRsn) 373 return "RSN"; 374 if (security == shill::kSecurityPsk) 375 return "PSK"; 376 if (security == shill::kSecurity8021x) { 377 std::string result = "8021X"; 378 if (eap_method == shill::kEapMethodPEAP) 379 result += "PEAP"; 380 else if (eap_method == shill::kEapMethodTLS) 381 result += "TLS"; 382 else if (eap_method == shill::kEapMethodTTLS) 383 result += "TTLS"; 384 else if (eap_method == shill::kEapMethodLEAP) 385 result += "LEAP"; 386 return result; 387 } 388 return "Unknown"; 389 } 390 391 std::string ProviderTypeString( 392 const std::string& provider_type, 393 const base::DictionaryValue& provider_properties) { 394 int id; 395 if (provider_type == shill::kProviderL2tpIpsec) { 396 std::string client_cert_id; 397 provider_properties.GetStringWithoutPathExpansion( 398 shill::kL2tpIpsecClientCertIdProperty, &client_cert_id); 399 if (client_cert_id.empty()) 400 id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_PSK; 401 else 402 id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_USER_CERT; 403 } else if (provider_type == shill::kProviderOpenVpn) { 404 id = IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_OPEN_VPN; 405 } else { 406 id = IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN; 407 } 408 return l10n_util::GetStringUTF8(id); 409 } 410 411 bool HasPolicyForFavorite(const FavoriteState* favorite, 412 const PrefService* profile_prefs) { 413 return onc::HasPolicyForFavoriteNetwork( 414 profile_prefs, g_browser_process->local_state(), *favorite); 415 } 416 417 bool HasPolicyForNetwork(const NetworkState* network, 418 const PrefService* profile_prefs) { 419 const FavoriteState* favorite = 420 NetworkHandler::Get()->network_state_handler()->GetFavoriteState( 421 network->path()); 422 if (!favorite) 423 return false; 424 return HasPolicyForFavorite(favorite, profile_prefs); 425 } 426 427 void SetCommonNetworkInfo(const ManagedState* state, 428 const gfx::ImageSkia& icon, 429 ui::ScaleFactor icon_scale_factor, 430 base::DictionaryValue* network_info) { 431 gfx::ImageSkiaRep image_rep = 432 icon.GetRepresentation(ui::GetImageScale(icon_scale_factor)); 433 std::string icon_url = 434 icon.isNull() ? "" : webui::GetBitmapDataUrl(image_rep.sk_bitmap()); 435 network_info->SetString(kNetworkInfoKeyIconURL, icon_url); 436 437 std::string name = state->name(); 438 if (state->Matches(NetworkTypePattern::Ethernet())) 439 name = l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET); 440 network_info->SetString(kNetworkInfoKeyNetworkName, name); 441 network_info->SetString(kNetworkInfoKeyNetworkType, state->type()); 442 network_info->SetString(kNetworkInfoKeyServicePath, state->path()); 443 } 444 445 // Builds a dictionary with network information and an icon used for the 446 // NetworkList on the settings page. Ownership of the returned pointer is 447 // transferred to the caller. 448 base::DictionaryValue* BuildNetworkDictionary( 449 const NetworkState* network, 450 ui::ScaleFactor icon_scale_factor, 451 const PrefService* profile_prefs) { 452 scoped_ptr<base::DictionaryValue> network_info(new base::DictionaryValue()); 453 network_info->SetBoolean(kNetworkInfoKeyConnectable, network->connectable()); 454 network_info->SetBoolean(kNetworkInfoKeyConnected, 455 network->IsConnectedState()); 456 network_info->SetBoolean(kNetworkInfoKeyConnecting, 457 network->IsConnectingState()); 458 network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, 459 HasPolicyForNetwork(network, profile_prefs)); 460 461 gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork( 462 network, ash::network_icon::ICON_TYPE_LIST); 463 SetCommonNetworkInfo(network, icon, icon_scale_factor, network_info.get()); 464 return network_info.release(); 465 } 466 467 base::DictionaryValue* BuildFavoriteDictionary( 468 const FavoriteState* favorite, 469 ui::ScaleFactor icon_scale_factor, 470 const PrefService* profile_prefs) { 471 scoped_ptr<base::DictionaryValue> network_info(new base::DictionaryValue()); 472 network_info->SetBoolean(kNetworkInfoKeyConnectable, false); 473 network_info->SetBoolean(kNetworkInfoKeyConnected, false); 474 network_info->SetBoolean(kNetworkInfoKeyConnecting, false); 475 network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, 476 HasPolicyForFavorite(favorite, profile_prefs)); 477 478 gfx::ImageSkia icon = ash::network_icon::GetImageForDisconnectedNetwork( 479 ash::network_icon::ICON_TYPE_LIST, favorite->type()); 480 SetCommonNetworkInfo(favorite, icon, icon_scale_factor, network_info.get()); 481 return network_info.release(); 482 } 483 484 // Pulls IP information out of a shill service properties dictionary. If 485 // |static_ip| is true, then it fetches "StaticIP.*" properties. If not, then it 486 // fetches "SavedIP.*" properties. Caller must take ownership of returned 487 // dictionary. If non-NULL, |ip_parameters_set| returns a count of the number 488 // of IP routing parameters that get set. 489 base::DictionaryValue* BuildIPInfoDictionary( 490 const base::DictionaryValue& shill_properties, 491 bool static_ip, 492 int* routing_parameters_set) { 493 std::string address_key; 494 std::string prefix_len_key; 495 std::string gateway_key; 496 std::string name_servers_key; 497 if (static_ip) { 498 address_key = shill::kStaticIPAddressProperty; 499 prefix_len_key = shill::kStaticIPPrefixlenProperty; 500 gateway_key = shill::kStaticIPGatewayProperty; 501 name_servers_key = shill::kStaticIPNameServersProperty; 502 } else { 503 address_key = shill::kSavedIPAddressProperty; 504 prefix_len_key = shill::kSavedIPPrefixlenProperty; 505 gateway_key = shill::kSavedIPGatewayProperty; 506 name_servers_key = shill::kSavedIPNameServersProperty; 507 } 508 509 scoped_ptr<base::DictionaryValue> ip_info_dict(new base::DictionaryValue); 510 std::string address; 511 int routing_parameters = 0; 512 if (shill_properties.GetStringWithoutPathExpansion(address_key, &address)) { 513 ip_info_dict->SetString(kIpConfigAddress, address); 514 VLOG(2) << "Found " << address_key << ": " << address; 515 routing_parameters++; 516 } 517 int prefix_len = -1; 518 if (shill_properties.GetIntegerWithoutPathExpansion( 519 prefix_len_key, &prefix_len)) { 520 ip_info_dict->SetInteger(kIpConfigPrefixLength, prefix_len); 521 std::string netmask = network_util::PrefixLengthToNetmask(prefix_len); 522 ip_info_dict->SetString(kIpConfigNetmask, netmask); 523 VLOG(2) << "Found " << prefix_len_key << ": " 524 << prefix_len << " (" << netmask << ")"; 525 routing_parameters++; 526 } 527 std::string gateway; 528 if (shill_properties.GetStringWithoutPathExpansion(gateway_key, &gateway)) { 529 ip_info_dict->SetString(kIpConfigGateway, gateway); 530 VLOG(2) << "Found " << gateway_key << ": " << gateway; 531 routing_parameters++; 532 } 533 if (routing_parameters_set) 534 *routing_parameters_set = routing_parameters; 535 536 std::string name_servers; 537 if (shill_properties.GetStringWithoutPathExpansion( 538 name_servers_key, &name_servers)) { 539 ip_info_dict->SetString(kIpConfigNameServers, name_servers); 540 VLOG(2) << "Found " << name_servers_key << ": " << name_servers; 541 } 542 543 return ip_info_dict.release(); 544 } 545 546 bool CanForgetNetworkType(const std::string& type) { 547 return type == shill::kTypeWifi || 548 type == shill::kTypeWimax || 549 type == shill::kTypeVPN; 550 } 551 552 bool CanAddNetworkType(const std::string& type) { 553 return type == shill::kTypeWifi || 554 type == shill::kTypeVPN || 555 type == shill::kTypeCellular; 556 } 557 558 // Decorate dictionary |value_dict| with policy information from |ui_data|. 559 void DecorateValueDictionary(const NetworkPropertyUIData& ui_data, 560 const base::Value& value, 561 base::DictionaryValue* value_dict) { 562 const base::Value* recommended_value = ui_data.default_value(); 563 if (ui_data.IsManaged()) 564 value_dict->SetString(kTagControlledBy, kTagPolicy); 565 else if (recommended_value && recommended_value->Equals(&value)) 566 value_dict->SetString(kTagControlledBy, kTagRecommended); 567 568 if (recommended_value) 569 value_dict->Set(kTagRecommendedValue, recommended_value->DeepCopy()); 570 } 571 572 // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does and 573 // store it under |key| in |settings|. Takes ownership of |value|. 574 void SetValueDictionary(base::DictionaryValue* settings, 575 const char* key, 576 base::Value* value, 577 const NetworkPropertyUIData& ui_data) { 578 base::DictionaryValue* dict = new base::DictionaryValue(); 579 // DictionaryValue::Set() takes ownership of |value|. 580 dict->Set(kTagValue, value); 581 settings->Set(key, dict); 582 DecorateValueDictionary(ui_data, *value, dict); 583 } 584 585 // Creates a decorated dictionary like SetValueDictionary does, but extended for 586 // the Autoconnect property, which respects additionally global network policy. 587 void SetAutoconnectValueDictionary(bool network_is_private, 588 ::onc::ONCSource onc_source, 589 bool current_autoconnect, 590 const NetworkPropertyUIData& ui_data, 591 base::DictionaryValue* settings) { 592 base::DictionaryValue* dict = new base::DictionaryValue(); 593 base::Value* value = new base::FundamentalValue(current_autoconnect); 594 // DictionaryValue::Set() takes ownership of |value|. 595 dict->Set(kTagValue, value); 596 settings->Set(kTagAutoConnect, dict); 597 if (onc_source != ::onc::ONC_SOURCE_USER_POLICY && 598 onc_source != ::onc::ONC_SOURCE_DEVICE_POLICY) { 599 // Autoconnect can be controlled by the GlobalNetworkConfiguration of the 600 // ONC policy. 601 bool only_policy_autoconnect = 602 onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect(network_is_private); 603 if (only_policy_autoconnect) { 604 dict->SetString(kTagControlledBy, kTagPolicy); 605 return; 606 } 607 } 608 DecorateValueDictionary(ui_data, *value, dict); 609 } 610 611 std::string CopyStringFromDictionary(const base::DictionaryValue& source, 612 const std::string& src_key, 613 const std::string& dest_key, 614 base::DictionaryValue* dest) { 615 std::string string_value; 616 if (source.GetStringWithoutPathExpansion(src_key, &string_value)) 617 dest->SetStringWithoutPathExpansion(dest_key, string_value); 618 return string_value; 619 } 620 621 void CopyIntegerFromDictionary(const base::DictionaryValue& source, 622 const std::string& src_key, 623 const std::string& dest_key, 624 bool as_string, 625 base::DictionaryValue* dest) { 626 int int_value; 627 if (!source.GetIntegerWithoutPathExpansion(src_key, &int_value)) 628 return; 629 if (as_string) { 630 std::string str = base::StringPrintf("%d", int_value); 631 dest->SetStringWithoutPathExpansion(dest_key, str); 632 } else { 633 dest->SetIntegerWithoutPathExpansion(dest_key, int_value); 634 } 635 } 636 637 // Fills |dictionary| with the configuration details of |vpn|. |onc| is required 638 // for augmenting the policy-managed information. 639 void PopulateVPNDetails(const NetworkState* vpn, 640 const base::DictionaryValue& shill_properties, 641 base::DictionaryValue* dictionary) { 642 // Name and Remembered are set in PopulateConnectionDetails(). 643 // Provider properties are stored in the "Provider" dictionary. 644 const base::DictionaryValue* provider_properties = NULL; 645 if (!shill_properties.GetDictionaryWithoutPathExpansion( 646 shill::kProviderProperty, &provider_properties)) { 647 LOG(ERROR) << "No provider properties for VPN: " << vpn->path(); 648 return; 649 } 650 std::string provider_type; 651 provider_properties->GetStringWithoutPathExpansion( 652 shill::kTypeProperty, &provider_type); 653 dictionary->SetString(kTagProviderType, 654 ProviderTypeString(provider_type, 655 *provider_properties)); 656 657 std::string username; 658 if (provider_type == shill::kProviderOpenVpn) { 659 provider_properties->GetStringWithoutPathExpansion( 660 shill::kOpenVPNUserProperty, &username); 661 } else { 662 provider_properties->GetStringWithoutPathExpansion( 663 shill::kL2tpIpsecUserProperty, &username); 664 } 665 dictionary->SetString(kTagUsername, username); 666 667 ::onc::ONCSource onc_source = ::onc::ONC_SOURCE_NONE; 668 const base::DictionaryValue* onc = 669 onc::FindPolicyForActiveUser(vpn->guid(), &onc_source); 670 671 NetworkPropertyUIData hostname_ui_data; 672 hostname_ui_data.ParseOncProperty( 673 onc_source, 674 onc, 675 base::StringPrintf("%s.%s", ::onc::network_config::kVPN, 676 ::onc::vpn::kHost)); 677 std::string provider_host; 678 provider_properties->GetStringWithoutPathExpansion( 679 shill::kHostProperty, &provider_host); 680 SetValueDictionary(dictionary, kTagServerHostname, 681 new base::StringValue(provider_host), 682 hostname_ui_data); 683 684 // Disable 'Connect' for VPN unless connected to a non-VPN network. 685 const NetworkState* connected_network = 686 NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType( 687 NetworkTypePattern::NonVirtual()); 688 dictionary->SetBoolean(kTagDisableConnectButton, !connected_network); 689 } 690 691 // Given a list of supported carrier's by the device, return the index of 692 // the carrier the device is currently using. 693 int FindCurrentCarrierIndex(const base::ListValue* carriers, 694 const DeviceState* device) { 695 DCHECK(carriers); 696 DCHECK(device); 697 bool gsm = (device->technology_family() == shill::kTechnologyFamilyGsm); 698 int index = 0; 699 for (base::ListValue::const_iterator it = carriers->begin(); 700 it != carriers->end(); ++it, ++index) { 701 std::string value; 702 if (!(*it)->GetAsString(&value)) 703 continue; 704 // For GSM devices the device name will be empty, so simply select 705 // the Generic UMTS carrier option if present. 706 if (gsm && (value == shill::kCarrierGenericUMTS)) 707 return index; 708 // For other carriers, the service name will match the carrier name. 709 if (value == device->carrier()) 710 return index; 711 } 712 return -1; 713 } 714 715 void PopulateWifiDetails(const NetworkState* wifi, 716 const base::DictionaryValue& shill_properties, 717 base::DictionaryValue* dictionary); 718 // TODO(stevenjb): Move implementation here. 719 720 void PopulateWimaxDetails(const NetworkState* wimax, 721 const base::DictionaryValue& shill_properties, 722 base::DictionaryValue* dictionary); 723 // TODO(stevenjb): Move implementation here. 724 725 void CreateDictionaryFromCellularApn(const base::DictionaryValue* apn, 726 base::DictionaryValue* dictionary); 727 // TODO(stevenjb): Move implementation here. 728 729 void PopulateCellularDetails(const NetworkState* cellular, 730 const base::DictionaryValue& shill_properties, 731 base::DictionaryValue* dictionary); 732 // TODO(stevenjb): Move implementation here. 733 734 void PopulateConnectionDetails(const NetworkState* network, 735 const base::DictionaryValue& shill_properties, 736 base::DictionaryValue* dictionary); 737 // TODO(stevenjb): Move implementation here. 738 739 // Helper methods for SetIPConfigProperties 740 bool AppendPropertyKeyIfPresent(const std::string& key, 741 const base::DictionaryValue& old_properties, 742 std::vector<std::string>* property_keys) { 743 if (old_properties.HasKey(key)) { 744 property_keys->push_back(key); 745 return true; 746 } 747 return false; 748 } 749 750 bool AddStringPropertyIfChanged(const std::string& key, 751 const std::string& new_value, 752 const base::DictionaryValue& old_properties, 753 base::DictionaryValue* new_properties) { 754 std::string old_value; 755 if (!old_properties.GetStringWithoutPathExpansion(key, &old_value) || 756 new_value != old_value) { 757 new_properties->SetStringWithoutPathExpansion(key, new_value); 758 return true; 759 } 760 return false; 761 } 762 763 bool AddIntegerPropertyIfChanged(const std::string& key, 764 int new_value, 765 const base::DictionaryValue& old_properties, 766 base::DictionaryValue* new_properties) { 767 int old_value; 768 if (!old_properties.GetIntegerWithoutPathExpansion(key, &old_value) || 769 new_value != old_value) { 770 new_properties->SetIntegerWithoutPathExpansion(key, new_value); 771 return true; 772 } 773 return false; 774 } 775 776 void RequestReconnect(const std::string& service_path, 777 gfx::NativeWindow owning_window) { 778 NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork( 779 service_path, 780 base::Bind(&ash::network_connect::ConnectToNetwork, 781 service_path, owning_window), 782 base::Bind(&ShillError, "RequestReconnect")); 783 } 784 785 } // namespace 786 787 InternetOptionsHandler::InternetOptionsHandler() 788 : weak_factory_(this) { 789 registrar_.Add(this, chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED, 790 content::NotificationService::AllSources()); 791 registrar_.Add(this, chrome::NOTIFICATION_ENTER_PIN_ENDED, 792 content::NotificationService::AllSources()); 793 NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE); 794 LoginState::Get()->AddObserver(this); 795 } 796 797 InternetOptionsHandler::~InternetOptionsHandler() { 798 if (NetworkHandler::IsInitialized()) { 799 NetworkHandler::Get()->network_state_handler()->RemoveObserver( 800 this, FROM_HERE); 801 } 802 if (LoginState::Get()->IsInitialized()) 803 LoginState::Get()->RemoveObserver(this); 804 } 805 806 void InternetOptionsHandler::GetLocalizedValues( 807 base::DictionaryValue* localized_strings) { 808 DCHECK(localized_strings); 809 810 static OptionsStringResource resources[] = { 811 812 // Main settings page. 813 814 { "ethernetTitle", IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET }, 815 { "wifiTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_WIFI_NETWORK }, 816 { "wimaxTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_WIMAX_NETWORK }, 817 { "cellularTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_CELLULAR_NETWORK }, 818 { "vpnTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_PRIVATE_NETWORK }, 819 { "networkNotConnected", IDS_OPTIONS_SETTINGS_NETWORK_NOT_CONNECTED }, 820 { "networkConnected", IDS_CHROMEOS_NETWORK_STATE_READY }, 821 { "joinOtherNetwork", IDS_OPTIONS_SETTINGS_NETWORK_OTHER }, 822 { "networkOffline", IDS_OPTIONS_SETTINGS_NETWORK_OFFLINE }, 823 { "networkDisabled", IDS_OPTIONS_SETTINGS_NETWORK_DISABLED }, 824 { "networkOnline", IDS_OPTIONS_SETTINGS_NETWORK_ONLINE }, 825 { "networkOptions", IDS_OPTIONS_SETTINGS_NETWORK_OPTIONS }, 826 { "turnOffWifi", IDS_OPTIONS_SETTINGS_NETWORK_DISABLE_WIFI }, 827 { "turnOffWimax", IDS_OPTIONS_SETTINGS_NETWORK_DISABLE_WIMAX }, 828 { "turnOffCellular", IDS_OPTIONS_SETTINGS_NETWORK_DISABLE_CELLULAR }, 829 { "disconnectNetwork", IDS_OPTIONS_SETTINGS_DISCONNECT }, 830 { "preferredNetworks", IDS_OPTIONS_SETTINGS_PREFERRED_NETWORKS_LABEL }, 831 { "preferredNetworksPage", IDS_OPTIONS_SETTINGS_PREFERRED_NETWORKS_TITLE }, 832 { "useSharedProxies", IDS_OPTIONS_SETTINGS_USE_SHARED_PROXIES }, 833 { "addConnectionTitle", 834 IDS_OPTIONS_SETTINGS_SECTION_TITLE_ADD_CONNECTION }, 835 { "addConnectionWifi", IDS_OPTIONS_SETTINGS_ADD_CONNECTION_WIFI }, 836 { "addConnectionVPN", IDS_STATUSBAR_NETWORK_ADD_VPN }, 837 { "otherCellularNetworks", IDS_OPTIONS_SETTINGS_OTHER_CELLULAR_NETWORKS }, 838 { "enableDataRoaming", IDS_OPTIONS_SETTINGS_ENABLE_DATA_ROAMING }, 839 { "disableDataRoaming", IDS_OPTIONS_SETTINGS_DISABLE_DATA_ROAMING }, 840 { "dataRoamingDisableToggleTooltip", 841 IDS_OPTIONS_SETTINGS_TOGGLE_DATA_ROAMING_RESTRICTION }, 842 { "activateNetwork", IDS_STATUSBAR_NETWORK_DEVICE_ACTIVATE }, 843 844 // Internet details dialog. 845 846 { "changeProxyButton", 847 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CHANGE_PROXY_BUTTON }, 848 { "managedNetwork", IDS_OPTIONS_SETTINGS_MANAGED_NETWORK }, 849 { "wifiNetworkTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_CONNECTION }, 850 { "vpnTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_VPN }, 851 { "cellularConnTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_CONNECTION }, 852 { "cellularDeviceTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_DEVICE }, 853 { "networkTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_NETWORK }, 854 { "securityTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_SECURITY }, 855 { "proxyTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_PROXY }, 856 { "connectionState", IDS_OPTIONS_SETTINGS_INTERNET_CONNECTION_STATE }, 857 { "inetAddress", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_ADDRESS }, 858 { "inetNetmask", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SUBNETMASK }, 859 { "inetGateway", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_GATEWAY }, 860 { "inetNameServers", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_DNSSERVER }, 861 { "ipAutomaticConfiguration", 862 IDS_OPTIONS_SETTINGS_INTERNET_IP_AUTOMATIC_CONFIGURATION }, 863 { "automaticNameServers", 864 IDS_OPTIONS_SETTINGS_INTERNET_AUTOMATIC_NAME_SERVERS }, 865 { "userNameServer1", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_1 }, 866 { "userNameServer2", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_2 }, 867 { "userNameServer3", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_3 }, 868 { "userNameServer4", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_4 }, 869 { "googleNameServers", IDS_OPTIONS_SETTINGS_INTERNET_GOOGLE_NAME_SERVERS }, 870 { "userNameServers", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVERS }, 871 { "hardwareAddress", 872 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_HARDWARE_ADDRESS }, 873 { "detailsInternetDismiss", IDS_CLOSE }, 874 { "activateButton", IDS_OPTIONS_SETTINGS_ACTIVATE }, 875 { "buyplanButton", IDS_OPTIONS_SETTINGS_BUY_PLAN }, 876 { "connectButton", IDS_OPTIONS_SETTINGS_CONNECT }, 877 { "configureButton", IDS_OPTIONS_SETTINGS_CONFIGURE }, 878 { "disconnectButton", IDS_OPTIONS_SETTINGS_DISCONNECT }, 879 { "viewAccountButton", IDS_STATUSBAR_NETWORK_VIEW_ACCOUNT }, 880 { "wimaxConnTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_WIMAX }, 881 882 // Wifi Tab. 883 884 { "inetSsid", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_ID }, 885 { "inetBssid", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_BSSID }, 886 { "inetEncryption", 887 IDS_OPTIONS_SETTIGNS_INTERNET_OPTIONS_NETWORK_ENCRYPTION }, 888 { "inetFrequency", 889 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_FREQUENCY }, 890 { "inetFrequencyFormat", 891 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_FREQUENCY_MHZ }, 892 { "inetSignalStrength", 893 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_STRENGTH }, 894 { "inetSignalStrengthFormat", 895 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_STRENGTH_PERCENTAGE }, 896 { "inetPassProtected", 897 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NET_PROTECTED }, 898 { "inetNetworkShared", 899 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_SHARED }, 900 { "inetPreferredNetwork", 901 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PREFER_NETWORK }, 902 { "inetAutoConnectNetwork", 903 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_AUTO_CONNECT }, 904 { "inetLogin", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_LOGIN }, 905 { "inetShowPass", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SHOWPASSWORD }, 906 { "inetPassPrompt", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PASSWORD }, 907 { "inetSsidPrompt", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SSID }, 908 { "inetStatus", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_STATUS_TITLE }, 909 { "inetConnect", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CONNECT_TITLE }, 910 911 // VPN Tab. 912 913 { "inetServiceName", 914 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_SERVICE_NAME }, 915 { "inetServerHostname", 916 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_SERVER_HOSTNAME }, 917 { "inetProviderType", 918 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_PROVIDER_TYPE }, 919 { "inetUsername", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_USERNAME }, 920 921 // Cellular Tab. 922 923 { "serviceName", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_SERVICE_NAME }, 924 { "networkTechnology", 925 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_NETWORK_TECHNOLOGY }, 926 { "operatorName", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_OPERATOR }, 927 { "operatorCode", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_OPERATOR_CODE }, 928 { "activationState", 929 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ACTIVATION_STATE }, 930 { "roamingState", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ROAMING_STATE }, 931 { "restrictedPool", 932 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_RESTRICTED_POOL }, 933 { "errorState", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ERROR_STATE }, 934 { "manufacturer", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_MANUFACTURER }, 935 { "modelId", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_MODEL_ID }, 936 { "firmwareRevision", 937 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_FIRMWARE_REVISION }, 938 { "hardwareRevision", 939 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_HARDWARE_REVISION }, 940 { "prlVersion", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_PRL_VERSION }, 941 { "cellularApnLabel", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN }, 942 { "cellularApnOther", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_OTHER }, 943 { "cellularApnUsername", 944 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_USERNAME }, 945 { "cellularApnPassword", 946 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_PASSWORD }, 947 { "cellularApnUseDefault", 948 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_CLEAR }, 949 { "cellularApnSet", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_SET }, 950 { "cellularApnCancel", IDS_CANCEL }, 951 952 // Security Tab. 953 954 { "accessSecurityTabLink", 955 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ACCESS_SECURITY_TAB }, 956 { "lockSimCard", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_LOCK_SIM_CARD }, 957 { "changePinButton", 958 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_CHANGE_PIN_BUTTON }, 959 960 // Proxy Tab. 961 { "webProxyAutoDiscoveryUrl", IDS_PROXY_WEB_PROXY_AUTO_DISCOVERY }, 962 }; 963 964 RegisterStrings(localized_strings, resources, arraysize(resources)); 965 966 std::string owner; 967 chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner); 968 localized_strings->SetString("ownerUserId", UTF8ToUTF16(owner)); 969 970 base::DictionaryValue* network_dictionary = new base::DictionaryValue; 971 FillNetworkInfo(network_dictionary); 972 localized_strings->Set("networkData", network_dictionary); 973 } 974 975 void InternetOptionsHandler::InitializePage() { 976 base::DictionaryValue dictionary; 977 dictionary.SetString(kTagCellular, 978 GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK)); 979 dictionary.SetString(kTagWifi, 980 GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK)); 981 dictionary.SetString(kTagVpn, 982 GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_VPN)); 983 web_ui()->CallJavascriptFunction(kSetDefaultNetworkIconsFunction, 984 dictionary); 985 NetworkHandler::Get()->network_state_handler()->RequestScan(); 986 RefreshNetworkData(); 987 UpdateLoggedInUserType(); 988 } 989 990 void InternetOptionsHandler::RegisterMessages() { 991 // Setup handlers specific to this panel. 992 web_ui()->RegisterMessageCallback(kNetworkCommandMessage, 993 base::Bind(&InternetOptionsHandler::NetworkCommandCallback, 994 base::Unretained(this))); 995 web_ui()->RegisterMessageCallback(kRefreshNetworksMessage, 996 base::Bind(&InternetOptionsHandler::RefreshNetworksCallback, 997 base::Unretained(this))); 998 web_ui()->RegisterMessageCallback(kSetPreferNetworkMessage, 999 base::Bind(&InternetOptionsHandler::SetPreferNetworkCallback, 1000 base::Unretained(this))); 1001 web_ui()->RegisterMessageCallback(kSetAutoConnectMessage, 1002 base::Bind(&InternetOptionsHandler::SetAutoConnectCallback, 1003 base::Unretained(this))); 1004 web_ui()->RegisterMessageCallback(kSetIPConfigMessage, 1005 base::Bind(&InternetOptionsHandler::SetIPConfigCallback, 1006 base::Unretained(this))); 1007 web_ui()->RegisterMessageCallback(kEnableWifiMessage, 1008 base::Bind(&InternetOptionsHandler::EnableWifiCallback, 1009 base::Unretained(this))); 1010 web_ui()->RegisterMessageCallback(kDisableWifiMessage, 1011 base::Bind(&InternetOptionsHandler::DisableWifiCallback, 1012 base::Unretained(this))); 1013 web_ui()->RegisterMessageCallback(kEnableCellularMessage, 1014 base::Bind(&InternetOptionsHandler::EnableCellularCallback, 1015 base::Unretained(this))); 1016 web_ui()->RegisterMessageCallback(kDisableCellularMessage, 1017 base::Bind(&InternetOptionsHandler::DisableCellularCallback, 1018 base::Unretained(this))); 1019 web_ui()->RegisterMessageCallback(kEnableWimaxMessage, 1020 base::Bind(&InternetOptionsHandler::EnableWimaxCallback, 1021 base::Unretained(this))); 1022 web_ui()->RegisterMessageCallback(kDisableWimaxMessage, 1023 base::Bind(&InternetOptionsHandler::DisableWimaxCallback, 1024 base::Unretained(this))); 1025 web_ui()->RegisterMessageCallback(kBuyDataPlanMessage, 1026 base::Bind(&InternetOptionsHandler::BuyDataPlanCallback, 1027 base::Unretained(this))); 1028 web_ui()->RegisterMessageCallback(kShowMorePlanInfoMessage, 1029 base::Bind(&InternetOptionsHandler::ShowMorePlanInfoCallback, 1030 base::Unretained(this))); 1031 web_ui()->RegisterMessageCallback(kSetApnMessage, 1032 base::Bind(&InternetOptionsHandler::SetApnCallback, 1033 base::Unretained(this))); 1034 web_ui()->RegisterMessageCallback(kSetCarrierMessage, 1035 base::Bind(&InternetOptionsHandler::SetCarrierCallback, 1036 base::Unretained(this))); 1037 web_ui()->RegisterMessageCallback(kSetSimCardLockMessage, 1038 base::Bind(&InternetOptionsHandler::SetSimCardLockCallback, 1039 base::Unretained(this))); 1040 web_ui()->RegisterMessageCallback(kChangePinMessage, 1041 base::Bind(&InternetOptionsHandler::ChangePinCallback, 1042 base::Unretained(this))); 1043 web_ui()->RegisterMessageCallback(kSetServerHostname, 1044 base::Bind(&InternetOptionsHandler::SetServerHostnameCallback, 1045 base::Unretained(this))); 1046 } 1047 1048 void InternetOptionsHandler::EnableWifiCallback(const base::ListValue* args) { 1049 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( 1050 NetworkTypePattern::WiFi(), true, 1051 base::Bind(&ShillError, "EnableWifiCallback")); 1052 } 1053 1054 void InternetOptionsHandler::DisableWifiCallback(const base::ListValue* args) { 1055 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( 1056 NetworkTypePattern::WiFi(), false, 1057 base::Bind(&ShillError, "DisableWifiCallback")); 1058 } 1059 1060 void InternetOptionsHandler::EnableCellularCallback( 1061 const base::ListValue* args) { 1062 NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler(); 1063 const DeviceState* device = 1064 handler->GetDeviceStateByType(NetworkTypePattern::Cellular()); 1065 if (!device) { 1066 LOG(ERROR) << "Mobile device not found."; 1067 return; 1068 } 1069 if (!device->sim_lock_type().empty()) { 1070 SimDialogDelegate::ShowDialog(GetNativeWindow(), 1071 SimDialogDelegate::SIM_DIALOG_UNLOCK); 1072 return; 1073 } 1074 if (!handler->IsTechnologyEnabled(NetworkTypePattern::Cellular())) { 1075 handler->SetTechnologyEnabled( 1076 NetworkTypePattern::Cellular(), true, 1077 base::Bind(&ShillError, "EnableCellularCallback")); 1078 return; 1079 } 1080 if (device->IsSimAbsent()) { 1081 MobileConfig* config = MobileConfig::GetInstance(); 1082 if (config->IsReady()) { 1083 const MobileConfig::LocaleConfig* locale_config = 1084 config->GetLocaleConfig(); 1085 if (locale_config) { 1086 std::string setup_url = locale_config->setup_url(); 1087 if (!setup_url.empty()) { 1088 chrome::ScopedTabbedBrowserDisplayer displayer( 1089 ProfileManager::GetDefaultProfileOrOffTheRecord(), 1090 chrome::HOST_DESKTOP_TYPE_ASH); 1091 chrome::ShowSingletonTab(displayer.browser(), GURL(setup_url)); 1092 return; 1093 } 1094 } 1095 } 1096 // TODO(nkostylev): Show generic error message. http://crosbug.com/15444 1097 } 1098 LOG(ERROR) << "EnableCellularCallback called for enabled mobile device"; 1099 } 1100 1101 void InternetOptionsHandler::DisableCellularCallback( 1102 const base::ListValue* args) { 1103 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( 1104 NetworkTypePattern::Mobile(), false, 1105 base::Bind(&ShillError, "DisableCellularCallback")); 1106 } 1107 1108 void InternetOptionsHandler::EnableWimaxCallback(const base::ListValue* args) { 1109 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( 1110 NetworkTypePattern::Wimax(), true, 1111 base::Bind(&ShillError, "EnableWimaxCallback")); 1112 } 1113 1114 void InternetOptionsHandler::DisableWimaxCallback(const base::ListValue* args) { 1115 NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled( 1116 NetworkTypePattern::Wimax(), false, 1117 base::Bind(&ShillError, "DisableWimaxCallback")); 1118 } 1119 1120 void InternetOptionsHandler::ShowMorePlanInfoCallback( 1121 const base::ListValue* args) { 1122 if (!web_ui()) 1123 return; 1124 std::string service_path; 1125 if (args->GetSize() != 1 || !args->GetString(0, &service_path)) { 1126 NOTREACHED(); 1127 return; 1128 } 1129 ash::network_connect::ShowMobileSetup(service_path); 1130 } 1131 1132 void InternetOptionsHandler::BuyDataPlanCallback(const base::ListValue* args) { 1133 if (!web_ui()) 1134 return; 1135 std::string service_path; 1136 if (args->GetSize() != 1 || !args->GetString(0, &service_path)) { 1137 NOTREACHED(); 1138 return; 1139 } 1140 ash::network_connect::ShowMobileSetup(service_path); 1141 } 1142 1143 void InternetOptionsHandler::SetApnCallback(const base::ListValue* args) { 1144 std::string service_path; 1145 if (!args->GetString(0, &service_path)) { 1146 NOTREACHED(); 1147 return; 1148 } 1149 NetworkHandler::Get()->network_configuration_handler()->GetProperties( 1150 service_path, 1151 base::Bind(&InternetOptionsHandler::SetApnProperties, 1152 weak_factory_.GetWeakPtr(), base::Owned(args->DeepCopy())), 1153 base::Bind(&ShillError, "SetApnCallback")); 1154 } 1155 1156 void InternetOptionsHandler::SetApnProperties( 1157 const base::ListValue* args, 1158 const std::string& service_path, 1159 const base::DictionaryValue& shill_properties) { 1160 std::string apn, username, password; 1161 if (!args->GetString(1, &apn) || 1162 !args->GetString(2, &username) || 1163 !args->GetString(3, &password)) { 1164 NOTREACHED(); 1165 return; 1166 } 1167 NET_LOG_EVENT("SetApnCallback", service_path); 1168 1169 if (apn.empty()) { 1170 std::vector<std::string> properties_to_clear; 1171 properties_to_clear.push_back(shill::kCellularApnProperty); 1172 NetworkHandler::Get()->network_configuration_handler()->ClearProperties( 1173 service_path, properties_to_clear, 1174 base::Bind(&base::DoNothing), 1175 base::Bind(&ShillError, "ClearCellularApnProperties")); 1176 return; 1177 } 1178 1179 const base::DictionaryValue* shill_apn_dict = NULL; 1180 std::string network_id; 1181 if (shill_properties.GetDictionaryWithoutPathExpansion( 1182 shill::kCellularApnProperty, &shill_apn_dict)) { 1183 shill_apn_dict->GetStringWithoutPathExpansion( 1184 shill::kApnNetworkIdProperty, &network_id); 1185 } 1186 base::DictionaryValue properties; 1187 base::DictionaryValue* apn_dict = new base::DictionaryValue; 1188 apn_dict->SetStringWithoutPathExpansion(shill::kApnProperty, apn); 1189 apn_dict->SetStringWithoutPathExpansion(shill::kApnNetworkIdProperty, 1190 network_id); 1191 apn_dict->SetStringWithoutPathExpansion(shill::kApnUsernameProperty, 1192 username); 1193 apn_dict->SetStringWithoutPathExpansion(shill::kApnPasswordProperty, 1194 password); 1195 properties.SetWithoutPathExpansion(shill::kCellularApnProperty, apn_dict); 1196 NetworkHandler::Get()->network_configuration_handler()->SetProperties( 1197 service_path, properties, 1198 base::Bind(&base::DoNothing), 1199 base::Bind(&ShillError, "SetApnProperties")); 1200 } 1201 1202 void InternetOptionsHandler::CarrierStatusCallback() { 1203 NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler(); 1204 const DeviceState* device = 1205 handler->GetDeviceStateByType(NetworkTypePattern::Cellular()); 1206 if (device && (device->carrier() == shill::kCarrierSprint)) { 1207 const NetworkState* network = 1208 handler->FirstNetworkByType(NetworkTypePattern::Cellular()); 1209 if (network) { 1210 ash::network_connect::ActivateCellular(network->path()); 1211 UpdateConnectionData(network->path()); 1212 } 1213 } 1214 UpdateCarrier(); 1215 } 1216 1217 void InternetOptionsHandler::SetCarrierCallback(const base::ListValue* args) { 1218 std::string service_path; 1219 std::string carrier; 1220 if (args->GetSize() != 2 || 1221 !args->GetString(0, &service_path) || 1222 !args->GetString(1, &carrier)) { 1223 NOTREACHED(); 1224 return; 1225 } 1226 const DeviceState* device = NetworkHandler::Get()->network_state_handler()-> 1227 GetDeviceStateByType(NetworkTypePattern::Cellular()); 1228 if (!device) { 1229 LOG(WARNING) << "SetCarrierCallback with no cellular device."; 1230 return; 1231 } 1232 NetworkHandler::Get()->network_device_handler()->SetCarrier( 1233 device->path(), 1234 carrier, 1235 base::Bind(&InternetOptionsHandler::CarrierStatusCallback, 1236 weak_factory_.GetWeakPtr()), 1237 base::Bind(&ShillError, "SetCarrierCallback")); 1238 } 1239 1240 void InternetOptionsHandler::SetSimCardLockCallback( 1241 const base::ListValue* args) { 1242 bool require_pin_new_value; 1243 if (!args->GetBoolean(0, &require_pin_new_value)) { 1244 NOTREACHED(); 1245 return; 1246 } 1247 // 1. Bring up SIM unlock dialog, pass new RequirePin setting in URL. 1248 // 2. Dialog will ask for current PIN in any case. 1249 // 3. If card is locked it will first call PIN unlock operation 1250 // 4. Then it will call Set RequirePin, passing the same PIN. 1251 // 5. We'll get notified by REQUIRE_PIN_SETTING_CHANGE_ENDED notification. 1252 SimDialogDelegate::SimDialogMode mode; 1253 if (require_pin_new_value) 1254 mode = SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON; 1255 else 1256 mode = SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF; 1257 SimDialogDelegate::ShowDialog(GetNativeWindow(), mode); 1258 } 1259 1260 void InternetOptionsHandler::ChangePinCallback(const base::ListValue* args) { 1261 SimDialogDelegate::ShowDialog(GetNativeWindow(), 1262 SimDialogDelegate::SIM_DIALOG_CHANGE_PIN); 1263 } 1264 1265 void InternetOptionsHandler::RefreshNetworksCallback( 1266 const base::ListValue* args) { 1267 NetworkHandler::Get()->network_state_handler()->RequestScan(); 1268 } 1269 1270 std::string InternetOptionsHandler::GetIconDataUrl(int resource_id) const { 1271 gfx::ImageSkia* icon = 1272 ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id); 1273 gfx::ImageSkiaRep image_rep = icon->GetRepresentation( 1274 ui::GetImageScale(web_ui()->GetDeviceScaleFactor())); 1275 return webui::GetBitmapDataUrl(image_rep.sk_bitmap()); 1276 } 1277 1278 void InternetOptionsHandler::RefreshNetworkData() { 1279 base::DictionaryValue dictionary; 1280 FillNetworkInfo(&dictionary); 1281 web_ui()->CallJavascriptFunction( 1282 kRefreshNetworkDataFunction, dictionary); 1283 } 1284 1285 void InternetOptionsHandler::UpdateConnectionData( 1286 const std::string& service_path) { 1287 NetworkHandler::Get()->network_configuration_handler()->GetProperties( 1288 service_path, 1289 base::Bind(&InternetOptionsHandler::UpdateConnectionDataCallback, 1290 weak_factory_.GetWeakPtr()), 1291 base::Bind(&ShillError, "UpdateConnectionData")); 1292 } 1293 1294 void InternetOptionsHandler::UpdateConnectionDataCallback( 1295 const std::string& service_path, 1296 const base::DictionaryValue& shill_properties) { 1297 const NetworkState* network = GetNetworkState(service_path); 1298 if (!network) 1299 return; 1300 base::DictionaryValue dictionary; 1301 PopulateConnectionDetails(network, shill_properties, &dictionary); 1302 web_ui()->CallJavascriptFunction(kUpdateConnectionDataFunction, dictionary); 1303 } 1304 1305 void InternetOptionsHandler::UpdateCarrier() { 1306 web_ui()->CallJavascriptFunction(kUpdateCarrierFunction); 1307 } 1308 1309 void InternetOptionsHandler::DeviceListChanged() { 1310 if (!web_ui()) 1311 return; 1312 RefreshNetworkData(); 1313 } 1314 1315 void InternetOptionsHandler::NetworkListChanged() { 1316 if (!web_ui()) 1317 return; 1318 RefreshNetworkData(); 1319 } 1320 1321 void InternetOptionsHandler::NetworkConnectionStateChanged( 1322 const NetworkState* network) { 1323 if (!web_ui()) 1324 return; 1325 // Update the connection data for the detailed view when the connection state 1326 // of any network changes. 1327 if (!details_path_.empty()) 1328 UpdateConnectionData(details_path_); 1329 } 1330 1331 void InternetOptionsHandler::NetworkPropertiesUpdated( 1332 const NetworkState* network) { 1333 if (!web_ui()) 1334 return; 1335 RefreshNetworkData(); 1336 UpdateConnectionData(network->path()); 1337 } 1338 1339 void InternetOptionsHandler::LoggedInStateChanged() { 1340 UpdateLoggedInUserType(); 1341 } 1342 1343 void InternetOptionsHandler::UpdateLoggedInUserType() { 1344 if (!web_ui()) 1345 return; 1346 base::StringValue login_type( 1347 LoggedInUserTypeToString(LoginState::Get()->GetLoggedInUserType())); 1348 web_ui()->CallJavascriptFunction( 1349 kUpdateLoggedInUserTypeFunction, login_type); 1350 } 1351 1352 void InternetOptionsHandler::Observe( 1353 int type, 1354 const content::NotificationSource& source, 1355 const content::NotificationDetails& details) { 1356 OptionsPageUIHandler::Observe(type, source, details); 1357 if (type == chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED) { 1358 base::FundamentalValue require_pin(*content::Details<bool>(details).ptr()); 1359 web_ui()->CallJavascriptFunction( 1360 kUpdateSecurityTabFunction, require_pin); 1361 } else if (type == chrome::NOTIFICATION_ENTER_PIN_ENDED) { 1362 // We make an assumption (which is valid for now) that the SIM 1363 // unlock dialog is put up only when the user is trying to enable 1364 // mobile data. 1365 bool cancelled = *content::Details<bool>(details).ptr(); 1366 if (cancelled) 1367 RefreshNetworkData(); 1368 // The case in which the correct PIN was entered and the SIM is 1369 // now unlocked is handled in NetworkMenuButton. 1370 } 1371 } 1372 1373 void InternetOptionsHandler::SetServerHostnameCallback( 1374 const base::ListValue* args) { 1375 std::string service_path, server_hostname; 1376 if (args->GetSize() < 2 || 1377 !args->GetString(0, &service_path) || 1378 !args->GetString(1, &server_hostname)) { 1379 NOTREACHED(); 1380 return; 1381 } 1382 SetNetworkProperty(service_path, shill::kProviderHostProperty, 1383 base::Value::CreateStringValue(server_hostname)); 1384 } 1385 1386 void InternetOptionsHandler::SetPreferNetworkCallback( 1387 const base::ListValue* args) { 1388 std::string service_path, prefer_network_str; 1389 if (args->GetSize() < 2 || 1390 !args->GetString(0, &service_path) || 1391 !args->GetString(1, &prefer_network_str)) { 1392 NOTREACHED(); 1393 return; 1394 } 1395 int priority = (prefer_network_str == kTagTrue) ? kPreferredPriority : 0; 1396 SetNetworkProperty(service_path, shill::kPriorityProperty, 1397 base::Value::CreateIntegerValue(priority)); 1398 } 1399 1400 void InternetOptionsHandler::SetAutoConnectCallback( 1401 const base::ListValue* args) { 1402 std::string service_path, auto_connect_str; 1403 if (args->GetSize() < 2 || 1404 !args->GetString(0, &service_path) || 1405 !args->GetString(1, &auto_connect_str)) { 1406 NOTREACHED(); 1407 return; 1408 } 1409 bool auto_connect = auto_connect_str == kTagTrue; 1410 SetNetworkProperty(service_path, shill::kAutoConnectProperty, 1411 base::Value::CreateBooleanValue(auto_connect)); 1412 } 1413 1414 void InternetOptionsHandler::SetIPConfigCallback(const base::ListValue* args) { 1415 std::string service_path; 1416 if (!args->GetString(0, &service_path)) { 1417 NOTREACHED(); 1418 return; 1419 } 1420 NetworkHandler::Get()->network_configuration_handler()->GetProperties( 1421 service_path, 1422 base::Bind(&InternetOptionsHandler::SetIPConfigProperties, 1423 weak_factory_.GetWeakPtr(), base::Owned(args->DeepCopy())), 1424 base::Bind(&ShillError, "SetIPConfigCallback")); 1425 } 1426 1427 void InternetOptionsHandler::SetIPConfigProperties( 1428 const base::ListValue* args, 1429 const std::string& service_path, 1430 const base::DictionaryValue& shill_properties) { 1431 std::string address, netmask, gateway, name_server_type, name_servers; 1432 bool dhcp_for_ip; 1433 if (!args->GetBoolean(1, &dhcp_for_ip) || 1434 !args->GetString(2, &address) || 1435 !args->GetString(3, &netmask) || 1436 !args->GetString(4, &gateway) || 1437 !args->GetString(5, &name_server_type) || 1438 !args->GetString(6, &name_servers)) { 1439 NOTREACHED(); 1440 return; 1441 } 1442 NET_LOG_USER("SetIPConfigProperties", service_path); 1443 1444 bool request_reconnect = false; 1445 std::vector<std::string> properties_to_clear; 1446 base::DictionaryValue properties_to_set; 1447 1448 if (dhcp_for_ip) { 1449 request_reconnect |= AppendPropertyKeyIfPresent( 1450 shill::kStaticIPAddressProperty, 1451 shill_properties, &properties_to_clear); 1452 request_reconnect |= AppendPropertyKeyIfPresent( 1453 shill::kStaticIPPrefixlenProperty, 1454 shill_properties, &properties_to_clear); 1455 request_reconnect |= AppendPropertyKeyIfPresent( 1456 shill::kStaticIPGatewayProperty, 1457 shill_properties, &properties_to_clear); 1458 } else { 1459 request_reconnect |= AddStringPropertyIfChanged( 1460 shill::kStaticIPAddressProperty, 1461 address, shill_properties, &properties_to_set); 1462 int prefixlen = network_util::NetmaskToPrefixLength(netmask); 1463 if (prefixlen < 0) { 1464 LOG(ERROR) << "Invalid prefix length for: " << service_path 1465 << " with netmask " << netmask; 1466 prefixlen = 0; 1467 } 1468 request_reconnect |= AddIntegerPropertyIfChanged( 1469 shill::kStaticIPPrefixlenProperty, 1470 prefixlen, shill_properties, &properties_to_set); 1471 request_reconnect |= AddStringPropertyIfChanged( 1472 shill::kStaticIPGatewayProperty, 1473 gateway, shill_properties, &properties_to_set); 1474 } 1475 1476 if (name_server_type == kNameServerTypeAutomatic) { 1477 AppendPropertyKeyIfPresent(shill::kStaticIPNameServersProperty, 1478 shill_properties, &properties_to_clear); 1479 } else { 1480 if (name_server_type == kNameServerTypeGoogle) 1481 name_servers = kGoogleNameServers; 1482 AddStringPropertyIfChanged( 1483 shill::kStaticIPNameServersProperty, 1484 name_servers, shill_properties, &properties_to_set); 1485 } 1486 1487 if (!properties_to_clear.empty()) { 1488 NetworkHandler::Get()->network_configuration_handler()->ClearProperties( 1489 service_path, properties_to_clear, 1490 base::Bind(&base::DoNothing), 1491 base::Bind(&ShillError, "ClearIPConfigProperties")); 1492 } 1493 if (!properties_to_set.empty()) { 1494 NetworkHandler::Get()->network_configuration_handler()->SetProperties( 1495 service_path, properties_to_set, 1496 base::Bind(&base::DoNothing), 1497 base::Bind(&ShillError, "SetIPConfigProperties")); 1498 } 1499 std::string device_path; 1500 shill_properties.GetStringWithoutPathExpansion( 1501 shill::kDeviceProperty, &device_path); 1502 if (!device_path.empty()) { 1503 base::Closure callback = base::Bind(&base::DoNothing); 1504 // If auto config or a static IP property changed, we need to reconnect 1505 // to the network. 1506 if (request_reconnect) 1507 callback = base::Bind(&RequestReconnect, service_path, GetNativeWindow()); 1508 NetworkHandler::Get()->network_device_handler()->RequestRefreshIPConfigs( 1509 device_path, 1510 callback, 1511 base::Bind(&ShillError, "RequestRefreshIPConfigs")); 1512 } 1513 } 1514 1515 void InternetOptionsHandler::PopulateDictionaryDetailsCallback( 1516 const std::string& service_path, 1517 const base::DictionaryValue& shill_properties) { 1518 const NetworkState* network = GetNetworkState(service_path); 1519 if (!network) { 1520 LOG(ERROR) << "Network properties not found: " << service_path; 1521 return; 1522 } 1523 1524 details_path_ = service_path; 1525 1526 ::onc::ONCSource onc_source = ::onc::ONC_SOURCE_NONE; 1527 const base::DictionaryValue* onc = 1528 onc::FindPolicyForActiveUser(network->guid(), &onc_source); 1529 const NetworkPropertyUIData property_ui_data(onc_source); 1530 1531 base::DictionaryValue dictionary; 1532 1533 // Device hardware address 1534 const DeviceState* device = NetworkHandler::Get()->network_state_handler()-> 1535 GetDeviceState(network->device_path()); 1536 if (device) 1537 dictionary.SetString(kTagHardwareAddress, device->GetFormattedMacAddress()); 1538 1539 // IP config 1540 scoped_ptr<base::DictionaryValue> ipconfig_dhcp(new base::DictionaryValue); 1541 ipconfig_dhcp->SetString(kIpConfigAddress, network->ip_address()); 1542 ipconfig_dhcp->SetString(kIpConfigNetmask, network->GetNetmask()); 1543 ipconfig_dhcp->SetString(kIpConfigGateway, network->gateway()); 1544 std::string ipconfig_name_servers = network->GetDnsServersAsString(); 1545 ipconfig_dhcp->SetString(kIpConfigNameServers, ipconfig_name_servers); 1546 ipconfig_dhcp->SetString(kIpConfigWebProxyAutoDiscoveryUrl, 1547 network->web_proxy_auto_discovery_url().spec()); 1548 SetValueDictionary(&dictionary, 1549 kDictionaryIpConfig, 1550 ipconfig_dhcp.release(), 1551 property_ui_data); 1552 1553 std::string name_server_type = kNameServerTypeAutomatic; 1554 int automatic_ip_config = 0; 1555 scoped_ptr<base::DictionaryValue> static_ip_dict( 1556 BuildIPInfoDictionary(shill_properties, true, &automatic_ip_config)); 1557 dictionary.SetBoolean(kIpConfigAutoConfig, automatic_ip_config == 0); 1558 DCHECK(automatic_ip_config == 3 || automatic_ip_config == 0) 1559 << "UI doesn't support automatic specification of individual " 1560 << "static IP parameters."; 1561 scoped_ptr<base::DictionaryValue> saved_ip_dict( 1562 BuildIPInfoDictionary(shill_properties, false, NULL)); 1563 dictionary.Set(kDictionarySavedIp, saved_ip_dict.release()); 1564 1565 // Determine what kind of name server setting we have by comparing the 1566 // StaticIP and Google values with the ipconfig values. 1567 std::string static_ip_nameservers; 1568 static_ip_dict->GetString(kIpConfigNameServers, &static_ip_nameservers); 1569 if (!static_ip_nameservers.empty() && 1570 static_ip_nameservers == ipconfig_name_servers) { 1571 name_server_type = kNameServerTypeUser; 1572 } 1573 if (ipconfig_name_servers == kGoogleNameServers) { 1574 name_server_type = kNameServerTypeGoogle; 1575 } 1576 SetValueDictionary(&dictionary, 1577 kDictionaryStaticIp, 1578 static_ip_dict.release(), 1579 property_ui_data); 1580 1581 std::string type = network->type(); 1582 dictionary.SetString(kTagType, type); 1583 dictionary.SetString(kTagServicePath, network->path()); 1584 dictionary.SetString(kTagNameServerType, name_server_type); 1585 dictionary.SetString(kTagNameServersGoogle, kGoogleNameServers); 1586 1587 // Only show proxy for remembered networks. 1588 dictionary.SetBoolean(kTagShowProxy, !network->profile_path().empty()); 1589 1590 // Enable static ip config for Ethernet or WiFi. 1591 bool staticIPConfig = network->Matches(NetworkTypePattern::Ethernet()) || 1592 type == shill::kTypeWifi; 1593 dictionary.SetBoolean(kTagShowStaticIPConfig, staticIPConfig); 1594 1595 dictionary.SetBoolean(kTagShowPreferred, !network->profile_path().empty()); 1596 int priority = 0; 1597 shill_properties.GetIntegerWithoutPathExpansion( 1598 shill::kPriorityProperty, &priority); 1599 bool preferred = priority > 0; 1600 SetValueDictionary(&dictionary, kTagPreferred, 1601 new base::FundamentalValue(preferred), 1602 property_ui_data); 1603 1604 NetworkPropertyUIData auto_connect_ui_data(onc_source); 1605 std::string onc_path_to_auto_connect; 1606 if (type == shill::kTypeWifi) { 1607 onc_path_to_auto_connect = base::StringPrintf( 1608 "%s.%s", 1609 ::onc::network_config::kWiFi, 1610 ::onc::wifi::kAutoConnect); 1611 } else if (type == shill::kTypeVPN) { 1612 onc_path_to_auto_connect = base::StringPrintf( 1613 "%s.%s", 1614 ::onc::network_config::kVPN, 1615 ::onc::vpn::kAutoConnect); 1616 } 1617 if (!onc_path_to_auto_connect.empty()) { 1618 auto_connect_ui_data.ParseOncProperty( 1619 onc_source, onc, onc_path_to_auto_connect); 1620 } 1621 bool auto_connect = false; 1622 shill_properties.GetBooleanWithoutPathExpansion( 1623 shill::kAutoConnectProperty, &auto_connect); 1624 SetAutoconnectValueDictionary(network->IsPrivate(), 1625 onc_source, 1626 auto_connect, 1627 auto_connect_ui_data, 1628 &dictionary); 1629 1630 PopulateConnectionDetails(network, shill_properties, &dictionary); 1631 1632 // Show details dialog 1633 web_ui()->CallJavascriptFunction(kShowDetailedInfoFunction, dictionary); 1634 } 1635 1636 namespace { 1637 1638 void PopulateConnectionDetails(const NetworkState* network, 1639 const base::DictionaryValue& shill_properties, 1640 base::DictionaryValue* dictionary) { 1641 dictionary->SetString(kNetworkInfoKeyServicePath, network->path()); 1642 dictionary->SetString(kTagServiceName, network->name()); 1643 dictionary->SetBoolean(kTagConnecting, network->IsConnectingState()); 1644 dictionary->SetBoolean(kTagConnected, network->IsConnectedState()); 1645 dictionary->SetString(kTagConnectionState, 1646 ConnectionStateString(network->connection_state())); 1647 dictionary->SetString(kTagNetworkName, network->name()); 1648 dictionary->SetString( 1649 kTagErrorState, 1650 ash::network_connect::ErrorString(network->error(), network->path())); 1651 1652 dictionary->SetBoolean(kTagRemembered, !network->profile_path().empty()); 1653 bool shared = !network->IsPrivate(); 1654 dictionary->SetBoolean(kTagShared, shared); 1655 1656 const std::string& type = network->type(); 1657 const NetworkState* connected_network = 1658 NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType( 1659 NetworkTypePattern::Primitive(type)); 1660 1661 dictionary->SetBoolean(kTagDeviceConnected, connected_network != NULL); 1662 1663 if (type == shill::kTypeWifi) 1664 PopulateWifiDetails(network, shill_properties, dictionary); 1665 else if (type == shill::kTypeWimax) 1666 PopulateWimaxDetails(network, shill_properties, dictionary); 1667 else if (type == shill::kTypeCellular) 1668 PopulateCellularDetails(network, shill_properties, dictionary); 1669 else if (type == shill::kTypeVPN) 1670 PopulateVPNDetails(network, shill_properties, dictionary); 1671 } 1672 1673 void PopulateWifiDetails(const NetworkState* wifi, 1674 const base::DictionaryValue& shill_properties, 1675 base::DictionaryValue* dictionary) { 1676 dictionary->SetString(kTagSsid, wifi->name()); 1677 dictionary->SetInteger(kTagStrength, wifi->signal_strength()); 1678 dictionary->SetString(kTagEncryption, 1679 EncryptionString(wifi->security(), wifi->eap_method())); 1680 CopyStringFromDictionary(shill_properties, shill::kWifiBSsid, 1681 kTagBssid, dictionary); 1682 CopyIntegerFromDictionary(shill_properties, shill::kWifiFrequency, 1683 kTagFrequency, false, dictionary); 1684 } 1685 1686 void PopulateWimaxDetails(const NetworkState* wimax, 1687 const base::DictionaryValue& shill_properties, 1688 base::DictionaryValue* dictionary) { 1689 dictionary->SetInteger(kTagStrength, wimax->signal_strength()); 1690 CopyStringFromDictionary(shill_properties, shill::kEapIdentityProperty, 1691 kTagIdentity, dictionary); 1692 } 1693 1694 void CreateDictionaryFromCellularApn(const base::DictionaryValue* apn, 1695 base::DictionaryValue* dictionary) { 1696 CopyStringFromDictionary(*apn, shill::kApnProperty, 1697 kTagApn, dictionary); 1698 CopyStringFromDictionary(*apn, shill::kApnNetworkIdProperty, 1699 kTagNetworkId, dictionary); 1700 CopyStringFromDictionary(*apn, shill::kApnUsernameProperty, 1701 kTagUsername, dictionary); 1702 CopyStringFromDictionary(*apn, shill::kApnPasswordProperty, 1703 kTagPassword, dictionary); 1704 CopyStringFromDictionary(*apn, shill::kApnNameProperty, 1705 kTagName, dictionary); 1706 CopyStringFromDictionary(*apn, shill::kApnLocalizedNameProperty, 1707 kTagLocalizedName, dictionary); 1708 CopyStringFromDictionary(*apn, shill::kApnLanguageProperty, 1709 kTagLanguage, dictionary); 1710 } 1711 1712 void PopulateCellularDetails(const NetworkState* cellular, 1713 const base::DictionaryValue& shill_properties, 1714 base::DictionaryValue* dictionary) { 1715 dictionary->SetBoolean(kTagCarrierSelectFlag, 1716 CommandLine::ForCurrentProcess()->HasSwitch( 1717 chromeos::switches::kEnableCarrierSwitching)); 1718 // Cellular network / connection settings. 1719 dictionary->SetString(kTagNetworkTechnology, cellular->network_technology()); 1720 dictionary->SetString(kTagActivationState, 1721 ActivationStateString(cellular->activation_state())); 1722 dictionary->SetString(kTagRoamingState, 1723 RoamingStateString(cellular->roaming())); 1724 bool restricted = cellular->connection_state() == shill::kStatePortal; 1725 dictionary->SetString(kTagRestrictedPool, 1726 restricted ? 1727 l10n_util::GetStringUTF8( 1728 IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL) : 1729 l10n_util::GetStringUTF8( 1730 IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL)); 1731 1732 const base::DictionaryValue* serving_operator = NULL; 1733 if (shill_properties.GetDictionaryWithoutPathExpansion( 1734 shill::kServingOperatorProperty, &serving_operator)) { 1735 CopyStringFromDictionary(*serving_operator, shill::kOperatorNameKey, 1736 kTagOperatorName, dictionary); 1737 CopyStringFromDictionary(*serving_operator, shill::kOperatorCodeKey, 1738 kTagOperatorCode, dictionary); 1739 } 1740 1741 const base::DictionaryValue* olp = NULL; 1742 if (shill_properties.GetDictionaryWithoutPathExpansion( 1743 shill::kPaymentPortalProperty, &olp)) { 1744 std::string url; 1745 olp->GetStringWithoutPathExpansion(shill::kPaymentPortalURL, &url); 1746 dictionary->SetString(kTagSupportUrl, url); 1747 } 1748 1749 base::DictionaryValue* apn = new base::DictionaryValue; 1750 const base::DictionaryValue* source_apn = NULL; 1751 if (shill_properties.GetDictionaryWithoutPathExpansion( 1752 shill::kCellularApnProperty, &source_apn)) { 1753 CreateDictionaryFromCellularApn(source_apn, apn); 1754 } 1755 dictionary->Set(kTagApn, apn); 1756 1757 base::DictionaryValue* last_good_apn = new base::DictionaryValue; 1758 if (shill_properties.GetDictionaryWithoutPathExpansion( 1759 shill::kCellularLastGoodApnProperty, &source_apn)) { 1760 CreateDictionaryFromCellularApn(source_apn, last_good_apn); 1761 } 1762 dictionary->Set(kTagLastGoodApn, last_good_apn); 1763 1764 // These default to empty and are only set if device != NULL. 1765 std::string carrier_id; 1766 std::string mdn; 1767 1768 // Device settings. 1769 const DeviceState* device = NetworkHandler::Get()->network_state_handler()-> 1770 GetDeviceState(cellular->device_path()); 1771 if (device) { 1772 // TODO(stevenjb): Add NetworkDeviceHandler::GetProperties() and use that 1773 // to retrieve the complete dictionary of device properties, instead of 1774 // caching them (will be done for the new UI). 1775 const base::DictionaryValue& device_properties = device->properties(); 1776 const NetworkPropertyUIData cellular_property_ui_data( 1777 cellular->ui_data().onc_source()); 1778 CopyStringFromDictionary(device_properties, shill::kManufacturerProperty, 1779 kTagManufacturer, dictionary); 1780 CopyStringFromDictionary(device_properties, shill::kModelIDProperty, 1781 kTagModelId, dictionary); 1782 CopyStringFromDictionary(device_properties, 1783 shill::kFirmwareRevisionProperty, 1784 kTagFirmwareRevision, dictionary); 1785 CopyStringFromDictionary(device_properties, 1786 shill::kHardwareRevisionProperty, 1787 kTagHardwareRevision, dictionary); 1788 CopyIntegerFromDictionary(device_properties, shill::kPRLVersionProperty, 1789 kTagPrlVersion, true, dictionary); 1790 CopyStringFromDictionary(device_properties, shill::kMeidProperty, 1791 kTagMeid, dictionary); 1792 CopyStringFromDictionary(device_properties, shill::kIccidProperty, 1793 kTagIccid, dictionary); 1794 CopyStringFromDictionary(device_properties, shill::kImeiProperty, 1795 kTagImei, dictionary); 1796 mdn = CopyStringFromDictionary(device_properties, shill::kMdnProperty, 1797 kTagMdn, dictionary); 1798 CopyStringFromDictionary(device_properties, shill::kImsiProperty, 1799 kTagImsi, dictionary); 1800 CopyStringFromDictionary(device_properties, shill::kEsnProperty, 1801 kTagEsn, dictionary); 1802 CopyStringFromDictionary(device_properties, shill::kMinProperty, 1803 kTagMin, dictionary); 1804 std::string family; 1805 device_properties.GetStringWithoutPathExpansion( 1806 shill::kTechnologyFamilyProperty, &family); 1807 dictionary->SetBoolean(kTagGsm, family == shill::kNetworkTechnologyGsm); 1808 1809 SetValueDictionary( 1810 dictionary, kTagSimCardLockEnabled, 1811 new base::FundamentalValue(device->sim_lock_enabled()), 1812 cellular_property_ui_data); 1813 1814 carrier_id = device->home_provider_id(); 1815 1816 MobileConfig* config = MobileConfig::GetInstance(); 1817 if (config->IsReady()) { 1818 const MobileConfig::Carrier* carrier = config->GetCarrier(carrier_id); 1819 if (carrier && !carrier->top_up_url().empty()) 1820 dictionary->SetString(kTagCarrierUrl, carrier->top_up_url()); 1821 } 1822 1823 base::ListValue* apn_list_value = new base::ListValue(); 1824 const base::ListValue* apn_list; 1825 if (device_properties.GetListWithoutPathExpansion( 1826 shill::kCellularApnListProperty, &apn_list)) { 1827 for (base::ListValue::const_iterator iter = apn_list->begin(); 1828 iter != apn_list->end(); ++iter) { 1829 const base::DictionaryValue* dict; 1830 if ((*iter)->GetAsDictionary(&dict)) { 1831 base::DictionaryValue* apn = new base::DictionaryValue; 1832 CreateDictionaryFromCellularApn(dict, apn); 1833 apn_list_value->Append(apn); 1834 } 1835 } 1836 } 1837 SetValueDictionary(dictionary, kTagProviderApnList, apn_list_value, 1838 cellular_property_ui_data); 1839 if (CommandLine::ForCurrentProcess()->HasSwitch( 1840 chromeos::switches::kEnableCarrierSwitching)) { 1841 const base::ListValue* supported_carriers; 1842 if (device_properties.GetListWithoutPathExpansion( 1843 shill::kSupportedCarriersProperty, &supported_carriers)) { 1844 dictionary->Set(kTagCarriers, supported_carriers->DeepCopy()); 1845 dictionary->SetInteger(kTagCurrentCarrierIndex, 1846 FindCurrentCarrierIndex(supported_carriers, 1847 device)); 1848 } else { 1849 // In case of any error, set the current carrier tag to -1 indicating 1850 // to the JS code to fallback to a single carrier. 1851 dictionary->SetInteger(kTagCurrentCarrierIndex, -1); 1852 } 1853 } 1854 } 1855 1856 // Set Cellular Buttons Visibility 1857 dictionary->SetBoolean( 1858 kTagDisableConnectButton, 1859 cellular->activation_state() == shill::kActivationStateActivating || 1860 cellular->IsConnectingState()); 1861 1862 // Don't show any account management related buttons if the activation 1863 // state is unknown or no payment portal URL is available. 1864 std::string support_url; 1865 if (cellular->activation_state() == shill::kActivationStateUnknown || 1866 !dictionary->GetString(kTagSupportUrl, &support_url) || 1867 support_url.empty()) { 1868 VLOG(2) << "No support URL is available. Don't display buttons."; 1869 return; 1870 } 1871 1872 if (cellular->activation_state() != shill::kActivationStateActivating && 1873 cellular->activation_state() != shill::kActivationStateActivated) { 1874 dictionary->SetBoolean(kTagShowActivateButton, true); 1875 } else { 1876 bool may_show_portal_button = false; 1877 1878 // If an online payment URL was provided by shill, then this means that the 1879 // "View Account" button should be shown for the current carrier. 1880 if (olp) { 1881 std::string url; 1882 olp->GetStringWithoutPathExpansion(shill::kPaymentPortalURL, &url); 1883 may_show_portal_button = !url.empty(); 1884 } 1885 // If no online payment URL was provided by shill, fall back to 1886 // MobileConfig to determine if the "View Account" should be shown. 1887 if (!may_show_portal_button && MobileConfig::GetInstance()->IsReady()) { 1888 const MobileConfig::Carrier* carrier = 1889 MobileConfig::GetInstance()->GetCarrier(carrier_id); 1890 may_show_portal_button = carrier && carrier->show_portal_button(); 1891 } 1892 if (may_show_portal_button) { 1893 // The button should be shown for a LTE network even when the LTE network 1894 // is not connected, but CrOS is online. This is done to enable users to 1895 // update their plan even if they are out of credits. 1896 // The button should not be shown when the device's mdn is not set, 1897 // because the network's proper portal url cannot be generated without it 1898 const NetworkState* default_network = 1899 NetworkHandler::Get()->network_state_handler()->DefaultNetwork(); 1900 const std::string& technology = cellular->network_technology(); 1901 bool force_show_view_account_button = 1902 (technology == shill::kNetworkTechnologyLte || 1903 technology == shill::kNetworkTechnologyLteAdvanced) && 1904 default_network && 1905 !mdn.empty(); 1906 1907 // The button will trigger ShowMorePlanInfoCallback() which will open 1908 // carrier specific portal. 1909 if (cellular->IsConnectedState() || force_show_view_account_button) 1910 dictionary->SetBoolean(kTagShowViewAccountButton, true); 1911 } 1912 } 1913 } 1914 1915 } // namespace 1916 1917 gfx::NativeWindow InternetOptionsHandler::GetNativeWindow() const { 1918 return web_ui()->GetWebContents()->GetView()->GetTopLevelNativeWindow(); 1919 } 1920 1921 void InternetOptionsHandler::NetworkCommandCallback( 1922 const base::ListValue* args) { 1923 std::string type; 1924 std::string service_path; 1925 std::string command; 1926 if (args->GetSize() != 3 || 1927 !args->GetString(0, &type) || 1928 !args->GetString(1, &service_path) || 1929 !args->GetString(2, &command)) { 1930 NOTREACHED(); 1931 return; 1932 } 1933 1934 // Process commands that do not require an existing network. 1935 if (command == kTagAddConnection) { 1936 if (CanAddNetworkType(type)) 1937 AddConnection(type); 1938 } else if (command == kTagForget) { 1939 if (CanForgetNetworkType(type)) { 1940 NetworkHandler::Get()->network_configuration_handler()-> 1941 RemoveConfiguration( 1942 service_path, 1943 base::Bind(&base::DoNothing), 1944 base::Bind(&ShillError, "NetworkCommand: " + command)); 1945 } 1946 } else if (command == kTagOptions) { 1947 NetworkHandler::Get()->network_configuration_handler()->GetProperties( 1948 service_path, 1949 base::Bind(&InternetOptionsHandler::PopulateDictionaryDetailsCallback, 1950 weak_factory_.GetWeakPtr()), 1951 base::Bind(&ShillError, "NetworkCommand: " + command)); 1952 } else if (command == kTagConnect) { 1953 ash::network_connect::ConnectToNetwork(service_path, GetNativeWindow()); 1954 } else if (command == kTagDisconnect) { 1955 NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork( 1956 service_path, 1957 base::Bind(&base::DoNothing), 1958 base::Bind(&ShillError, "NetworkCommand: " + command)); 1959 } else if (command == kTagConfigure) { 1960 NetworkConfigView::Show(service_path, GetNativeWindow()); 1961 } else if (command == kTagActivate && type == shill::kTypeCellular) { 1962 ash::network_connect::ActivateCellular(service_path); 1963 // Activation may update network properties (e.g. ActivationState), so 1964 // request them here in case they change. 1965 UpdateConnectionData(service_path); 1966 } else { 1967 VLOG(1) << "Unknown command: " << command; 1968 NOTREACHED(); 1969 } 1970 } 1971 1972 void InternetOptionsHandler::AddConnection(const std::string& type) { 1973 if (type == shill::kTypeWifi) 1974 NetworkConfigView::ShowForType(shill::kTypeWifi, GetNativeWindow()); 1975 else if (type == shill::kTypeVPN) 1976 NetworkConfigView::ShowForType(shill::kTypeVPN, GetNativeWindow()); 1977 else if (type == shill::kTypeCellular) 1978 ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow()); 1979 else 1980 NOTREACHED(); 1981 } 1982 1983 base::ListValue* InternetOptionsHandler::GetWiredList() { 1984 base::ListValue* list = new base::ListValue(); 1985 const NetworkState* network = NetworkHandler::Get()->network_state_handler()-> 1986 FirstNetworkByType(NetworkTypePattern::Ethernet()); 1987 if (!network) 1988 return list; 1989 list->Append( 1990 BuildNetworkDictionary(network, 1991 web_ui()->GetDeviceScaleFactor(), 1992 Profile::FromWebUI(web_ui())->GetPrefs())); 1993 return list; 1994 } 1995 1996 base::ListValue* InternetOptionsHandler::GetWirelessList() { 1997 base::ListValue* list = new base::ListValue(); 1998 1999 NetworkStateHandler::NetworkStateList networks; 2000 NetworkHandler::Get()->network_state_handler()->GetNetworkListByType( 2001 NetworkTypePattern::Wireless(), &networks); 2002 for (NetworkStateHandler::NetworkStateList::const_iterator iter = 2003 networks.begin(); iter != networks.end(); ++iter) { 2004 list->Append( 2005 BuildNetworkDictionary(*iter, 2006 web_ui()->GetDeviceScaleFactor(), 2007 Profile::FromWebUI(web_ui())->GetPrefs())); 2008 } 2009 2010 return list; 2011 } 2012 2013 base::ListValue* InternetOptionsHandler::GetVPNList() { 2014 base::ListValue* list = new base::ListValue(); 2015 2016 NetworkStateHandler::NetworkStateList networks; 2017 NetworkHandler::Get()->network_state_handler()->GetNetworkListByType( 2018 NetworkTypePattern::VPN(), &networks); 2019 for (NetworkStateHandler::NetworkStateList::const_iterator iter = 2020 networks.begin(); iter != networks.end(); ++iter) { 2021 list->Append( 2022 BuildNetworkDictionary(*iter, 2023 web_ui()->GetDeviceScaleFactor(), 2024 Profile::FromWebUI(web_ui())->GetPrefs())); 2025 } 2026 2027 return list; 2028 } 2029 2030 base::ListValue* InternetOptionsHandler::GetRememberedList() { 2031 base::ListValue* list = new base::ListValue(); 2032 2033 NetworkStateHandler::FavoriteStateList favorites; 2034 NetworkHandler::Get()->network_state_handler()->GetFavoriteList(&favorites); 2035 for (NetworkStateHandler::FavoriteStateList::const_iterator iter = 2036 favorites.begin(); iter != favorites.end(); ++iter) { 2037 const FavoriteState* favorite = *iter; 2038 if (favorite->type() != shill::kTypeWifi && 2039 favorite->type() != shill::kTypeVPN) 2040 continue; 2041 list->Append( 2042 BuildFavoriteDictionary(favorite, 2043 web_ui()->GetDeviceScaleFactor(), 2044 Profile::FromWebUI(web_ui())->GetPrefs())); 2045 } 2046 2047 return list; 2048 } 2049 2050 void InternetOptionsHandler::FillNetworkInfo( 2051 base::DictionaryValue* dictionary) { 2052 NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler(); 2053 dictionary->Set(kTagWiredList, GetWiredList()); 2054 dictionary->Set(kTagWirelessList, GetWirelessList()); 2055 dictionary->Set(kTagVpnList, GetVPNList()); 2056 dictionary->Set(kTagRememberedList, GetRememberedList()); 2057 2058 dictionary->SetBoolean( 2059 kTagWifiAvailable, 2060 handler->IsTechnologyAvailable(NetworkTypePattern::WiFi())); 2061 dictionary->SetBoolean( 2062 kTagWifiEnabled, 2063 handler->IsTechnologyEnabled(NetworkTypePattern::WiFi())); 2064 2065 dictionary->SetBoolean( 2066 kTagCellularAvailable, 2067 handler->IsTechnologyAvailable(NetworkTypePattern::Mobile())); 2068 dictionary->SetBoolean( 2069 kTagCellularEnabled, 2070 handler->IsTechnologyEnabled(NetworkTypePattern::Mobile())); 2071 const DeviceState* cellular = 2072 handler->GetDeviceStateByType(NetworkTypePattern::Mobile()); 2073 dictionary->SetBoolean( 2074 kTagCellularSupportsScan, 2075 cellular && cellular->support_network_scan()); 2076 2077 dictionary->SetBoolean( 2078 kTagWimaxAvailable, 2079 handler->IsTechnologyAvailable(NetworkTypePattern::Wimax())); 2080 dictionary->SetBoolean( 2081 kTagWimaxEnabled, 2082 handler->IsTechnologyEnabled(NetworkTypePattern::Wimax())); 2083 } 2084 2085 } // namespace options 2086 } // namespace chromeos 2087
