Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1333)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/browser/ui/webui/options2/chromeos/internet_options_handler.cc

Issue 10837331: Options: s/options2/options/. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: wut Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « chrome/browser/ui/webui/options2/chromeos/internet_options_handler.h ('k') | chrome/browser/ui/webui/options2/chromeos/keyboard_handler.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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/options2/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 "base/base64.h"
16 #include "base/basictypes.h"
17 #include "base/bind.h"
18 #include "base/bind_helpers.h"
19 #include "base/command_line.h"
20 #include "base/i18n/time_formatting.h"
21 #include "base/json/json_writer.h"
22 #include "base/string16.h"
23 #include "base/string_number_conversions.h"
24 #include "base/stringprintf.h"
25 #include "base/time.h"
26 #include "base/utf_string_conversions.h"
27 #include "base/values.h"
28 #include "chrome/browser/browser_process.h"
29 #include "chrome/browser/chromeos/choose_mobile_network_dialog.h"
30 #include "chrome/browser/chromeos/cros/cros_library.h"
31 #include "chrome/browser/chromeos/cros/cros_network_functions.h"
32 #include "chrome/browser/chromeos/cros/network_library.h"
33 #include "chrome/browser/chromeos/cros/onc_constants.h"
34 #include "chrome/browser/chromeos/enrollment_dialog_view.h"
35 #include "chrome/browser/chromeos/mobile_config.h"
36 #include "chrome/browser/chromeos/options/network_config_view.h"
37 #include "chrome/browser/chromeos/proxy_config_service_impl.h"
38 #include "chrome/browser/chromeos/settings/cros_settings.h"
39 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
40 #include "chrome/browser/chromeos/status/network_menu_icon.h"
41 #include "chrome/browser/net/pref_proxy_config_tracker.h"
42 #include "chrome/browser/profiles/profile.h"
43 #include "chrome/browser/profiles/profile_manager.h"
44 #include "chrome/browser/ui/browser.h"
45 #include "chrome/browser/ui/browser_finder.h"
46 #include "chrome/browser/ui/browser_window.h"
47 #include "chrome/browser/ui/singleton_tabs.h"
48 #include "chrome/browser/ui/webui/web_ui_util.h"
49 #include "chrome/common/chrome_notification_types.h"
50 #include "chrome/common/chrome_switches.h"
51 #include "chrome/common/time_format.h"
52 #include "content/public/browser/notification_service.h"
53 #include "content/public/browser/web_contents.h"
54 #include "content/public/browser/web_ui.h"
55 #include "grit/chromium_strings.h"
56 #include "grit/generated_resources.h"
57 #include "grit/locale_settings.h"
58 #include "grit/theme_resources.h"
59 #include "third_party/cros_system_api/dbus/service_constants.h"
60 #include "ui/base/l10n/l10n_util.h"
61 #include "ui/base/layout.h"
62 #include "ui/base/resource/resource_bundle.h"
63 #include "ui/gfx/display.h"
64 #include "ui/gfx/image/image_skia.h"
65 #include "ui/gfx/screen.h"
66 #include "ui/views/widget/widget.h"
67
68 namespace {
69
70 static const char kOtherNetworksFakePath[] = "?";
71
72 // Keys for the network description dictionary passed to the web ui. Make sure
73 // to keep the strings in sync with what the JavaScript side uses.
74 const char kNetworkInfoKeyActivationState[] = "activation_state";
75 const char kNetworkInfoKeyConnectable[] = "connectable";
76 const char kNetworkInfoKeyConnected[] = "connected";
77 const char kNetworkInfoKeyConnecting[] = "connecting";
78 const char kNetworkInfoKeyIconURL[] = "iconURL";
79 const char kNetworkInfoKeyNeedsNewPlan[] = "needs_new_plan";
80 const char kNetworkInfoKeyNetworkName[] = "networkName";
81 const char kNetworkInfoKeyNetworkStatus[] = "networkStatus";
82 const char kNetworkInfoKeyNetworkType[] = "networkType";
83 const char kNetworkInfoKeyRemembered[] = "remembered";
84 const char kNetworkInfoKeyServicePath[] = "servicePath";
85 const char kNetworkInfoKeyPolicyManaged[] = "policyManaged";
86
87 // These are keys for getting IP information from the web ui.
88 const char kIpConfigAddress[] = "address";
89 const char kIpConfigPrefixLength[] = "prefixLength";
90 const char kIpConfigNetmask[] = "netmask";
91 const char kIpConfigGateway[] = "gateway";
92 const char kIpConfigNameServers[] = "nameServers";
93 const char kIpConfigAutoConfig[] = "ipAutoConfig";
94
95 // These are types of name server selections from the web ui.
96 const char kNameServerTypeAutomatic[] = "automatic";
97 const char kNameServerTypeGoogle[] = "google";
98 const char kNameServerTypeUser[] = "user";
99
100 // These are dictionary names used to send data to the web ui.
101 const char kDictionaryIpConfig[] = "ipconfig";
102 const char kDictionaryStaticIp[] = "staticIP";
103 const char kDictionarySavedIp[] = "savedIP";
104
105 // Google public name servers (DNS).
106 const char kGoogleNameServers[] = "8.8.4.4,8.8.8.8";
107
108 // Functions we call in JavaScript.
109 const char kRefreshNetworkDataFunction[] =
110 "options.network.NetworkList.refreshNetworkData";
111 const char kShowDetailedInfoFunction[] =
112 "options.internet.DetailsInternetPage.showDetailedInfo";
113 const char kUpdateCellularPlansFunction[] =
114 "options.internet.DetailsInternetPage.updateCellularPlans";
115 const char kUpdateSecurityTabFunction[] =
116 "options.internet.DetailsInternetPage.updateSecurityTab";
117
118 // These are used to register message handlers with JavaScript.
119 const char kBuyDataPlanMessage[] = "buyDataPlan";
120 const char kChangePinMessage[] = "changePin";
121 const char kDisableCellularMessage[] = "disableCellular";
122 const char kDisableWifiMessage[] = "disableWifi";
123 const char kDisableWimaxMessage[] = "disableWimax";
124 const char kEnableCellularMessage[] = "enableCellular";
125 const char kEnableWifiMessage[] = "enableWifi";
126 const char kEnableWimaxMessage[] = "enableWimax";
127 const char kNetworkCommandMessage[] = "networkCommand";
128 const char kRefreshCellularPlanMessage[] = "refreshCellularPlan";
129 const char kRefreshNetworksMessage[] = "refreshNetworks";
130 const char kSetApnMessage[] = "setApn";
131 const char kSetAutoConnectMessage[] = "setAutoConnect";
132 const char kSetIPConfigMessage[] = "setIPConfig";
133 const char kSetPreferNetworkMessage[] = "setPreferNetwork";
134 const char kSetSimCardLockMessage[] = "setSimCardLock";
135 const char kShowMorePlanInfoMessage[] = "showMorePlanInfo";
136
137 // These are strings used to communicate with JavaScript.
138 const char kTagAccessLocked[] = "accessLocked";
139 const char kTagActivate[] = "activate";
140 const char kTagActivated[] = "activated";
141 const char kTagActivationState[] = "activationState";
142 const char kTagAirplaneMode[] = "airplaneMode";
143 const char kTagApn[] = "apn";
144 const char kTagAutoConnect[] = "autoConnect";
145 const char kTagBssid[] = "bssid";
146 const char kTagCarrierUrl[] = "carrierUrl";
147 const char kTagCellularAvailable[] = "cellularAvailable";
148 const char kTagCellularBusy[] = "cellularBusy";
149 const char kTagCellularEnabled[] = "cellularEnabled";
150 const char kTagConnect[] = "connect";
151 const char kTagConnected[] = "connected";
152 const char kTagConnecting[] = "connecting";
153 const char kTagConnectionState[] = "connectionState";
154 const char kTagControlledBy[] = "controlledBy";
155 const char kTagDataRemaining[] = "dataRemaining";
156 const char kTagDefault[] = "default";
157 const char kTagDeviceConnected[] = "deviceConnected";
158 const char kTagDisconnect[] = "disconnect";
159 const char kTagEncryption[] = "encryption";
160 const char kTagErrorState[] = "errorState";
161 const char kTagEsn[] = "esn";
162 const char kTagFirmwareRevision[] = "firmwareRevision";
163 const char kTagForget[] = "forget";
164 const char kTagFrequency[] = "frequency";
165 const char kTagGsm[] = "gsm";
166 const char kTagHardwareAddress[] = "hardwareAddress";
167 const char kTagHardwareRevision[] = "hardwareRevision";
168 const char kTagIdentity[] = "identity";
169 const char kTagImei[] = "imei";
170 const char kTagImsi[] = "imsi";
171 const char kTagLanguage[] = "language";
172 const char kTagLastGoodApn[] = "lastGoodApn";
173 const char kTagLocalizedName[] = "localizedName";
174 const char kTagManufacturer[] = "manufacturer";
175 const char kTagMdn[] = "mdn";
176 const char kTagMeid[] = "meid";
177 const char kTagMin[] = "min";
178 const char kTagModelId[] = "modelId";
179 const char kTagName[] = "name";
180 const char kTagNameServersGoogle[] = "nameServersGoogle";
181 const char kTagNameServerType[] = "nameServerType";
182 const char kTagNeedsPlan[] = "needsPlan";
183 const char kTagNetworkId[] = "networkId";
184 const char kTagNetworkName[] = "networkName";
185 const char kTagNetworkTechnology[] = "networkTechnology";
186 const char kTagOperatorCode[] = "operatorCode";
187 const char kTagOperatorName[] = "operatorName";
188 const char kTagOptions[] = "options";
189 const char kTagPassword[] = "password";
190 const char kTagPlanExpires[] = "planExpires";
191 const char kTagPlans[] = "plans";
192 const char kTagPlanSummary[] = "planSummary";
193 const char kTagPlanType[] = "planType";
194 const char kTagPolicy[] = "policy";
195 const char kTagPreferred[] = "preferred";
196 const char kTagPrlVersion[] = "prlVersion";
197 const char kTagProvider_type[] = "provider_type";
198 const char kTagProviderApnList[] = "providerApnList";
199 const char kTagRecommended[] = "recommended";
200 const char kTagRemembered[] = "remembered";
201 const char kTagRememberedList[] = "rememberedList";
202 const char kTagRestrictedPool[] = "restrictedPool";
203 const char kTagRoamingState[] = "roamingState";
204 const char kTagServer_hostname[] = "server_hostname";
205 const char kTagService_name[] = "service_name";
206 const char kTagServiceName[] = "serviceName";
207 const char kTagServicePath[] = "servicePath";
208 const char kTagShared[] = "shared";
209 const char kTagShowActivateButton[] = "showActivateButton";
210 const char kTagShowBuyButton[] = "showBuyButton";
211 const char kTagShowPreferred[] = "showPreferred";
212 const char kTagShowProxy[] = "showProxy";
213 const char kTagShowStaticIPConfig[] = "showStaticIPConfig";
214 const char kTagShowViewAccountButton[] = "showViewAccountButton";
215 const char kTagSimCardLockEnabled[] = "simCardLockEnabled";
216 const char kTagSsid[] = "ssid";
217 const char kTagStrength[] = "strength";
218 const char kTagSupportUrl[] = "supportUrl";
219 const char kTagTrue[] = "true";
220 const char kTagType[] = "type";
221 const char kTagUsername[] = "username";
222 const char kTagValue[] = "value";
223 const char kTagVpnList[] = "vpnList";
224 const char kTagWarning[] = "warning";
225 const char kTagWifiAvailable[] = "wifiAvailable";
226 const char kTagWifiBusy[] = "wifiBusy";
227 const char kTagWifiEnabled[] = "wifiEnabled";
228 const char kTagWimaxAvailable[] = "wimaxAvailable";
229 const char kTagWimaxBusy[] = "wimaxBusy";
230 const char kTagWimaxEnabled[] = "wimaxEnabled";
231 const char kTagWiredList[] = "wiredList";
232 const char kTagWirelessList[] = "wirelessList";
233 const char kToggleAirplaneModeMessage[] = "toggleAirplaneMode";
234
235 // A helper class for building network information dictionaries to be sent to
236 // the webui code.
237 class NetworkInfoDictionary {
238 public:
239 // Initializes the dictionary with default values.
240 explicit NetworkInfoDictionary(float icon_scale);
241
242 // Copies in service path, connect{ing|ed|able} flags and connection type from
243 // the provided network object. Also chooses an appropriate icon based on the
244 // network type.
245 NetworkInfoDictionary(const chromeos::Network* network,
246 float icon_scale);
247
248 // Initializes a remembered network entry, pulling information from the passed
249 // network object and the corresponding remembered network object. |network|
250 // may be NULL.
251 NetworkInfoDictionary(const chromeos::Network* network,
252 const chromeos::Network* remembered,
253 float icon_scale);
254
255 // Setters for filling in information.
256 void set_service_path(const std::string& service_path) {
257 service_path_ = service_path;
258 }
259 void set_icon(const gfx::ImageSkia& icon) {
260 gfx::ImageSkiaRep image_rep = icon.GetRepresentation(icon_scale_factor_);
261 icon_url_ = icon.isNull() ? "" : web_ui_util::GetImageDataUrl(
262 image_rep.sk_bitmap());
263 }
264 void set_name(const std::string& name) {
265 name_ = name;
266 }
267 void set_connecting(bool connecting) {
268 connecting_ = connecting;
269 }
270 void set_connected(bool connected) {
271 connected_ = connected;
272 }
273 void set_connectable(bool connectable) {
274 connectable_ = connectable;
275 }
276 void set_connection_type(chromeos::ConnectionType connection_type) {
277 connection_type_ = connection_type;
278 }
279 void set_remembered(bool remembered) {
280 remembered_ = remembered;
281 }
282 void set_shared(bool shared) {
283 shared_ = shared;
284 }
285 void set_activation_state(chromeos::ActivationState activation_state) {
286 activation_state_ = activation_state;
287 }
288 void set_needs_new_plan(bool needs_new_plan) {
289 needs_new_plan_ = needs_new_plan;
290 }
291 void set_policy_managed(bool policy_managed) {
292 policy_managed_ = policy_managed;
293 }
294
295 // Builds the DictionaryValue representation from the previously set
296 // parameters. Ownership of the returned pointer is transferred to the caller.
297 DictionaryValue* BuildDictionary();
298
299 private:
300 // Values to be filled into the dictionary.
301 std::string service_path_;
302 std::string icon_url_;
303 std::string name_;
304 bool connecting_;
305 bool connected_;
306 bool connectable_;
307 chromeos::ConnectionType connection_type_;
308 bool remembered_;
309 bool shared_;
310 chromeos::ActivationState activation_state_;
311 bool needs_new_plan_;
312 bool policy_managed_;
313 ui::ScaleFactor icon_scale_factor_;
314
315 DISALLOW_COPY_AND_ASSIGN(NetworkInfoDictionary);
316 };
317
318 NetworkInfoDictionary::NetworkInfoDictionary(
319 float icon_scale)
320 : icon_scale_factor_(ui::GetScaleFactorFromScale(icon_scale)) {
321 set_connecting(false);
322 set_connected(false);
323 set_connectable(false);
324 set_remembered(false);
325 set_shared(false);
326 set_activation_state(chromeos::ACTIVATION_STATE_UNKNOWN);
327 set_needs_new_plan(false);
328 set_policy_managed(false);
329 }
330
331 NetworkInfoDictionary::NetworkInfoDictionary(const chromeos::Network* network,
332 float icon_scale)
333 : icon_scale_factor_(ui::GetScaleFactorFromScale(icon_scale)) {
334 set_service_path(network->service_path());
335 set_icon(chromeos::NetworkMenuIcon::GetImage(network,
336 chromeos::NetworkMenuIcon::COLOR_DARK));
337 set_name(network->name());
338 set_connecting(network->connecting());
339 set_connected(network->connected());
340 set_connectable(network->connectable());
341 set_connection_type(network->type());
342 set_remembered(false);
343 set_shared(false);
344 set_needs_new_plan(false);
345 set_policy_managed(network->ui_data().is_managed());
346 }
347
348 NetworkInfoDictionary::NetworkInfoDictionary(
349 const chromeos::Network* network,
350 const chromeos::Network* remembered,
351 float icon_scale)
352 : icon_scale_factor_(ui::GetScaleFactorFromScale(icon_scale)) {
353 set_service_path(remembered->service_path());
354 set_icon(chromeos::NetworkMenuIcon::GetImage(
355 network ? network : remembered, chromeos::NetworkMenuIcon::COLOR_DARK));
356 set_name(remembered->name());
357 set_connecting(network ? network->connecting() : false);
358 set_connected(network ? network->connected() : false);
359 set_connectable(true);
360 set_connection_type(remembered->type());
361 set_remembered(true);
362 set_shared(remembered->profile_type() == chromeos::PROFILE_SHARED);
363 set_needs_new_plan(false);
364 set_policy_managed(remembered->ui_data().is_managed());
365 }
366
367 DictionaryValue* NetworkInfoDictionary::BuildDictionary() {
368 std::string status;
369
370 if (remembered_) {
371 if (shared_)
372 status = l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_SHARED_NETWORK);
373 } else {
374 // 802.1X networks can be connected but not have saved credentials, and
375 // hence be "not configured". Give preference to the "connected" and
376 // "connecting" states. http://crosbug.com/14459
377 int connection_state = IDS_STATUSBAR_NETWORK_DEVICE_DISCONNECTED;
378 if (connected_)
379 connection_state = IDS_STATUSBAR_NETWORK_DEVICE_CONNECTED;
380 else if (connecting_)
381 connection_state = IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING;
382 else if (!connectable_)
383 connection_state = IDS_STATUSBAR_NETWORK_DEVICE_NOT_CONFIGURED;
384 status = l10n_util::GetStringUTF8(connection_state);
385 if (connection_type_ == chromeos::TYPE_CELLULAR) {
386 if (needs_new_plan_) {
387 status = l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_NO_PLAN_LABEL);
388 } else if (activation_state_ != chromeos::ACTIVATION_STATE_ACTIVATED) {
389 status.append(" / ");
390 status.append(chromeos::CellularNetwork::ActivationStateToString(
391 activation_state_));
392 }
393 }
394 }
395
396 scoped_ptr<DictionaryValue> network_info(new DictionaryValue());
397 network_info->SetInteger(kNetworkInfoKeyActivationState,
398 static_cast<int>(activation_state_));
399 network_info->SetBoolean(kNetworkInfoKeyConnectable, connectable_);
400 network_info->SetBoolean(kNetworkInfoKeyConnected, connected_);
401 network_info->SetBoolean(kNetworkInfoKeyConnecting, connecting_);
402 network_info->SetString(kNetworkInfoKeyIconURL, icon_url_);
403 network_info->SetBoolean(kNetworkInfoKeyNeedsNewPlan, needs_new_plan_);
404 network_info->SetString(kNetworkInfoKeyNetworkName, name_);
405 network_info->SetString(kNetworkInfoKeyNetworkStatus, status);
406 network_info->SetInteger(kNetworkInfoKeyNetworkType,
407 static_cast<int>(connection_type_));
408 network_info->SetBoolean(kNetworkInfoKeyRemembered, remembered_);
409 network_info->SetString(kNetworkInfoKeyServicePath, service_path_);
410 network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, policy_managed_);
411 return network_info.release();
412 }
413
414 // Pulls IP information out of a shill service properties dictionary. If
415 // |static_ip| is true, then it fetches "StaticIP.*" properties. If not, then it
416 // fetches "SavedIP.*" properties. Caller must take ownership of returned
417 // dictionary. If non-NULL, |ip_parameters_set| returns a count of the number
418 // of IP routing parameters that get set.
419 DictionaryValue* BuildIPInfoDictionary(const DictionaryValue& shill_properties,
420 bool static_ip,
421 int* routing_parameters_set) {
422 std::string address_key;
423 std::string prefix_len_key;
424 std::string gateway_key;
425 std::string name_servers_key;
426 if (static_ip) {
427 address_key = shill::kStaticIPAddressProperty;
428 prefix_len_key = shill::kStaticIPPrefixlenProperty;
429 gateway_key = shill::kStaticIPGatewayProperty;
430 name_servers_key = shill::kStaticIPNameServersProperty;
431 } else {
432 address_key = shill::kSavedIPAddressProperty;
433 prefix_len_key = shill::kSavedIPPrefixlenProperty;
434 gateway_key = shill::kSavedIPGatewayProperty;
435 name_servers_key = shill::kSavedIPNameServersProperty;
436 }
437
438 scoped_ptr<DictionaryValue> ip_info_dict(new DictionaryValue);
439 std::string address;
440 int routing_parameters = 0;
441 if (shill_properties.GetStringWithoutPathExpansion(address_key, &address)) {
442 ip_info_dict->SetString(kIpConfigAddress, address);
443 VLOG(2) << "Found " << address_key << ": " << address;
444 routing_parameters++;
445 }
446 int prefix_len = -1;
447 if (shill_properties.GetIntegerWithoutPathExpansion(
448 prefix_len_key, &prefix_len)) {
449 ip_info_dict->SetInteger(kIpConfigPrefixLength, prefix_len);
450 ip_info_dict->SetString(kIpConfigNetmask,
451 chromeos::CrosPrefixLengthToNetmask(prefix_len));
452 VLOG(2) << "Found " << prefix_len_key << ": "
453 << prefix_len
454 << " (" << chromeos::CrosPrefixLengthToNetmask(prefix_len) << ")";
455 routing_parameters++;
456 }
457 std::string gateway;
458 if (shill_properties.GetStringWithoutPathExpansion(gateway_key, &gateway)) {
459 ip_info_dict->SetString(kIpConfigGateway, gateway);
460 VLOG(2) << "Found " << gateway_key << ": " << gateway;
461 routing_parameters++;
462 }
463 if (routing_parameters_set)
464 *routing_parameters_set = routing_parameters;
465
466 std::string name_servers;
467 if (shill_properties.GetStringWithoutPathExpansion(
468 name_servers_key, &name_servers)) {
469 ip_info_dict->SetString(kIpConfigNameServers, name_servers);
470 VLOG(2) << "Found " << name_servers_key << ": " << name_servers;
471 }
472
473 return ip_info_dict.release();
474 }
475
476 } // namespace
477
478 namespace options {
479
480 InternetOptionsHandler::InternetOptionsHandler()
481 : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
482 registrar_.Add(this, chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED,
483 content::NotificationService::AllSources());
484 registrar_.Add(this, chrome::NOTIFICATION_ENTER_PIN_ENDED,
485 content::NotificationService::AllSources());
486 cros_ = chromeos::CrosLibrary::Get()->GetNetworkLibrary();
487 if (cros_) {
488 cros_->AddNetworkManagerObserver(this);
489 cros_->AddCellularDataPlanObserver(this);
490 MonitorNetworks();
491 }
492 }
493
494 InternetOptionsHandler::~InternetOptionsHandler() {
495 if (cros_) {
496 cros_->RemoveNetworkManagerObserver(this);
497 cros_->RemoveCellularDataPlanObserver(this);
498 cros_->RemoveObserverForAllNetworks(this);
499 }
500 }
501
502 void InternetOptionsHandler::GetLocalizedValues(
503 DictionaryValue* localized_strings) {
504 DCHECK(localized_strings);
505
506 static OptionsStringResource resources[] = {
507
508 // Main settings page.
509
510 { "ethernetTitle", IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET },
511 { "wifiTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_WIFI_NETWORK },
512 // TODO(zelidrag): Change details title to Wimax once we get strings.
513 { "wimaxTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_CELLULAR_NETWORK },
514 { "cellularTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_CELLULAR_NETWORK },
515 { "vpnTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_PRIVATE_NETWORK },
516 { "airplaneModeTitle", IDS_OPTIONS_SETTINGS_SECTION_TITLE_AIRPLANE_MODE },
517 { "airplaneModeLabel", IDS_OPTIONS_SETTINGS_NETWORK_AIRPLANE_MODE_LABEL },
518 { "networkNotConnected", IDS_OPTIONS_SETTINGS_NETWORK_NOT_CONNECTED },
519 { "networkConnected", IDS_CHROMEOS_NETWORK_STATE_READY },
520 { "joinOtherNetwork", IDS_OPTIONS_SETTINGS_NETWORK_OTHER },
521 { "networkOffline", IDS_OPTIONS_SETTINGS_NETWORK_OFFLINE },
522 { "networkDisabled", IDS_OPTIONS_SETTINGS_NETWORK_DISABLED },
523 { "networkOnline", IDS_OPTIONS_SETTINGS_NETWORK_ONLINE },
524 { "networkOptions", IDS_OPTIONS_SETTINGS_NETWORK_OPTIONS },
525 { "turnOffWifi", IDS_OPTIONS_SETTINGS_NETWORK_DISABLE_WIFI },
526 { "turnOffCellular", IDS_OPTIONS_SETTINGS_NETWORK_DISABLE_CELLULAR },
527 { "disconnectNetwork", IDS_OPTIONS_SETTINGS_DISCONNECT },
528 { "preferredNetworks", IDS_OPTIONS_SETTINGS_PREFERRED_NETWORKS_LABEL },
529 { "preferredNetworksPage", IDS_OPTIONS_SETTINGS_PREFERRED_NETWORKS_TITLE },
530 { "useSharedProxies", IDS_OPTIONS_SETTINGS_USE_SHARED_PROXIES },
531 { "addConnectionTitle",
532 IDS_OPTIONS_SETTINGS_SECTION_TITLE_ADD_CONNECTION },
533 { "addConnectionWifi", IDS_OPTIONS_SETTINGS_ADD_CONNECTION_WIFI },
534 { "addConnectionVPN", IDS_STATUSBAR_NETWORK_ADD_VPN },
535 { "enableDataRoaming", IDS_OPTIONS_SETTINGS_ENABLE_DATA_ROAMING },
536 { "disableDataRoaming", IDS_OPTIONS_SETTINGS_DISABLE_DATA_ROAMING },
537 { "dataRoamingDisableToggleTooltip",
538 IDS_OPTIONS_SETTINGS_TOGGLE_DATA_ROAMING_RESTRICTION },
539 { "activateNetwork", IDS_STATUSBAR_NETWORK_DEVICE_ACTIVATE },
540
541 // Internet details dialog.
542
543 { "changeProxyButton",
544 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CHANGE_PROXY_BUTTON },
545 { "managedNetwork", IDS_OPTIONS_SETTINGS_MANAGED_NETWORK },
546 { "wifiNetworkTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_CONNECTION },
547 { "vpnTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_VPN },
548 { "cellularPlanTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_PLAN },
549 { "cellularConnTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_CONNECTION },
550 { "cellularDeviceTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_DEVICE },
551 { "networkTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_NETWORK },
552 { "securityTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_SECURITY },
553 { "proxyTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_PROXY },
554 { "connectionState", IDS_OPTIONS_SETTINGS_INTERNET_CONNECTION_STATE },
555 { "inetAddress", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_ADDRESS },
556 { "inetNetmask", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SUBNETMASK },
557 { "inetGateway", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_GATEWAY },
558 { "inetNameServers", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_DNSSERVER },
559 { "ipAutomaticConfiguration",
560 IDS_OPTIONS_SETTINGS_INTERNET_IP_AUTOMATIC_CONFIGURATION },
561 { "automaticNameServers",
562 IDS_OPTIONS_SETTINGS_INTERNET_AUTOMATIC_NAME_SERVERS },
563 { "userNameServer1", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_1 },
564 { "userNameServer2", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_2 },
565 { "userNameServer3", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_3 },
566 { "userNameServer4", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVER_4 },
567 { "googleNameServers", IDS_OPTIONS_SETTINGS_INTERNET_GOOGLE_NAME_SERVERS },
568 { "userNameServers", IDS_OPTIONS_SETTINGS_INTERNET_USER_NAME_SERVERS },
569 { "hardwareAddress",
570 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_HARDWARE_ADDRESS },
571 { "detailsInternetDismiss", IDS_CLOSE },
572 { "activateButton", IDS_OPTIONS_SETTINGS_ACTIVATE },
573 { "buyplanButton", IDS_OPTIONS_SETTINGS_BUY_PLAN },
574 { "connectButton", IDS_OPTIONS_SETTINGS_CONNECT },
575 { "disconnectButton", IDS_OPTIONS_SETTINGS_DISCONNECT },
576 { "viewAccountButton", IDS_STATUSBAR_NETWORK_VIEW_ACCOUNT },
577
578 // TODO(zelidrag): Change details title to Wimax once we get strings.
579 { "wimaxConnTabLabel", IDS_OPTIONS_SETTINGS_INTERNET_TAB_CONNECTION },
580
581 // Wifi Tab.
582
583 { "accessLockedMsg", IDS_STATUSBAR_NETWORK_LOCKED },
584 { "inetSsid", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_ID },
585 { "inetBssid", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_BSSID },
586 { "inetEncryption",
587 IDS_OPTIONS_SETTIGNS_INTERNET_OPTIONS_NETWORK_ENCRYPTION },
588 { "inetFrequency",
589 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_FREQUENCY },
590 { "inetFrequencyFormat",
591 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_FREQUENCY_MHZ },
592 { "inetSignalStrength",
593 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_STRENGTH },
594 { "inetSignalStrengthFormat",
595 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_STRENGTH_PERCENTAGE },
596 { "inetPassProtected",
597 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NET_PROTECTED },
598 { "inetNetworkShared",
599 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_SHARED },
600 { "inetPreferredNetwork",
601 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PREFER_NETWORK },
602 { "inetAutoConnectNetwork",
603 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_AUTO_CONNECT },
604 { "inetLogin", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_LOGIN },
605 { "inetShowPass", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SHOWPASSWORD },
606 { "inetPassPrompt", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PASSWORD },
607 { "inetSsidPrompt", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SSID },
608 { "inetStatus", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_STATUS_TITLE },
609 { "inetConnect", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CONNECT_TITLE },
610
611 // VPN Tab.
612
613 { "inetServiceName",
614 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_SERVICE_NAME },
615 { "inetServerHostname",
616 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_SERVER_HOSTNAME },
617 { "inetProviderType",
618 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_PROVIDER_TYPE },
619 { "inetUsername", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_VPN_USERNAME },
620
621 // Cellular Tab.
622
623 { "serviceName", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_SERVICE_NAME },
624 { "networkTechnology",
625 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_NETWORK_TECHNOLOGY },
626 { "operatorName", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_OPERATOR },
627 { "operatorCode", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_OPERATOR_CODE },
628 { "activationState",
629 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ACTIVATION_STATE },
630 { "roamingState", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ROAMING_STATE },
631 { "restrictedPool",
632 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_RESTRICTED_POOL },
633 { "errorState", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ERROR_STATE },
634 { "manufacturer", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_MANUFACTURER },
635 { "modelId", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_MODEL_ID },
636 { "firmwareRevision",
637 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_FIRMWARE_REVISION },
638 { "hardwareRevision",
639 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_HARDWARE_REVISION },
640 { "prlVersion", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_PRL_VERSION },
641 { "cellularApnLabel", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN },
642 { "cellularApnOther", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_OTHER },
643 { "cellularApnUsername",
644 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_USERNAME },
645 { "cellularApnPassword",
646 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_PASSWORD },
647 { "cellularApnUseDefault",
648 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_CLEAR },
649 { "cellularApnSet", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_SET },
650 { "cellularApnCancel", IDS_CANCEL },
651
652 // Security Tab.
653
654 { "accessSecurityTabLink",
655 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ACCESS_SECURITY_TAB },
656 { "lockSimCard", IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_LOCK_SIM_CARD },
657 { "changePinButton",
658 IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_CHANGE_PIN_BUTTON },
659
660 // Plan Tab.
661
662 { "planName", IDS_OPTIONS_SETTINGS_INTERNET_CELL_PLAN_NAME },
663 { "planLoading", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_LOADING_PLAN },
664 { "noPlansFound", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NO_PLANS_FOUND },
665 { "purchaseMore", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PURCHASE_MORE },
666 { "dataRemaining", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_DATA_REMAINING },
667 { "planExpires", IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EXPIRES },
668 { "showPlanNotifications",
669 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SHOW_MOBILE_NOTIFICATION },
670 { "autoconnectCellular",
671 IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_AUTO_CONNECT }
672 };
673
674 RegisterStrings(localized_strings, resources, arraysize(resources));
675
676 std::string owner;
677 chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
678 localized_strings->SetString("ownerUserId", UTF8ToUTF16(owner));
679
680 DictionaryValue* network_dictionary = new DictionaryValue;
681 FillNetworkInfo(network_dictionary);
682 localized_strings->Set("networkData", network_dictionary);
683 }
684
685 void InternetOptionsHandler::InitializePage() {
686 cros_->RequestNetworkScan();
687 }
688
689 void InternetOptionsHandler::RegisterMessages() {
690 // Setup handlers specific to this panel.
691 web_ui()->RegisterMessageCallback(kNetworkCommandMessage,
692 base::Bind(&InternetOptionsHandler::NetworkCommandCallback,
693 base::Unretained(this)));
694 web_ui()->RegisterMessageCallback(kRefreshNetworksMessage,
695 base::Bind(&InternetOptionsHandler::RefreshNetworksCallback,
696 base::Unretained(this)));
697 web_ui()->RegisterMessageCallback(kRefreshCellularPlanMessage,
698 base::Bind(&InternetOptionsHandler::RefreshCellularPlanCallback,
699 base::Unretained(this)));
700 web_ui()->RegisterMessageCallback(kSetPreferNetworkMessage,
701 base::Bind(&InternetOptionsHandler::SetPreferNetworkCallback,
702 base::Unretained(this)));
703 web_ui()->RegisterMessageCallback(kSetAutoConnectMessage,
704 base::Bind(&InternetOptionsHandler::SetAutoConnectCallback,
705 base::Unretained(this)));
706 web_ui()->RegisterMessageCallback(kSetIPConfigMessage,
707 base::Bind(&InternetOptionsHandler::SetIPConfigCallback,
708 base::Unretained(this)));
709 web_ui()->RegisterMessageCallback(kEnableWifiMessage,
710 base::Bind(&InternetOptionsHandler::EnableWifiCallback,
711 base::Unretained(this)));
712 web_ui()->RegisterMessageCallback(kDisableWifiMessage,
713 base::Bind(&InternetOptionsHandler::DisableWifiCallback,
714 base::Unretained(this)));
715 web_ui()->RegisterMessageCallback(kEnableCellularMessage,
716 base::Bind(&InternetOptionsHandler::EnableCellularCallback,
717 base::Unretained(this)));
718 web_ui()->RegisterMessageCallback(kDisableCellularMessage,
719 base::Bind(&InternetOptionsHandler::DisableCellularCallback,
720 base::Unretained(this)));
721 web_ui()->RegisterMessageCallback(kEnableWimaxMessage,
722 base::Bind(&InternetOptionsHandler::EnableWimaxCallback,
723 base::Unretained(this)));
724 web_ui()->RegisterMessageCallback(kDisableWimaxMessage,
725 base::Bind(&InternetOptionsHandler::DisableWimaxCallback,
726 base::Unretained(this)));
727 web_ui()->RegisterMessageCallback(kBuyDataPlanMessage,
728 base::Bind(&InternetOptionsHandler::BuyDataPlanCallback,
729 base::Unretained(this)));
730 web_ui()->RegisterMessageCallback(kShowMorePlanInfoMessage,
731 base::Bind(&InternetOptionsHandler::ShowMorePlanInfoCallback,
732 base::Unretained(this)));
733 web_ui()->RegisterMessageCallback(kSetApnMessage,
734 base::Bind(&InternetOptionsHandler::SetApnCallback,
735 base::Unretained(this)));
736 web_ui()->RegisterMessageCallback(kSetSimCardLockMessage,
737 base::Bind(&InternetOptionsHandler::SetSimCardLockCallback,
738 base::Unretained(this)));
739 web_ui()->RegisterMessageCallback(kChangePinMessage,
740 base::Bind(&InternetOptionsHandler::ChangePinCallback,
741 base::Unretained(this)));
742 web_ui()->RegisterMessageCallback(kToggleAirplaneModeMessage,
743 base::Bind(&InternetOptionsHandler::ToggleAirplaneModeCallback,
744 base::Unretained(this)));
745 }
746
747 void InternetOptionsHandler::EnableWifiCallback(const ListValue* args) {
748 cros_->EnableWifiNetworkDevice(true);
749 }
750
751 void InternetOptionsHandler::DisableWifiCallback(const ListValue* args) {
752 cros_->EnableWifiNetworkDevice(false);
753 }
754
755 void InternetOptionsHandler::EnableCellularCallback(const ListValue* args) {
756 // TODO(nkostylev): Code duplication, see NetworkMenu::ToggleCellular().
757 const chromeos::NetworkDevice* mobile = cros_->FindMobileDevice();
758 if (!mobile) {
759 LOG(ERROR) << "Didn't find mobile device, it should have been available.";
760 cros_->EnableCellularNetworkDevice(true);
761 } else if (!mobile->is_sim_locked()) {
762 if (mobile->is_sim_absent()) {
763 std::string setup_url;
764 chromeos::MobileConfig* config = chromeos::MobileConfig::GetInstance();
765 if (config->IsReady()) {
766 const chromeos::MobileConfig::LocaleConfig* locale_config =
767 config->GetLocaleConfig();
768 if (locale_config)
769 setup_url = locale_config->setup_url();
770 }
771 if (!setup_url.empty()) {
772 chrome::ShowSingletonTab(GetAppropriateBrowser(), GURL(setup_url));
773 } else {
774 // TODO(nkostylev): Show generic error message. http://crosbug.com/15444
775 }
776 } else {
777 cros_->EnableCellularNetworkDevice(true);
778 }
779 } else {
780 chromeos::SimDialogDelegate::ShowDialog(GetNativeWindow(),
781 chromeos::SimDialogDelegate::SIM_DIALOG_UNLOCK);
782 }
783 }
784
785 void InternetOptionsHandler::DisableCellularCallback(const ListValue* args) {
786 cros_->EnableCellularNetworkDevice(false);
787 }
788
789 void InternetOptionsHandler::EnableWimaxCallback(const ListValue* args) {
790 cros_->EnableWimaxNetworkDevice(true);
791 }
792
793 void InternetOptionsHandler::DisableWimaxCallback(const ListValue* args) {
794 cros_->EnableWimaxNetworkDevice(false);
795 }
796
797 void InternetOptionsHandler::ShowMorePlanInfoCallback(const ListValue* args) {
798 if (!web_ui())
799 return;
800
801 const chromeos::CellularNetwork* cellular = cros_->cellular_network();
802 if (!cellular)
803 return;
804
805 web_ui()->GetWebContents()->OpenURL(content::OpenURLParams(
806 cellular->GetAccountInfoUrl(), content::Referrer(),
807 NEW_FOREGROUND_TAB,
808 content::PAGE_TRANSITION_LINK, false));
809 }
810
811 void InternetOptionsHandler::BuyDataPlanCallback(const ListValue* args) {
812 if (!web_ui())
813 return;
814
815 std::string service_path;
816 if (args->GetSize() != 1 || !args->GetString(0, &service_path)) {
817 NOTREACHED();
818 return;
819 }
820 ash::Shell::GetInstance()->delegate()->OpenMobileSetup(service_path);
821 }
822
823 void InternetOptionsHandler::SetApnCallback(const ListValue* args) {
824 std::string service_path;
825 std::string apn;
826 std::string username;
827 std::string password;
828 if (args->GetSize() != 4 ||
829 !args->GetString(0, &service_path) ||
830 !args->GetString(1, &apn) ||
831 !args->GetString(2, &username) ||
832 !args->GetString(3, &password)) {
833 NOTREACHED();
834 return;
835 }
836
837 chromeos::CellularNetwork* network =
838 cros_->FindCellularNetworkByPath(service_path);
839 if (network) {
840 network->SetApn(chromeos::CellularApn(
841 apn, network->apn().network_id, username, password));
842 }
843 }
844
845 void InternetOptionsHandler::SetSimCardLockCallback(const ListValue* args) {
846 bool require_pin_new_value;
847 if (!args->GetBoolean(0, &require_pin_new_value)) {
848 NOTREACHED();
849 return;
850 }
851 // 1. Bring up SIM unlock dialog, pass new RequirePin setting in URL.
852 // 2. Dialog will ask for current PIN in any case.
853 // 3. If card is locked it will first call PIN unlock operation
854 // 4. Then it will call Set RequirePin, passing the same PIN.
855 // 5. We'll get notified by REQUIRE_PIN_SETTING_CHANGE_ENDED notification.
856 chromeos::SimDialogDelegate::SimDialogMode mode;
857 if (require_pin_new_value)
858 mode = chromeos::SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON;
859 else
860 mode = chromeos::SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF;
861 chromeos::SimDialogDelegate::ShowDialog(GetNativeWindow(), mode);
862 }
863
864 void InternetOptionsHandler::ChangePinCallback(const ListValue* args) {
865 chromeos::SimDialogDelegate::ShowDialog(GetNativeWindow(),
866 chromeos::SimDialogDelegate::SIM_DIALOG_CHANGE_PIN);
867 }
868
869 void InternetOptionsHandler::RefreshNetworksCallback(const ListValue* args) {
870 cros_->RequestNetworkScan();
871 }
872
873 void InternetOptionsHandler::RefreshNetworkData() {
874 DictionaryValue dictionary;
875 FillNetworkInfo(&dictionary);
876 web_ui()->CallJavascriptFunction(
877 kRefreshNetworkDataFunction, dictionary);
878 }
879
880 void InternetOptionsHandler::OnNetworkManagerChanged(
881 chromeos::NetworkLibrary* cros) {
882 if (!web_ui())
883 return;
884 MonitorNetworks();
885 RefreshNetworkData();
886 }
887
888 void InternetOptionsHandler::OnNetworkChanged(
889 chromeos::NetworkLibrary* cros,
890 const chromeos::Network* network) {
891 if (web_ui())
892 RefreshNetworkData();
893 }
894
895 // Monitor wireless networks for changes. It is only necessary
896 // to set up individual observers for the cellular networks
897 // (if any) and for the connected Wi-Fi network (if any). The
898 // only change we are interested in for Wi-Fi networks is signal
899 // strength. For non-connected Wi-Fi networks, all information is
900 // reported via scan results, which trigger network manager
901 // updates. Only the connected Wi-Fi network has changes reported
902 // via service property updates.
903 void InternetOptionsHandler::MonitorNetworks() {
904 cros_->RemoveObserverForAllNetworks(this);
905 const chromeos::WifiNetwork* wifi_network = cros_->wifi_network();
906 if (wifi_network)
907 cros_->AddNetworkObserver(wifi_network->service_path(), this);
908
909 // Always monitor all mobile networks, if any, so that changes
910 // in network technology, roaming status, and signal strength
911 // will be shown.
912 const chromeos::WimaxNetworkVector& wimax_networks =
913 cros_->wimax_networks();
914 for (size_t i = 0; i < wimax_networks.size(); ++i) {
915 chromeos::WimaxNetwork* wimax_network = wimax_networks[i];
916 cros_->AddNetworkObserver(wimax_network->service_path(), this);
917 }
918 const chromeos::CellularNetworkVector& cell_networks =
919 cros_->cellular_networks();
920 for (size_t i = 0; i < cell_networks.size(); ++i) {
921 chromeos::CellularNetwork* cell_network = cell_networks[i];
922 cros_->AddNetworkObserver(cell_network->service_path(), this);
923 }
924 const chromeos::VirtualNetwork* virtual_network = cros_->virtual_network();
925 if (virtual_network)
926 cros_->AddNetworkObserver(virtual_network->service_path(), this);
927 }
928
929 void InternetOptionsHandler::OnCellularDataPlanChanged(
930 chromeos::NetworkLibrary* cros) {
931 if (!web_ui())
932 return;
933 const chromeos::CellularNetwork* cellular = cros_->cellular_network();
934 if (!cellular)
935 return;
936 const chromeos::CellularDataPlanVector* plans =
937 cros_->GetDataPlans(cellular->service_path());
938 DictionaryValue connection_plans;
939 ListValue* plan_list = new ListValue();
940 if (plans) {
941 for (chromeos::CellularDataPlanVector::const_iterator iter = plans->begin();
942 iter != plans->end(); ++iter) {
943 plan_list->Append(CellularDataPlanToDictionary(*iter));
944 }
945 }
946 connection_plans.SetString(kTagServicePath, cellular->service_path());
947 connection_plans.SetBoolean(kTagNeedsPlan, cellular->needs_new_plan());
948 connection_plans.SetBoolean(kTagActivated,
949 cellular->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATED);
950 connection_plans.Set(kTagPlans, plan_list);
951 SetActivationButtonVisibility(cellular,
952 &connection_plans,
953 cros_->GetCellularHomeCarrierId());
954 web_ui()->CallJavascriptFunction(
955 kUpdateCellularPlansFunction,
956 connection_plans);
957 }
958
959
960 void InternetOptionsHandler::Observe(
961 int type,
962 const content::NotificationSource& source,
963 const content::NotificationDetails& details) {
964 OptionsPageUIHandler::Observe(type, source, details);
965 if (type == chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED) {
966 base::FundamentalValue require_pin(*content::Details<bool>(details).ptr());
967 web_ui()->CallJavascriptFunction(
968 kUpdateSecurityTabFunction, require_pin);
969 } else if (type == chrome::NOTIFICATION_ENTER_PIN_ENDED) {
970 // We make an assumption (which is valid for now) that the SIM
971 // unlock dialog is put up only when the user is trying to enable
972 // mobile data.
973 bool cancelled = *content::Details<bool>(details).ptr();
974 if (cancelled)
975 RefreshNetworkData();
976 // The case in which the correct PIN was entered and the SIM is
977 // now unlocked is handled in NetworkMenuButton.
978 }
979 }
980
981 DictionaryValue* InternetOptionsHandler::CellularDataPlanToDictionary(
982 const chromeos::CellularDataPlan* plan) {
983 DictionaryValue* plan_dict = new DictionaryValue();
984 plan_dict->SetInteger(kTagPlanType, plan->plan_type);
985 plan_dict->SetString(kTagName, plan->plan_name);
986 plan_dict->SetString(kTagPlanSummary, plan->GetPlanDesciption());
987 plan_dict->SetString(kTagDataRemaining, plan->GetDataRemainingDesciption());
988 plan_dict->SetString(kTagPlanExpires, plan->GetPlanExpiration());
989 plan_dict->SetString(kTagWarning, plan->GetRemainingWarning());
990 return plan_dict;
991 }
992
993 void InternetOptionsHandler::SetPreferNetworkCallback(const ListValue* args) {
994 std::string service_path;
995 std::string prefer_network_str;
996
997 if (args->GetSize() < 2 ||
998 !args->GetString(0, &service_path) ||
999 !args->GetString(1, &prefer_network_str)) {
1000 NOTREACHED();
1001 return;
1002 }
1003
1004 chromeos::Network* network = cros_->FindNetworkByPath(service_path);
1005 if (!network)
1006 return;
1007
1008 bool prefer_network = prefer_network_str == kTagTrue;
1009 if (prefer_network != network->preferred())
1010 network->SetPreferred(prefer_network);
1011 }
1012
1013 void InternetOptionsHandler::SetAutoConnectCallback(const ListValue* args) {
1014 std::string service_path;
1015 std::string auto_connect_str;
1016
1017 if (args->GetSize() < 2 ||
1018 !args->GetString(0, &service_path) ||
1019 !args->GetString(1, &auto_connect_str)) {
1020 NOTREACHED();
1021 return;
1022 }
1023
1024 chromeos::Network* network = cros_->FindNetworkByPath(service_path);
1025 if (!network)
1026 return;
1027
1028 bool auto_connect = auto_connect_str == kTagTrue;
1029 if (auto_connect != network->auto_connect())
1030 network->SetAutoConnect(auto_connect);
1031 }
1032
1033 void InternetOptionsHandler::SetIPConfigCallback(const ListValue* args) {
1034 std::string service_path;
1035 bool dhcp_for_ip;
1036 std::string address;
1037 std::string netmask;
1038 std::string gateway;
1039 std::string name_server_type;
1040 std::string name_servers;
1041
1042 if (args->GetSize() < 7 ||
1043 !args->GetString(0, &service_path) ||
1044 !args->GetBoolean(1, &dhcp_for_ip) ||
1045 !args->GetString(2, &address) ||
1046 !args->GetString(3, &netmask) ||
1047 !args->GetString(4, &gateway) ||
1048 !args->GetString(5, &name_server_type) ||
1049 !args->GetString(6, &name_servers)) {
1050 NOTREACHED();
1051 return;
1052 }
1053
1054 int dhcp_usage_mask = 0;
1055 if (dhcp_for_ip) {
1056 dhcp_usage_mask = (chromeos::NetworkLibrary::USE_DHCP_ADDRESS |
1057 chromeos::NetworkLibrary::USE_DHCP_NETMASK |
1058 chromeos::NetworkLibrary::USE_DHCP_GATEWAY);
1059 }
1060 if (name_server_type == kNameServerTypeAutomatic) {
1061 dhcp_usage_mask |= chromeos::NetworkLibrary::USE_DHCP_NAME_SERVERS;
1062 name_servers.clear();
1063 } else if (name_server_type == kNameServerTypeGoogle) {
1064 name_servers = kGoogleNameServers;
1065 }
1066
1067 cros_->SetIPParameters(service_path,
1068 address,
1069 netmask,
1070 gateway,
1071 name_servers,
1072 dhcp_usage_mask);
1073 }
1074
1075 void InternetOptionsHandler::PopulateDictionaryDetails(
1076 const chromeos::Network* network) {
1077 DCHECK(network);
1078
1079 // Send off an asynchronous request to Shill to get the service properties
1080 // and continue in the callback.
1081 chromeos::CrosRequestNetworkServiceProperties(
1082 network->service_path(),
1083 base::Bind(&InternetOptionsHandler::PopulateDictionaryDetailsCallback,
1084 weak_factory_.GetWeakPtr(), network));
1085 }
1086
1087 void InternetOptionsHandler::PopulateDictionaryDetailsCallback(
1088 const chromeos::Network* network,
1089 const std::string& service_path,
1090 const base::DictionaryValue* shill_properties) {
1091 if (VLOG_IS_ON(2)) {
1092 std::string properties_json;
1093 base::JSONWriter::WriteWithOptions(shill_properties,
1094 base::JSONWriter::OPTIONS_PRETTY_PRINT,
1095 &properties_json);
1096 VLOG(2) << "Shill Properties: " << std::endl << properties_json;
1097 }
1098
1099 if (web_ui()) {
1100 Profile::FromWebUI(web_ui())->GetProxyConfigTracker()->UISetCurrentNetwork(
1101 network->service_path());
1102 }
1103
1104 const chromeos::NetworkUIData& ui_data = network->ui_data();
1105 const base::DictionaryValue* onc =
1106 cros_->FindOncForNetwork(network->unique_id());
1107
1108 base::DictionaryValue dictionary;
1109 std::string hardware_address;
1110 chromeos::NetworkIPConfigVector ipconfigs = cros_->GetIPConfigs(
1111 network->device_path(), &hardware_address,
1112 chromeos::NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
1113 if (!hardware_address.empty())
1114 dictionary.SetString(kTagHardwareAddress, hardware_address);
1115
1116 // The DHCP IPConfig contains the values that are actually in use at the
1117 // moment, even if some are overridden by static IP values.
1118 scoped_ptr<DictionaryValue> ipconfig_dhcp(new DictionaryValue);
1119 std::string ipconfig_name_servers;
1120 for (chromeos::NetworkIPConfigVector::const_iterator it = ipconfigs.begin();
1121 it != ipconfigs.end(); ++it) {
1122 const chromeos::NetworkIPConfig& ipconfig = *it;
1123 if (ipconfig.type == chromeos::IPCONFIG_TYPE_DHCP) {
1124 ipconfig_dhcp->SetString(kIpConfigAddress, ipconfig.address);
1125 VLOG(2) << "Found DHCP Address: " << ipconfig.address;
1126 ipconfig_dhcp->SetString(kIpConfigNetmask, ipconfig.netmask);
1127 VLOG(2) << "Found DHCP Netmask: " << ipconfig.netmask;
1128 ipconfig_dhcp->SetString(kIpConfigGateway, ipconfig.gateway);
1129 VLOG(2) << "Found DHCP Gateway: " << ipconfig.gateway;
1130 ipconfig_dhcp->SetString(kIpConfigNameServers, ipconfig.name_servers);
1131 ipconfig_name_servers = ipconfig.name_servers; // save for later
1132 VLOG(2) << "Found DHCP Name Servers: " << ipconfig.name_servers;
1133 break;
1134 }
1135 }
1136
1137 chromeos::NetworkPropertyUIData ipconfig_dhcp_ui_data(ui_data);
1138
1139 chromeos::NetworkPropertyUIData static_ip_ui_data(ui_data);
1140 int automatic_ip_config;
1141 scoped_ptr<DictionaryValue> static_ip_dict(
1142 BuildIPInfoDictionary(*shill_properties, true, &automatic_ip_config));
1143 dictionary.SetBoolean(kIpConfigAutoConfig, automatic_ip_config == 0);
1144 DCHECK(automatic_ip_config == 3 || automatic_ip_config == 0)
1145 << "UI doesn't support automatic specification of individual "
1146 << "static ip parameters.";
1147 scoped_ptr<DictionaryValue> saved_ip_dict(
1148 BuildIPInfoDictionary(*shill_properties, false, NULL));
1149 dictionary.Set(kDictionarySavedIp, saved_ip_dict.release());
1150
1151 // Determine what kind of name server setting we have by comparing the
1152 // StaticIP and Google values with the ipconfig values.
1153 std::string name_server_type = kNameServerTypeAutomatic;
1154 std::string static_ip_nameservers;
1155 static_ip_dict->GetString(kIpConfigNameServers, &static_ip_nameservers);
1156 if (!static_ip_nameservers.empty() &&
1157 static_ip_nameservers == ipconfig_name_servers) {
1158 name_server_type = kNameServerTypeUser;
1159 }
1160 if (ipconfig_name_servers == kGoogleNameServers) {
1161 name_server_type = kNameServerTypeGoogle;
1162 }
1163
1164 SetValueDictionary(&dictionary, kDictionaryIpConfig, ipconfig_dhcp.release(),
1165 ipconfig_dhcp_ui_data);
1166 SetValueDictionary(&dictionary, kDictionaryStaticIp, static_ip_dict.release(),
1167 static_ip_ui_data);
1168
1169 chromeos::ConnectionType type = network->type();
1170 dictionary.SetInteger(kTagType, type);
1171 dictionary.SetString(kTagServicePath, network->service_path());
1172 dictionary.SetBoolean(kTagConnecting, network->connecting());
1173 dictionary.SetBoolean(kTagConnected, network->connected());
1174 dictionary.SetString(kTagConnectionState, network->GetStateString());
1175 dictionary.SetString(kTagNetworkName, network->name());
1176 dictionary.SetString(kTagNameServerType, name_server_type);
1177 dictionary.SetString(kTagNameServersGoogle, kGoogleNameServers);
1178
1179 // Only show proxy for remembered networks.
1180 chromeos::NetworkProfileType network_profile = network->profile_type();
1181 dictionary.SetBoolean(kTagShowProxy,
1182 network_profile != chromeos::PROFILE_NONE);
1183
1184 // Enable static ip config for ethernet. For wifi, enable if flag is set.
1185 bool staticIPConfig = type == chromeos::TYPE_ETHERNET ||
1186 (type == chromeos::TYPE_WIFI &&
1187 CommandLine::ForCurrentProcess()->HasSwitch(
1188 switches::kEnableStaticIPConfig));
1189 dictionary.SetBoolean(kTagShowStaticIPConfig, staticIPConfig);
1190
1191 chromeos::NetworkPropertyUIData preferred_ui_data(ui_data);
1192 if (network_profile == chromeos::PROFILE_USER) {
1193 dictionary.SetBoolean(kTagShowPreferred, true);
1194 SetValueDictionary(&dictionary, kTagPreferred,
1195 Value::CreateBooleanValue(network->preferred()),
1196 preferred_ui_data);
1197 } else {
1198 dictionary.SetBoolean(kTagShowPreferred, false);
1199 SetValueDictionary(&dictionary, kTagPreferred,
1200 Value::CreateBooleanValue(network->preferred()),
1201 preferred_ui_data);
1202 }
1203 chromeos::NetworkPropertyUIData auto_connect_ui_data(ui_data);
1204 if (type == chromeos::TYPE_WIFI) {
1205 auto_connect_ui_data.ParseOncProperty(
1206 ui_data, onc,
1207 base::StringPrintf("%s.%s",
1208 chromeos::onc::kWiFi,
1209 chromeos::onc::wifi::kAutoConnect));
1210 }
1211 SetValueDictionary(&dictionary, kTagAutoConnect,
1212 Value::CreateBooleanValue(network->auto_connect()),
1213 auto_connect_ui_data);
1214
1215 if (type == chromeos::TYPE_WIFI) {
1216 dictionary.SetBoolean(kTagDeviceConnected, cros_->wifi_connected());
1217 const chromeos::WifiNetwork* wifi =
1218 cros_->FindWifiNetworkByPath(network->service_path());
1219 if (!wifi) {
1220 LOG(WARNING) << "Cannot find network " << network->service_path();
1221 } else {
1222 PopulateWifiDetails(wifi, &dictionary);
1223 }
1224 } else if (type == chromeos::TYPE_WIMAX) {
1225 dictionary.SetBoolean(kTagDeviceConnected, cros_->wimax_connected());
1226 const chromeos::WimaxNetwork* wimax =
1227 cros_->FindWimaxNetworkByPath(network->service_path());
1228 if (!wimax) {
1229 LOG(WARNING) << "Cannot find network " << network->service_path();
1230 } else {
1231 PopulateWimaxDetails(wimax, &dictionary);
1232 }
1233 } else if (type == chromeos::TYPE_CELLULAR) {
1234 dictionary.SetBoolean(kTagDeviceConnected, cros_->cellular_connected());
1235 const chromeos::CellularNetwork* cellular =
1236 cros_->FindCellularNetworkByPath(network->service_path());
1237 if (!cellular) {
1238 LOG(WARNING) << "Cannot find network " << network->service_path();
1239 } else {
1240 PopulateCellularDetails(cellular, &dictionary);
1241 }
1242 } else if (type == chromeos::TYPE_VPN) {
1243 dictionary.SetBoolean(kTagDeviceConnected,
1244 cros_->virtual_network_connected());
1245 const chromeos::VirtualNetwork* vpn =
1246 cros_->FindVirtualNetworkByPath(network->service_path());
1247 if (!vpn) {
1248 LOG(WARNING) << "Cannot find network " << network->service_path();
1249 } else {
1250 PopulateVPNDetails(vpn, &dictionary);
1251 }
1252 } else if (type == chromeos::TYPE_ETHERNET) {
1253 dictionary.SetBoolean(kTagDeviceConnected, cros_->ethernet_connected());
1254 }
1255
1256 web_ui()->CallJavascriptFunction(
1257 kShowDetailedInfoFunction, dictionary);
1258 }
1259
1260 void InternetOptionsHandler::PopulateWifiDetails(
1261 const chromeos::WifiNetwork* wifi,
1262 DictionaryValue* dictionary) {
1263 dictionary->SetString(kTagSsid, wifi->name());
1264 bool remembered = (wifi->profile_type() != chromeos::PROFILE_NONE);
1265 dictionary->SetBoolean(kTagRemembered, remembered);
1266 bool shared = wifi->profile_type() == chromeos::PROFILE_SHARED;
1267 dictionary->SetBoolean(kTagShared, shared);
1268 dictionary->SetString(kTagEncryption, wifi->GetEncryptionString());
1269 dictionary->SetString(kTagBssid, wifi->bssid());
1270 dictionary->SetInteger(kTagFrequency, wifi->frequency());
1271 dictionary->SetInteger(kTagStrength, wifi->strength());
1272 }
1273
1274 void InternetOptionsHandler::PopulateWimaxDetails(
1275 const chromeos::WimaxNetwork* wimax,
1276 DictionaryValue* dictionary) {
1277 bool remembered = (wimax->profile_type() != chromeos::PROFILE_NONE);
1278 dictionary->SetBoolean(kTagRemembered, remembered);
1279 bool shared = wimax->profile_type() == chromeos::PROFILE_SHARED;
1280 dictionary->SetBoolean(kTagShared, shared);
1281 if (wimax->passphrase_required())
1282 dictionary->SetString(kTagIdentity, wimax->eap_identity());
1283
1284 dictionary->SetInteger(kTagStrength, wimax->strength());
1285 }
1286
1287 DictionaryValue* InternetOptionsHandler::CreateDictionaryFromCellularApn(
1288 const chromeos::CellularApn& apn) {
1289 DictionaryValue* dictionary = new DictionaryValue();
1290 dictionary->SetString(kTagApn, apn.apn);
1291 dictionary->SetString(kTagNetworkId, apn.network_id);
1292 dictionary->SetString(kTagUsername, apn.username);
1293 dictionary->SetString(kTagPassword, apn.password);
1294 dictionary->SetString(kTagName, apn.name);
1295 dictionary->SetString(kTagLocalizedName, apn.localized_name);
1296 dictionary->SetString(kTagLanguage, apn.language);
1297 return dictionary;
1298 }
1299
1300 void InternetOptionsHandler::PopulateCellularDetails(
1301 const chromeos::CellularNetwork* cellular,
1302 DictionaryValue* dictionary) {
1303 // Cellular network / connection settings.
1304 dictionary->SetString(kTagServiceName, cellular->name());
1305 dictionary->SetString(kTagNetworkTechnology,
1306 cellular->GetNetworkTechnologyString());
1307 dictionary->SetString(kTagOperatorName, cellular->operator_name());
1308 dictionary->SetString(kTagOperatorCode, cellular->operator_code());
1309 dictionary->SetString(kTagActivationState,
1310 cellular->GetActivationStateString());
1311 dictionary->SetString(kTagRoamingState,
1312 cellular->GetRoamingStateString());
1313 dictionary->SetString(kTagRestrictedPool,
1314 cellular->restricted_pool() ?
1315 l10n_util::GetStringUTF8(
1316 IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL) :
1317 l10n_util::GetStringUTF8(
1318 IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL));
1319 dictionary->SetString(kTagErrorState, cellular->GetErrorString());
1320 dictionary->SetString(kTagSupportUrl, cellular->payment_url());
1321 dictionary->SetBoolean(kTagNeedsPlan, cellular->needs_new_plan());
1322
1323 dictionary->Set(kTagApn, CreateDictionaryFromCellularApn(cellular->apn()));
1324 dictionary->Set(kTagLastGoodApn,
1325 CreateDictionaryFromCellularApn(cellular->last_good_apn()));
1326
1327 // Device settings.
1328 const chromeos::NetworkDevice* device =
1329 cros_->FindNetworkDeviceByPath(cellular->device_path());
1330 if (device) {
1331 chromeos::NetworkPropertyUIData cellular_propety_ui_data(
1332 cellular->ui_data());
1333 dictionary->SetString(kTagManufacturer, device->manufacturer());
1334 dictionary->SetString(kTagModelId, device->model_id());
1335 dictionary->SetString(kTagFirmwareRevision, device->firmware_revision());
1336 dictionary->SetString(kTagHardwareRevision, device->hardware_revision());
1337 dictionary->SetString(kTagPrlVersion,
1338 base::StringPrintf("%u", device->prl_version()));
1339 dictionary->SetString(kTagMeid, device->meid());
1340 dictionary->SetString(kTagImei, device->imei());
1341 dictionary->SetString(kTagMdn, device->mdn());
1342 dictionary->SetString(kTagImsi, device->imsi());
1343 dictionary->SetString(kTagEsn, device->esn());
1344 dictionary->SetString(kTagMin, device->min());
1345 dictionary->SetBoolean(kTagGsm,
1346 device->technology_family() == chromeos::TECHNOLOGY_FAMILY_GSM);
1347 SetValueDictionary(
1348 dictionary, kTagSimCardLockEnabled,
1349 Value::CreateBooleanValue(
1350 device->sim_pin_required() == chromeos::SIM_PIN_REQUIRED),
1351 cellular_propety_ui_data);
1352
1353 chromeos::MobileConfig* config = chromeos::MobileConfig::GetInstance();
1354 if (config->IsReady()) {
1355 const std::string& carrier_id = cros_->GetCellularHomeCarrierId();
1356 const chromeos::MobileConfig::Carrier* carrier =
1357 config->GetCarrier(carrier_id);
1358 if (carrier && !carrier->top_up_url().empty())
1359 dictionary->SetString(kTagCarrierUrl, carrier->top_up_url());
1360 }
1361
1362 const chromeos::CellularApnList& apn_list = device->provider_apn_list();
1363 ListValue* apn_list_value = new ListValue();
1364 for (chromeos::CellularApnList::const_iterator it = apn_list.begin();
1365 it != apn_list.end(); ++it) {
1366 apn_list_value->Append(CreateDictionaryFromCellularApn(*it));
1367 }
1368 SetValueDictionary(dictionary, kTagProviderApnList, apn_list_value,
1369 cellular_propety_ui_data);
1370 }
1371
1372 SetActivationButtonVisibility(cellular,
1373 dictionary,
1374 cros_->GetCellularHomeCarrierId());
1375 }
1376
1377 void InternetOptionsHandler::PopulateVPNDetails(
1378 const chromeos::VirtualNetwork* vpn,
1379 DictionaryValue* dictionary) {
1380 dictionary->SetString(kTagService_name, vpn->name());
1381 bool remembered = (vpn->profile_type() != chromeos::PROFILE_NONE);
1382 dictionary->SetBoolean(kTagRemembered, remembered);
1383 dictionary->SetString(kTagServer_hostname, vpn->server_hostname());
1384 dictionary->SetString(kTagProvider_type, vpn->GetProviderTypeString());
1385 dictionary->SetString(kTagUsername, vpn->username());
1386 }
1387
1388 void InternetOptionsHandler::SetActivationButtonVisibility(
1389 const chromeos::CellularNetwork* cellular,
1390 DictionaryValue* dictionary,
1391 const std::string& carrier_id) {
1392 if (cellular->needs_new_plan()) {
1393 dictionary->SetBoolean(kTagShowBuyButton, true);
1394 } else if (cellular->activation_state() !=
1395 chromeos::ACTIVATION_STATE_ACTIVATING &&
1396 cellular->activation_state() !=
1397 chromeos::ACTIVATION_STATE_ACTIVATED) {
1398 dictionary->SetBoolean(kTagShowActivateButton, true);
1399 } else {
1400 const chromeos::MobileConfig::Carrier* carrier =
1401 chromeos::MobileConfig::GetInstance()->GetCarrier(carrier_id);
1402 if (carrier && carrier->show_portal_button()) {
1403 // This will trigger BuyDataPlanCallback() so that
1404 // chrome://mobilesetup/ will open carrier specific portal.
1405 dictionary->SetBoolean(kTagShowViewAccountButton, true);
1406 }
1407 }
1408 }
1409
1410 gfx::NativeWindow InternetOptionsHandler::GetNativeWindow() const {
1411 // TODO(beng): This is an improper direct dependency on Browser. Route this
1412 // through some sort of delegate.
1413 Browser* browser =
1414 browser::FindBrowserWithWebContents(web_ui()->GetWebContents());
1415 return browser->window()->GetNativeWindow();
1416 }
1417
1418 Browser* InternetOptionsHandler::GetAppropriateBrowser() {
1419 return browser::FindOrCreateTabbedBrowser(
1420 ProfileManager::GetDefaultProfileOrOffTheRecord());
1421 }
1422
1423 void InternetOptionsHandler::NetworkCommandCallback(const ListValue* args) {
1424 std::string str_type;
1425 std::string service_path;
1426 std::string command;
1427 if (args->GetSize() != 3 ||
1428 !args->GetString(0, &str_type) ||
1429 !args->GetString(1, &service_path) ||
1430 !args->GetString(2, &command)) {
1431 NOTREACHED();
1432 return;
1433 }
1434
1435 int type = atoi(str_type.c_str());
1436 if (type == chromeos::TYPE_ETHERNET) {
1437 const chromeos::EthernetNetwork* ether = cros_->ethernet_network();
1438 if (ether)
1439 PopulateDictionaryDetails(ether);
1440 } else if (type == chromeos::TYPE_WIFI) {
1441 HandleWifiButtonClick(service_path, command);
1442 } else if (type == chromeos::TYPE_WIMAX) {
1443 HandleWimaxButtonClick(service_path, command);
1444 } else if (type == chromeos::TYPE_CELLULAR) {
1445 HandleCellularButtonClick(service_path, command);
1446 } else if (type == chromeos::TYPE_VPN) {
1447 HandleVPNButtonClick(service_path, command);
1448 } else {
1449 NOTREACHED();
1450 }
1451 }
1452
1453 void InternetOptionsHandler::ToggleAirplaneModeCallback(const ListValue* args) {
1454 // TODO(kevers): The use of 'offline_mode' is not quite correct. Update once
1455 // we have proper back-end support.
1456 cros_->EnableOfflineMode(!cros_->offline_mode());
1457 }
1458
1459 void InternetOptionsHandler::HandleWifiButtonClick(
1460 const std::string& service_path,
1461 const std::string& command) {
1462 chromeos::WifiNetwork* wifi = NULL;
1463 if (command == kTagForget) {
1464 cros_->ForgetNetwork(service_path);
1465 } else if (service_path == kOtherNetworksFakePath) {
1466 // Other wifi networks.
1467 chromeos::NetworkConfigView::ShowForType(
1468 chromeos::TYPE_WIFI, GetNativeWindow());
1469 } else if ((wifi = cros_->FindWifiNetworkByPath(service_path))) {
1470 if (command == kTagConnect) {
1471 wifi->SetEnrollmentDelegate(
1472 chromeos::CreateEnrollmentDelegate(GetNativeWindow(), wifi->name(),
1473 ProfileManager::GetLastUsedProfile()));
1474 wifi->AttemptConnection(base::Bind(&InternetOptionsHandler::DoConnect,
1475 weak_factory_.GetWeakPtr(),
1476 wifi));
1477 } else if (command == kTagDisconnect) {
1478 cros_->DisconnectFromNetwork(wifi);
1479 } else if (command == kTagOptions) {
1480 PopulateDictionaryDetails(wifi);
1481 }
1482 }
1483 }
1484
1485 void InternetOptionsHandler::HandleWimaxButtonClick(
1486 const std::string& service_path,
1487 const std::string& command) {
1488 chromeos::WimaxNetwork* wimax = NULL;
1489 if (command == kTagForget) {
1490 cros_->ForgetNetwork(service_path);
1491 } else if ((wimax = cros_->FindWimaxNetworkByPath(service_path))) {
1492 if (command == kTagConnect) {
1493 wimax->SetEnrollmentDelegate(
1494 chromeos::CreateEnrollmentDelegate(GetNativeWindow(), wimax->name(),
1495 ProfileManager::GetLastUsedProfile()));
1496 wimax->AttemptConnection(base::Bind(&InternetOptionsHandler::DoConnect,
1497 weak_factory_.GetWeakPtr(),
1498 wimax));
1499 } else if (command == kTagDisconnect) {
1500 cros_->DisconnectFromNetwork(wimax);
1501 } else if (command == kTagOptions) {
1502 PopulateDictionaryDetails(wimax);
1503 }
1504 }
1505 }
1506
1507 void InternetOptionsHandler::HandleCellularButtonClick(
1508 const std::string& service_path,
1509 const std::string& command) {
1510 chromeos::CellularNetwork* cellular = NULL;
1511 if (service_path == kOtherNetworksFakePath) {
1512 chromeos::ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
1513 } else if ((cellular = cros_->FindCellularNetworkByPath(service_path))) {
1514 if (command == kTagConnect) {
1515 cros_->ConnectToCellularNetwork(cellular);
1516 } else if (command == kTagDisconnect) {
1517 cros_->DisconnectFromNetwork(cellular);
1518 } else if (command == kTagActivate) {
1519 ash::Shell::GetInstance()->delegate()->OpenMobileSetup(service_path);
1520 } else if (command == kTagOptions) {
1521 PopulateDictionaryDetails(cellular);
1522 }
1523 }
1524 }
1525
1526 void InternetOptionsHandler::HandleVPNButtonClick(
1527 const std::string& service_path,
1528 const std::string& command) {
1529 chromeos::VirtualNetwork* network = NULL;
1530 if (command == kTagForget) {
1531 cros_->ForgetNetwork(service_path);
1532 } else if (service_path == kOtherNetworksFakePath) {
1533 // TODO(altimofeev): verify if service_path in condition is correct.
1534 // Other VPN networks.
1535 chromeos::NetworkConfigView::ShowForType(
1536 chromeos::TYPE_VPN, GetNativeWindow());
1537 } else if ((network = cros_->FindVirtualNetworkByPath(service_path))) {
1538 if (command == kTagConnect) {
1539 network->SetEnrollmentDelegate(
1540 chromeos::CreateEnrollmentDelegate(
1541 GetNativeWindow(),
1542 network->name(),
1543 ProfileManager::GetLastUsedProfile()));
1544 network->AttemptConnection(base::Bind(&InternetOptionsHandler::DoConnect,
1545 weak_factory_.GetWeakPtr(),
1546 network));
1547 } else if (command == kTagDisconnect) {
1548 cros_->DisconnectFromNetwork(network);
1549 } else if (command == kTagOptions) {
1550 PopulateDictionaryDetails(network);
1551 }
1552 }
1553 }
1554
1555 void InternetOptionsHandler::DoConnect(chromeos::Network* network) {
1556 if (network->type() == chromeos::TYPE_VPN) {
1557 chromeos::VirtualNetwork* vpn =
1558 static_cast<chromeos::VirtualNetwork*>(network);
1559 if (vpn->NeedMoreInfoToConnect()) {
1560 chromeos::NetworkConfigView::Show(network, GetNativeWindow());
1561 } else {
1562 cros_->ConnectToVirtualNetwork(vpn);
1563 // Connection failures are responsible for updating the UI, including
1564 // reopening dialogs.
1565 }
1566 } else if (network->type() == chromeos::TYPE_WIFI) {
1567 chromeos::WifiNetwork* wifi = static_cast<chromeos::WifiNetwork*>(network);
1568 if (wifi->IsPassphraseRequired()) {
1569 // Show the connection UI if we require a passphrase.
1570 chromeos::NetworkConfigView::Show(wifi, GetNativeWindow());
1571 } else {
1572 cros_->ConnectToWifiNetwork(wifi);
1573 // Connection failures are responsible for updating the UI, including
1574 // reopening dialogs.
1575 }
1576 } else if (network->type() == chromeos::TYPE_WIMAX) {
1577 chromeos::WimaxNetwork* wimax =
1578 static_cast<chromeos::WimaxNetwork*>(network);
1579 if (wimax->passphrase_required()) {
1580 // Show the connection UI if we require a passphrase.
1581 // TODO(stavenjb): Implament WiMAX connection UI.
1582 chromeos::NetworkConfigView::Show(wimax, GetNativeWindow());
1583 } else {
1584 cros_->ConnectToWimaxNetwork(wimax);
1585 // Connection failures are responsible for updating the UI, including
1586 // reopening dialogs.
1587 }
1588 }
1589 }
1590
1591 void InternetOptionsHandler::RefreshCellularPlanCallback(
1592 const ListValue* args) {
1593 std::string service_path;
1594 if (args->GetSize() != 1 ||
1595 !args->GetString(0, &service_path)) {
1596 NOTREACHED();
1597 return;
1598 }
1599 const chromeos::CellularNetwork* cellular =
1600 cros_->FindCellularNetworkByPath(service_path);
1601 if (cellular)
1602 cellular->RefreshDataPlansIfNeeded();
1603 }
1604
1605 ListValue* InternetOptionsHandler::GetWiredList() {
1606 ListValue* list = new ListValue();
1607
1608 // If ethernet is not enabled, then don't add anything.
1609 if (cros_->ethernet_enabled()) {
1610 const chromeos::EthernetNetwork* ethernet_network =
1611 cros_->ethernet_network();
1612 if (ethernet_network) {
1613 NetworkInfoDictionary network_dict(ethernet_network,
1614 web_ui()->GetDeviceScale());
1615 network_dict.set_name(
1616 l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET)),
1617 list->Append(network_dict.BuildDictionary());
1618 }
1619 }
1620 return list;
1621 }
1622
1623 ListValue* InternetOptionsHandler::GetWirelessList() {
1624 ListValue* list = new ListValue();
1625
1626 const chromeos::WifiNetworkVector& wifi_networks = cros_->wifi_networks();
1627 for (chromeos::WifiNetworkVector::const_iterator it =
1628 wifi_networks.begin(); it != wifi_networks.end(); ++it) {
1629 NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
1630 network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
1631 list->Append(network_dict.BuildDictionary());
1632 }
1633
1634 const chromeos::WimaxNetworkVector& wimax_networks = cros_->wimax_networks();
1635 for (chromeos::WimaxNetworkVector::const_iterator it =
1636 wimax_networks.begin(); it != wimax_networks.end(); ++it) {
1637 NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
1638 network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
1639 list->Append(network_dict.BuildDictionary());
1640 }
1641
1642 const chromeos::CellularNetworkVector cellular_networks =
1643 cros_->cellular_networks();
1644 for (chromeos::CellularNetworkVector::const_iterator it =
1645 cellular_networks.begin(); it != cellular_networks.end(); ++it) {
1646 NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
1647 network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
1648 network_dict.set_activation_state((*it)->activation_state());
1649 network_dict.set_needs_new_plan(
1650 (*it)->SupportsDataPlan() && (*it)->restricted_pool());
1651 list->Append(network_dict.BuildDictionary());
1652 }
1653
1654 const chromeos::NetworkDevice* cellular_device = cros_->FindCellularDevice();
1655 if (cellular_device && cellular_device->support_network_scan() &&
1656 cros_->cellular_enabled()) {
1657 NetworkInfoDictionary network_dict(web_ui()->GetDeviceScale());
1658 network_dict.set_service_path(kOtherNetworksFakePath);
1659 network_dict.set_icon(
1660 chromeos::NetworkMenuIcon::GetDisconnectedImage(
1661 chromeos::NetworkMenuIcon::BARS,
1662 chromeos::NetworkMenuIcon::COLOR_DARK));
1663 network_dict.set_name(
1664 l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_OTHER_CELLULAR_NETWORKS));
1665 network_dict.set_connectable(true);
1666 network_dict.set_connection_type(chromeos::TYPE_CELLULAR);
1667 network_dict.set_activation_state(chromeos::ACTIVATION_STATE_ACTIVATED);
1668 list->Append(network_dict.BuildDictionary());
1669 }
1670
1671 return list;
1672 }
1673
1674 ListValue* InternetOptionsHandler::GetVPNList() {
1675 ListValue* list = new ListValue();
1676
1677 const chromeos::VirtualNetworkVector& virtual_networks =
1678 cros_->virtual_networks();
1679 for (chromeos::VirtualNetworkVector::const_iterator it =
1680 virtual_networks.begin(); it != virtual_networks.end(); ++it) {
1681 NetworkInfoDictionary network_dict(*it, web_ui()->GetDeviceScale());
1682 network_dict.set_connectable(cros_->CanConnectToNetwork(*it));
1683 list->Append(network_dict.BuildDictionary());
1684 }
1685
1686 return list;
1687 }
1688
1689 ListValue* InternetOptionsHandler::GetRememberedList() {
1690 ListValue* list = new ListValue();
1691
1692 for (chromeos::WifiNetworkVector::const_iterator rit =
1693 cros_->remembered_wifi_networks().begin();
1694 rit != cros_->remembered_wifi_networks().end(); ++rit) {
1695 chromeos::WifiNetwork* remembered = *rit;
1696 chromeos::WifiNetwork* wifi = static_cast<chromeos::WifiNetwork*>(
1697 cros_->FindNetworkByUniqueId(remembered->unique_id()));
1698
1699 NetworkInfoDictionary network_dict(wifi,
1700 remembered,
1701 web_ui()->GetDeviceScale());
1702 list->Append(network_dict.BuildDictionary());
1703 }
1704
1705 for (chromeos::VirtualNetworkVector::const_iterator rit =
1706 cros_->remembered_virtual_networks().begin();
1707 rit != cros_->remembered_virtual_networks().end(); ++rit) {
1708 chromeos::VirtualNetwork* remembered = *rit;
1709 chromeos::VirtualNetwork* vpn = static_cast<chromeos::VirtualNetwork*>(
1710 cros_->FindNetworkByUniqueId(remembered->unique_id()));
1711
1712 NetworkInfoDictionary network_dict(vpn,
1713 remembered,
1714 web_ui()->GetDeviceScale());
1715 list->Append(network_dict.BuildDictionary());
1716 }
1717
1718 return list;
1719 }
1720
1721 void InternetOptionsHandler::FillNetworkInfo(DictionaryValue* dictionary) {
1722 dictionary->SetBoolean(kTagAccessLocked, cros_->IsLocked());
1723 dictionary->Set(kTagWiredList, GetWiredList());
1724 dictionary->Set(kTagWirelessList, GetWirelessList());
1725 dictionary->Set(kTagVpnList, GetVPNList());
1726 dictionary->Set(kTagRememberedList, GetRememberedList());
1727 dictionary->SetBoolean(kTagWifiAvailable, cros_->wifi_available());
1728 dictionary->SetBoolean(kTagWifiBusy, cros_->wifi_busy());
1729 dictionary->SetBoolean(kTagWifiEnabled, cros_->wifi_enabled());
1730 dictionary->SetBoolean(kTagCellularAvailable, cros_->cellular_available());
1731 dictionary->SetBoolean(kTagCellularBusy, cros_->cellular_busy());
1732 dictionary->SetBoolean(kTagCellularEnabled, cros_->cellular_enabled());
1733 dictionary->SetBoolean(kTagWimaxEnabled, cros_->wimax_enabled());
1734 dictionary->SetBoolean(kTagWimaxAvailable, cros_->wimax_available());
1735 dictionary->SetBoolean(kTagWimaxBusy, cros_->wimax_busy());
1736 // TODO(kevers): The use of 'offline_mode' is not quite correct. Update once
1737 // we have proper back-end support.
1738 dictionary->SetBoolean(kTagAirplaneMode, cros_->offline_mode());
1739 }
1740
1741 void InternetOptionsHandler::SetValueDictionary(
1742 DictionaryValue* settings,
1743 const char* key,
1744 base::Value* value,
1745 const chromeos::NetworkPropertyUIData& ui_data) {
1746 DictionaryValue* value_dict = new DictionaryValue();
1747 // DictionaryValue::Set() takes ownership of |value|.
1748 if (value)
1749 value_dict->Set(kTagValue, value);
1750 const base::Value* default_value = ui_data.default_value();
1751 if (default_value)
1752 value_dict->Set(kTagDefault, default_value->DeepCopy());
1753 if (ui_data.managed())
1754 value_dict->SetString(kTagControlledBy, kTagPolicy);
1755 else if (ui_data.recommended())
1756 value_dict->SetString(kTagControlledBy, kTagRecommended);
1757 settings->Set(key, value_dict);
1758 }
1759
1760 } // namespace options
OLDNEW
« no previous file with comments | « chrome/browser/ui/webui/options2/chromeos/internet_options_handler.h ('k') | chrome/browser/ui/webui/options2/chromeos/keyboard_handler.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698