1// Copyright (c) 2011 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 "base/base64.h"
14#include "base/basictypes.h"
15#include "base/callback.h"
16#include "base/i18n/time_formatting.h"
17#include "base/string16.h"
18#include "base/string_number_conversions.h"
19#include "base/time.h"
20#include "base/utf_string_conversions.h"
21#include "base/values.h"
22#include "chrome/browser/browser_process.h"
23#include "chrome/browser/chromeos/choose_mobile_network_dialog.h"
24#include "chrome/browser/chromeos/cros/cros_library.h"
25#include "chrome/browser/chromeos/customization_document.h"
26#include "chrome/browser/chromeos/login/user_manager.h"
27#include "chrome/browser/chromeos/sim_dialog_delegate.h"
28#include "chrome/browser/chromeos/status/network_menu.h"
29#include "chrome/browser/chromeos/user_cros_settings_provider.h"
30#include "chrome/browser/prefs/pref_service.h"
31#include "chrome/browser/ui/browser.h"
32#include "chrome/browser/ui/browser_list.h"
33#include "chrome/browser/ui/browser_window.h"
34#include "chrome/browser/ui/views/window.h"
35#include "chrome/browser/ui/webui/web_ui_util.h"
36#include "chrome/common/pref_names.h"
37#include "chrome/common/time_format.h"
38#include "content/common/notification_service.h"
39#include "content/common/notification_type.h"
40#include "grit/chromium_strings.h"
41#include "grit/generated_resources.h"
42#include "grit/locale_settings.h"
43#include "grit/theme_resources.h"
44#include "third_party/skia/include/core/SkBitmap.h"
45#include "ui/base/l10n/l10n_util.h"
46#include "ui/base/resource/resource_bundle.h"
47#include "views/window/window.h"
48
49static const char kOtherNetworksFakePath[] = "?";
50
51InternetOptionsHandler::InternetOptionsHandler()
52    : chromeos::CrosOptionsPageUIHandler(
53          new chromeos::UserCrosSettingsProvider),
54      use_settings_ui_(false) {
55  registrar_.Add(this, NotificationType::REQUIRE_PIN_SETTING_CHANGE_ENDED,
56      NotificationService::AllSources());
57  registrar_.Add(this, NotificationType::ENTER_PIN_ENDED,
58      NotificationService::AllSources());
59  chromeos::NetworkLibrary* netlib =
60      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
61  netlib->AddNetworkManagerObserver(this);
62  netlib->AddCellularDataPlanObserver(this);
63  MonitorNetworks(netlib);
64}
65
66InternetOptionsHandler::~InternetOptionsHandler() {
67  chromeos::NetworkLibrary *netlib =
68      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
69  netlib->RemoveNetworkManagerObserver(this);
70  netlib->RemoveCellularDataPlanObserver(this);
71  netlib->RemoveObserverForAllNetworks(this);
72}
73
74void InternetOptionsHandler::GetLocalizedValues(
75    DictionaryValue* localized_strings) {
76  DCHECK(localized_strings);
77
78  RegisterTitle(localized_strings, "internetPage",
79                IDS_OPTIONS_INTERNET_TAB_LABEL);
80
81  localized_strings->SetString("wired_title",
82      l10n_util::GetStringUTF16(
83          IDS_OPTIONS_SETTINGS_SECTION_TITLE_WIRED_NETWORK));
84  localized_strings->SetString("wireless_title",
85      l10n_util::GetStringUTF16(
86          IDS_OPTIONS_SETTINGS_SECTION_TITLE_WIRELESS_NETWORK));
87  localized_strings->SetString("remembered_title",
88      l10n_util::GetStringUTF16(
89          IDS_OPTIONS_SETTINGS_SECTION_TITLE_REMEMBERED_NETWORK));
90
91  localized_strings->SetString("connect_button",
92      l10n_util::GetStringUTF16(
93          IDS_OPTIONS_SETTINGS_CONNECT));
94  localized_strings->SetString("disconnect_button",
95      l10n_util::GetStringUTF16(
96          IDS_OPTIONS_SETTINGS_DISCONNECT));
97  localized_strings->SetString("options_button",
98      l10n_util::GetStringUTF16(
99          IDS_OPTIONS_SETTINGS_OPTIONS));
100  localized_strings->SetString("forget_button",
101      l10n_util::GetStringUTF16(
102          IDS_OPTIONS_SETTINGS_FORGET));
103  localized_strings->SetString("activate_button",
104      l10n_util::GetStringUTF16(
105          IDS_OPTIONS_SETTINGS_ACTIVATE));
106  localized_strings->SetString("buyplan_button",
107      l10n_util::GetStringUTF16(
108          IDS_OPTIONS_SETTINGS_BUY_PLAN));
109
110  localized_strings->SetString("wifiNetworkTabLabel",
111      l10n_util::GetStringUTF16(
112          IDS_OPTIONS_SETTINGS_INTERNET_TAB_WIFI));
113  localized_strings->SetString("cellularPlanTabLabel",
114      l10n_util::GetStringUTF16(
115          IDS_OPTIONS_SETTINGS_INTERNET_TAB_PLAN));
116  localized_strings->SetString("cellularConnTabLabel",
117      l10n_util::GetStringUTF16(
118          IDS_OPTIONS_SETTINGS_INTERNET_TAB_CONNECTION));
119  localized_strings->SetString("cellularDeviceTabLabel",
120      l10n_util::GetStringUTF16(
121          IDS_OPTIONS_SETTINGS_INTERNET_TAB_DEVICE));
122  localized_strings->SetString("networkTabLabel",
123      l10n_util::GetStringUTF16(
124          IDS_OPTIONS_SETTINGS_INTERNET_TAB_NETWORK));
125  localized_strings->SetString("securityTabLabel",
126        l10n_util::GetStringUTF16(
127            IDS_OPTIONS_SETTINGS_INTERNET_TAB_SECURITY));
128
129  localized_strings->SetString("connectionState",
130      l10n_util::GetStringUTF16(
131          IDS_OPTIONS_SETTINGS_INTERNET_CONNECTION_STATE));
132  localized_strings->SetString("inetAddress",
133      l10n_util::GetStringUTF16(
134          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_ADDRESS));
135  localized_strings->SetString("inetSubnetAddress",
136      l10n_util::GetStringUTF16(
137          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SUBNETMASK));
138  localized_strings->SetString("inetGateway",
139      l10n_util::GetStringUTF16(
140          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_GATEWAY));
141  localized_strings->SetString("inetDns",
142      l10n_util::GetStringUTF16(
143          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_DNSSERVER));
144  localized_strings->SetString("hardwareAddress",
145      l10n_util::GetStringUTF16(
146          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_HARDWARE_ADDRESS));
147
148  localized_strings->SetString("accessLockedMsg",
149      l10n_util::GetStringUTF16(
150          IDS_STATUSBAR_NETWORK_LOCKED));
151  localized_strings->SetString("inetSsid",
152      l10n_util::GetStringUTF16(
153          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NETWORK_ID));
154  localized_strings->SetString("inetPassProtected",
155      l10n_util::GetStringUTF16(
156          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NET_PROTECTED));
157  localized_strings->SetString("inetAutoConnectNetwork",
158      l10n_util::GetStringUTF16(
159          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_AUTO_CONNECT));
160  localized_strings->SetString("inetLogin",
161      l10n_util::GetStringUTF16(
162          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_LOGIN));
163  localized_strings->SetString("inetShowPass",
164      l10n_util::GetStringUTF16(
165          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SHOWPASSWORD));
166  localized_strings->SetString("inetSecurityNone",
167      l10n_util::GetStringFUTF16(
168          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_SELECT,
169          l10n_util::GetStringUTF16(
170              IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_NONE)));
171  localized_strings->SetString("inetSecurityWEP",
172      l10n_util::GetStringFUTF16(
173          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_SELECT,
174          l10n_util::GetStringUTF16(
175              IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_WEP)));
176  localized_strings->SetString("inetSecurityWPA",
177      l10n_util::GetStringFUTF16(
178          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_SELECT,
179          l10n_util::GetStringUTF16(
180              IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_WPA)));
181  localized_strings->SetString("inetSecurityRSN",
182      l10n_util::GetStringFUTF16(
183          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_SELECT,
184          l10n_util::GetStringUTF16(
185              IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SECURITY_RSN)));
186  localized_strings->SetString("inetPassPrompt",
187      l10n_util::GetStringUTF16(
188          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PASSWORD));
189  localized_strings->SetString("inetSsidPrompt",
190      l10n_util::GetStringUTF16(
191          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SSID));
192  localized_strings->SetString("inetStatus",
193      l10n_util::GetStringUTF16(
194          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_STATUS_TITLE));
195  localized_strings->SetString("inetConnect",
196      l10n_util::GetStringUTF16(
197          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CONNECT_TITLE));
198
199  localized_strings->SetString("serviceName",
200      l10n_util::GetStringUTF16(
201          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_SERVICE_NAME));
202  localized_strings->SetString("networkTechnology",
203      l10n_util::GetStringUTF16(
204          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_NETWORK_TECHNOLOGY));
205  localized_strings->SetString("operatorName",
206      l10n_util::GetStringUTF16(
207          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_OPERATOR));
208  localized_strings->SetString("operatorCode",
209      l10n_util::GetStringUTF16(
210          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_OPERATOR_CODE));
211  localized_strings->SetString("activationState",
212      l10n_util::GetStringUTF16(
213          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ACTIVATION_STATE));
214  localized_strings->SetString("roamingState",
215      l10n_util::GetStringUTF16(
216          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ROAMING_STATE));
217  localized_strings->SetString("restrictedPool",
218      l10n_util::GetStringUTF16(
219          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_RESTRICTED_POOL));
220  localized_strings->SetString("errorState",
221      l10n_util::GetStringUTF16(
222          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ERROR_STATE));
223  localized_strings->SetString("manufacturer",
224      l10n_util::GetStringUTF16(
225          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_MANUFACTURER));
226  localized_strings->SetString("modelId",
227      l10n_util::GetStringUTF16(
228          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_MODEL_ID));
229  localized_strings->SetString("firmwareRevision",
230      l10n_util::GetStringUTF16(
231          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_FIRMWARE_REVISION));
232  localized_strings->SetString("hardwareRevision",
233      l10n_util::GetStringUTF16(
234          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_HARDWARE_REVISION));
235  localized_strings->SetString("prlVersion",
236      l10n_util::GetStringUTF16(
237          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_PRL_VERSION));
238  localized_strings->SetString("cellularApnLabel",
239      l10n_util::GetStringUTF16(
240          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN));
241  localized_strings->SetString("cellularApnUsername",
242      l10n_util::GetStringUTF16(
243          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_USERNAME));
244  localized_strings->SetString("cellularApnPassword",
245      l10n_util::GetStringUTF16(
246          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_PASSWORD));
247  localized_strings->SetString("cellularApnClear",
248      l10n_util::GetStringUTF16(
249          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_CLEAR));
250  localized_strings->SetString("cellularApnSet",
251      l10n_util::GetStringUTF16(
252          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_APN_SET));
253
254  localized_strings->SetString("accessSecurityTabLink",
255      l10n_util::GetStringUTF16(
256          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_ACCESS_SECURITY_TAB));
257  localized_strings->SetString("lockSimCard",
258      l10n_util::GetStringUTF16(
259          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_LOCK_SIM_CARD));
260  localized_strings->SetString("changePinButton",
261      l10n_util::GetStringUTF16(
262          IDS_OPTIONS_SETTINGS_INTERNET_CELLULAR_CHANGE_PIN_BUTTON));
263
264  localized_strings->SetString("planName",
265      l10n_util::GetStringUTF16(
266          IDS_OPTIONS_SETTINGS_INTERNET_CELL_PLAN_NAME));
267  localized_strings->SetString("planLoading",
268      l10n_util::GetStringUTF16(
269          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_LOADING_PLAN));
270  localized_strings->SetString("noPlansFound",
271      l10n_util::GetStringUTF16(
272          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_NO_PLANS_FOUND));
273  localized_strings->SetString("purchaseMore",
274      l10n_util::GetStringUTF16(
275          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_PURCHASE_MORE));
276  localized_strings->SetString("dataRemaining",
277      l10n_util::GetStringUTF16(
278          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_DATA_REMAINING));
279  localized_strings->SetString("planExpires",
280      l10n_util::GetStringUTF16(
281          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_EXPIRES));
282  localized_strings->SetString("showPlanNotifications",
283      l10n_util::GetStringUTF16(
284          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_SHOW_MOBILE_NOTIFICATION));
285  localized_strings->SetString("autoconnectCellular",
286      l10n_util::GetStringUTF16(
287          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_AUTO_CONNECT));
288  localized_strings->SetString("customerSupport",
289      l10n_util::GetStringUTF16(
290          IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CUSTOMER_SUPPORT));
291
292  localized_strings->SetString("enableWifi",
293      l10n_util::GetStringFUTF16(
294          IDS_STATUSBAR_NETWORK_DEVICE_ENABLE,
295          l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_WIFI)));
296  localized_strings->SetString("disableWifi",
297      l10n_util::GetStringFUTF16(
298          IDS_STATUSBAR_NETWORK_DEVICE_DISABLE,
299          l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_WIFI)));
300  localized_strings->SetString("enableCellular",
301      l10n_util::GetStringFUTF16(
302          IDS_STATUSBAR_NETWORK_DEVICE_ENABLE,
303          l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CELLULAR)));
304  localized_strings->SetString("disableCellular",
305      l10n_util::GetStringFUTF16(
306          IDS_STATUSBAR_NETWORK_DEVICE_DISABLE,
307          l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CELLULAR)));
308  localized_strings->SetString("enableDataRoaming",
309      l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_ENABLE_DATA_ROAMING));
310  localized_strings->SetString("generalNetworkingTitle",
311      l10n_util::GetStringUTF16(
312          IDS_OPTIONS_SETTINGS_INTERNET_CONTROL_TITLE));
313  localized_strings->SetString("detailsInternetDismiss",
314      l10n_util::GetStringUTF16(IDS_CLOSE));
315  localized_strings->SetString("ownerOnly", l10n_util::GetStringUTF16(
316      IDS_OPTIONS_ACCOUNTS_OWNER_ONLY));
317  localized_strings->SetString("ownerUserId", UTF8ToUTF16(
318      chromeos::UserCrosSettingsProvider::cached_owner()));
319
320  chromeos::NetworkLibrary* cros =
321      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
322  FillNetworkInfo(localized_strings, cros);
323
324  localized_strings->SetBoolean("networkUseSettingsUI", use_settings_ui_);
325}
326
327void InternetOptionsHandler::Initialize() {
328  chromeos::NetworkLibrary* cros =
329      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
330  cros->RequestNetworkScan();
331}
332
333void InternetOptionsHandler::RegisterMessages() {
334  // Setup handlers specific to this panel.
335  DCHECK(web_ui_);
336  web_ui_->RegisterMessageCallback("buttonClickCallback",
337      NewCallback(this, &InternetOptionsHandler::ButtonClickCallback));
338  web_ui_->RegisterMessageCallback("refreshCellularPlan",
339      NewCallback(this, &InternetOptionsHandler::RefreshCellularPlanCallback));
340  web_ui_->RegisterMessageCallback("loginToNetwork",
341      NewCallback(this, &InternetOptionsHandler::LoginCallback));
342  web_ui_->RegisterMessageCallback("loginToCertNetwork",
343      NewCallback(this, &InternetOptionsHandler::LoginCertCallback));
344  web_ui_->RegisterMessageCallback("loginToOtherNetwork",
345      NewCallback(this, &InternetOptionsHandler::LoginToOtherCallback));
346  web_ui_->RegisterMessageCallback("setDetails",
347      NewCallback(this, &InternetOptionsHandler::SetDetailsCallback));
348  web_ui_->RegisterMessageCallback("enableWifi",
349      NewCallback(this, &InternetOptionsHandler::EnableWifiCallback));
350  web_ui_->RegisterMessageCallback("disableWifi",
351      NewCallback(this, &InternetOptionsHandler::DisableWifiCallback));
352  web_ui_->RegisterMessageCallback("enableCellular",
353      NewCallback(this, &InternetOptionsHandler::EnableCellularCallback));
354  web_ui_->RegisterMessageCallback("disableCellular",
355      NewCallback(this, &InternetOptionsHandler::DisableCellularCallback));
356  web_ui_->RegisterMessageCallback("buyDataPlan",
357      NewCallback(this, &InternetOptionsHandler::BuyDataPlanCallback));
358  web_ui_->RegisterMessageCallback("showMorePlanInfo",
359      NewCallback(this, &InternetOptionsHandler::BuyDataPlanCallback));
360  web_ui_->RegisterMessageCallback("setApn",
361        NewCallback(this, &InternetOptionsHandler::SetApnCallback));
362  web_ui_->RegisterMessageCallback("setSimCardLock",
363        NewCallback(this, &InternetOptionsHandler::SetSimCardLockCallback));
364  web_ui_->RegisterMessageCallback("changePin",
365        NewCallback(this, &InternetOptionsHandler::ChangePinCallback));
366}
367
368void InternetOptionsHandler::EnableWifiCallback(const ListValue* args) {
369  chromeos::NetworkLibrary* cros =
370      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
371  cros->EnableWifiNetworkDevice(true);
372}
373
374void InternetOptionsHandler::DisableWifiCallback(const ListValue* args) {
375  chromeos::NetworkLibrary* cros =
376      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
377  cros->EnableWifiNetworkDevice(false);
378}
379
380void InternetOptionsHandler::EnableCellularCallback(const ListValue* args) {
381  chromeos::NetworkLibrary* cros =
382      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
383  const chromeos::NetworkDevice* cellular = cros->FindCellularDevice();
384  if (!cellular) {
385    LOG(ERROR) << "Didn't find cellular device, it should have been available.";
386    cros->EnableCellularNetworkDevice(true);
387  } else if (cellular->sim_lock_state() == chromeos::SIM_UNLOCKED ||
388             cellular->sim_lock_state() == chromeos::SIM_UNKNOWN) {
389      cros->EnableCellularNetworkDevice(true);
390  } else {
391    chromeos::SimDialogDelegate::ShowDialog(GetNativeWindow(),
392        chromeos::SimDialogDelegate::SIM_DIALOG_UNLOCK);
393  }
394}
395
396void InternetOptionsHandler::DisableCellularCallback(const ListValue* args) {
397  chromeos::NetworkLibrary* cros =
398      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
399  cros->EnableCellularNetworkDevice(false);
400}
401
402void InternetOptionsHandler::BuyDataPlanCallback(const ListValue* args) {
403  if (!web_ui_)
404    return;
405  Browser* browser = BrowserList::FindBrowserWithFeature(
406      web_ui_->GetProfile(), Browser::FEATURE_TABSTRIP);
407  if (browser)
408    browser->OpenMobilePlanTabAndActivate();
409}
410
411void InternetOptionsHandler::SetApnCallback(const ListValue* args) {
412  std::string service_path;
413  std::string apn;
414  std::string username;
415  std::string password;
416  if (args->GetSize() != 4 ||
417      !args->GetString(0, &service_path) ||
418      !args->GetString(1, &apn) ||
419      !args->GetString(2, &username) ||
420      !args->GetString(3, &password)) {
421    NOTREACHED();
422    return;
423  }
424
425  chromeos::NetworkLibrary* cros =
426      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
427  chromeos::CellularNetwork* network =
428        cros->FindCellularNetworkByPath(service_path);
429  if (network) {
430    network->SetApn(chromeos::CellularNetwork::Apn(
431        apn, network->apn().network_id, username, password));
432  }
433}
434
435void InternetOptionsHandler::SetSimCardLockCallback(const ListValue* args) {
436  bool require_pin_new_value;
437  if (!args->GetBoolean(0, &require_pin_new_value)) {
438    NOTREACHED();
439    return;
440  }
441  // 1. Bring up SIM unlock dialog, pass new RequirePin setting in URL.
442  // 2. Dialog will ask for current PIN in any case.
443  // 3. If card is locked it will first call PIN unlock operation
444  // 4. Then it will call Set RequirePin, passing the same PIN.
445  // 5. We'll get notified by REQUIRE_PIN_SETTING_CHANGE_ENDED notification.
446  chromeos::SimDialogDelegate::SimDialogMode mode;
447  if (require_pin_new_value)
448    mode = chromeos::SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON;
449  else
450    mode = chromeos::SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF;
451  chromeos::SimDialogDelegate::ShowDialog(GetNativeWindow(), mode);
452}
453
454void InternetOptionsHandler::ChangePinCallback(const ListValue* args) {
455  chromeos::SimDialogDelegate::ShowDialog(GetNativeWindow(),
456      chromeos::SimDialogDelegate::SIM_DIALOG_CHANGE_PIN);
457}
458
459void InternetOptionsHandler::RefreshNetworkData(
460    chromeos::NetworkLibrary* cros) {
461  DictionaryValue dictionary;
462  FillNetworkInfo(&dictionary, cros);
463  web_ui_->CallJavascriptFunction(
464      "options.InternetOptions.refreshNetworkData", dictionary);
465}
466
467void InternetOptionsHandler::OnNetworkManagerChanged(
468    chromeos::NetworkLibrary* cros) {
469  if (!web_ui_)
470    return;
471  MonitorNetworks(cros);
472  RefreshNetworkData(cros);
473}
474
475void InternetOptionsHandler::OnNetworkChanged(
476    chromeos::NetworkLibrary* cros,
477    const chromeos::Network* network) {
478  if (web_ui_)
479    RefreshNetworkData(cros);
480}
481
482// Monitor wireless networks for changes. It is only necessary
483// to set up individual observers for the cellular networks
484// (if any) and for the connected Wi-Fi network (if any). The
485// only change we are interested in for Wi-Fi networks is signal
486// strength. For non-connected Wi-Fi networks, all information is
487// reported via scan results, which trigger network manager
488// updates. Only the connected Wi-Fi network has changes reported
489// via service property updates.
490void InternetOptionsHandler::MonitorNetworks(chromeos::NetworkLibrary* cros) {
491  cros->RemoveObserverForAllNetworks(this);
492  const chromeos::WifiNetwork* wifi_network = cros->wifi_network();
493  if (wifi_network != NULL)
494    cros->AddNetworkObserver(wifi_network->service_path(), this);
495  // Always monitor the cellular networks, if any, so that changes
496  // in network technology, roaming status, and signal strength
497  // will be shown.
498  const chromeos::CellularNetworkVector& cell_networks =
499      cros->cellular_networks();
500  for (size_t i = 0; i < cell_networks.size(); ++i) {
501    chromeos::CellularNetwork* cell_network = cell_networks[i];
502    cros->AddNetworkObserver(cell_network->service_path(), this);
503  }
504}
505
506void InternetOptionsHandler::OnCellularDataPlanChanged(
507    chromeos::NetworkLibrary* cros) {
508  if (!web_ui_)
509    return;
510  const chromeos::CellularNetwork* cellular = cros->cellular_network();
511  if (!cellular)
512    return;
513  const chromeos::CellularDataPlanVector* plans =
514      cros->GetDataPlans(cellular->service_path());
515  DictionaryValue connection_plans;
516  ListValue* plan_list = new ListValue();
517  if (plans) {
518    for (chromeos::CellularDataPlanVector::const_iterator iter = plans->begin();
519         iter != plans->end(); ++iter) {
520      plan_list->Append(CellularDataPlanToDictionary(*iter));
521    }
522  }
523  connection_plans.SetString("servicePath", cellular->service_path());
524  connection_plans.SetBoolean("needsPlan", cellular->needs_new_plan());
525  connection_plans.SetBoolean("activated",
526      cellular->activation_state() == chromeos::ACTIVATION_STATE_ACTIVATED);
527  connection_plans.Set("plans", plan_list);
528  SetActivationButtonVisibility(cellular, &connection_plans);
529  web_ui_->CallJavascriptFunction(
530      "options.InternetOptions.updateCellularPlans", connection_plans);
531}
532
533
534void InternetOptionsHandler::Observe(NotificationType type,
535                                     const NotificationSource& source,
536                                     const NotificationDetails& details) {
537  chromeos::CrosOptionsPageUIHandler::Observe(type, source, details);
538  if (type == NotificationType::REQUIRE_PIN_SETTING_CHANGE_ENDED) {
539    bool require_pin = *Details<bool>(details).ptr();
540    DictionaryValue dictionary;
541    dictionary.SetBoolean("requirePin", require_pin);
542    web_ui_->CallJavascriptFunction(
543        "options.InternetOptions.updateSecurityTab", dictionary);
544  } else if (type == NotificationType::ENTER_PIN_ENDED) {
545    // We make an assumption (which is valid for now) that the SIM
546    // unlock dialog is put up only when the user is trying to enable
547    // mobile data.
548    bool cancelled = *Details<bool>(details).ptr();
549    if (cancelled) {
550      chromeos::NetworkLibrary* cros =
551          chromeos::CrosLibrary::Get()->GetNetworkLibrary();
552      DictionaryValue dictionary;
553      FillNetworkInfo(&dictionary, cros);
554      web_ui_->CallJavascriptFunction(
555          "options.InternetOptions.setupAttributes", dictionary);
556    }
557    // The case in which the correct PIN was entered and the SIM is
558    // now unlocked is handled in NetworkMenuButton.
559  }
560}
561
562DictionaryValue* InternetOptionsHandler::CellularDataPlanToDictionary(
563    const chromeos::CellularDataPlan* plan) {
564  DictionaryValue* plan_dict = new DictionaryValue();
565  plan_dict->SetInteger("planType", plan->plan_type);
566  plan_dict->SetString("name", plan->plan_name);
567  plan_dict->SetString("planSummary", plan->GetPlanDesciption());
568  plan_dict->SetString("dataRemaining", plan->GetDataRemainingDesciption());
569  plan_dict->SetString("planExpires", plan->GetPlanExpiration());
570  plan_dict->SetString("warning", plan->GetRemainingWarning());
571  return plan_dict;
572}
573
574void InternetOptionsHandler::SetDetailsCallback(const ListValue* args) {
575  std::string service_path;
576  std::string auto_connect_str;
577
578  if (args->GetSize() < 2 ||
579      !args->GetString(0, &service_path) ||
580      !args->GetString(1, &auto_connect_str)) {
581    NOTREACHED();
582    return;
583  }
584
585  if (!chromeos::UserManager::Get()->current_user_is_owner()) {
586    LOG(WARNING) << "Non-owner tried to change a network.";
587    return;
588  }
589
590  chromeos::NetworkLibrary* cros =
591      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
592  chromeos::WifiNetwork* network = cros->FindWifiNetworkByPath(service_path);
593  if (!network)
594    return;
595
596  bool auto_connect = auto_connect_str == "true";
597  if (auto_connect != network->auto_connect())
598    network->SetAutoConnect(auto_connect);
599}
600
601void InternetOptionsHandler::PopulateDictionaryDetails(
602    const chromeos::Network* net, chromeos::NetworkLibrary* cros) {
603  DCHECK(net);
604  DictionaryValue dictionary;
605  std::string hardware_address;
606  chromeos::NetworkIPConfigVector ipconfigs = cros->GetIPConfigs(
607      net->device_path(), &hardware_address,
608      chromeos::NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
609  if (!hardware_address.empty())
610    dictionary.SetString("hardwareAddress", hardware_address);
611  scoped_ptr<ListValue> ipconfig_list(new ListValue());
612  for (chromeos::NetworkIPConfigVector::const_iterator it = ipconfigs.begin();
613       it != ipconfigs.end(); ++it) {
614    scoped_ptr<DictionaryValue> ipconfig_dict(new DictionaryValue());
615    const chromeos::NetworkIPConfig& ipconfig = *it;
616    ipconfig_dict->SetString("address", ipconfig.address);
617    ipconfig_dict->SetString("subnetAddress", ipconfig.netmask);
618    ipconfig_dict->SetString("gateway", ipconfig.gateway);
619    ipconfig_dict->SetString("dns", ipconfig.name_servers);
620    ipconfig_list->Append(ipconfig_dict.release());
621  }
622  dictionary.Set("ipconfigs", ipconfig_list.release());
623
624  chromeos::ConnectionType type = net->type();
625  dictionary.SetInteger("type", type);
626  dictionary.SetString("servicePath", net->service_path());
627  dictionary.SetBoolean("connecting", net->connecting());
628  dictionary.SetBoolean("connected", net->connected());
629  dictionary.SetString("connectionState", net->GetStateString());
630
631  if (type == chromeos::TYPE_WIFI) {
632    const chromeos::WifiNetwork* wifi =
633        cros->FindWifiNetworkByPath(net->service_path());
634    if (!wifi) {
635      LOG(WARNING) << "Cannot find network " << net->service_path();
636    } else {
637      PopulateWifiDetails(wifi, &dictionary);
638    }
639  } else if (type == chromeos::TYPE_CELLULAR) {
640    const chromeos::CellularNetwork* cellular =
641        cros->FindCellularNetworkByPath(net->service_path());
642    if (!cellular) {
643      LOG(WARNING) << "Cannot find network " << net->service_path();
644    } else {
645      PopulateCellularDetails(cros, cellular, &dictionary);
646    }
647  } else if (type == chromeos::TYPE_VPN) {
648    const chromeos::VirtualNetwork* vpn =
649        cros->FindVirtualNetworkByPath(net->service_path());
650    if (!vpn) {
651      LOG(WARNING) << "Cannot find network " << net->service_path();
652    } else {
653      PopulateVPNDetails(vpn, &dictionary);
654    }
655  }
656
657  web_ui_->CallJavascriptFunction(
658      "options.InternetOptions.showDetailedInfo", dictionary);
659}
660
661void InternetOptionsHandler::PopulateWifiDetails(
662    const chromeos::WifiNetwork* wifi,
663    DictionaryValue* dictionary) {
664  dictionary->SetString("ssid", wifi->name());
665  dictionary->SetBoolean("autoConnect", wifi->auto_connect());
666  dictionary->SetBoolean("encrypted", wifi->encrypted());
667}
668
669void InternetOptionsHandler::PopulateCellularDetails(
670    chromeos::NetworkLibrary* cros,
671    const chromeos::CellularNetwork* cellular,
672    DictionaryValue* dictionary) {
673  // Cellular network / connection settings.
674  dictionary->SetString("serviceName", cellular->name());
675  dictionary->SetString("networkTechnology",
676                        cellular->GetNetworkTechnologyString());
677  dictionary->SetString("operatorName", cellular->operator_name());
678  dictionary->SetString("operatorCode", cellular->operator_code());
679  dictionary->SetString("activationState",
680                        cellular->GetActivationStateString());
681  dictionary->SetString("roamingState",
682                        cellular->GetRoamingStateString());
683  dictionary->SetString("restrictedPool",
684                        cellular->restricted_pool() ?
685                        l10n_util::GetStringUTF8(
686                            IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL) :
687                        l10n_util::GetStringUTF8(
688                            IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL));
689  dictionary->SetString("errorState", cellular->GetErrorString());
690  dictionary->SetString("supportUrl", cellular->payment_url());
691  dictionary->SetBoolean("needsPlan", cellular->needs_new_plan());
692  dictionary->SetBoolean("gsm", cellular->is_gsm());
693  const chromeos::CellularNetwork::Apn& apn = cellular->apn();
694  dictionary->SetString("apn", apn.apn);
695  dictionary->SetString("apn_network_id", apn.network_id);
696  dictionary->SetString("apn_username", apn.username);
697  dictionary->SetString("apn_password", apn.password);
698  const chromeos::CellularNetwork::Apn& last_good_apn =
699      cellular->last_good_apn();
700  dictionary->SetString("last_good_apn", last_good_apn.apn);
701  dictionary->SetString("last_good_apn_network_id", last_good_apn.network_id);
702  dictionary->SetString("last_good_apn_username", last_good_apn.username);
703  dictionary->SetString("last_good_apn_password", last_good_apn.password);
704
705  // Device settings.
706  const chromeos::NetworkDevice* device =
707      cros->FindNetworkDeviceByPath(cellular->device_path());
708  if (device) {
709    dictionary->SetString("manufacturer", device->manufacturer());
710    dictionary->SetString("modelId", device->model_id());
711    dictionary->SetString("firmwareRevision", device->firmware_revision());
712    dictionary->SetString("hardwareRevision", device->hardware_revision());
713    dictionary->SetString("prlVersion",
714                          StringPrintf("%u", device->prl_version()));
715    dictionary->SetString("meid", device->meid());
716    dictionary->SetString("imei", device->imei());
717    dictionary->SetString("mdn", device->mdn());
718    dictionary->SetString("imsi", device->imsi());
719    dictionary->SetString("esn", device->esn());
720    dictionary->SetString("min", device->min());
721    dictionary->SetBoolean("simCardLockEnabled",
722        device->sim_pin_required() == chromeos::SIM_PIN_REQUIRED);
723
724    chromeos::ServicesCustomizationDocument* customization =
725        chromeos::ServicesCustomizationDocument::GetInstance();
726    if (customization->IsReady()) {
727      std::string carrier_id = cros->GetCellularHomeCarrierId();
728      const chromeos::ServicesCustomizationDocument::CarrierDeal* deal =
729          customization->GetCarrierDeal(carrier_id, false);
730      if (deal && !deal->top_up_url.empty())
731        dictionary->SetString("carrierUrl", deal->top_up_url);
732    }
733  }
734
735  SetActivationButtonVisibility(cellular, dictionary);
736}
737
738void InternetOptionsHandler::PopulateVPNDetails(
739    const chromeos::VirtualNetwork* vpn,
740    DictionaryValue* dictionary) {
741  // TODO(altimofeev): implement this.
742}
743
744void InternetOptionsHandler::SetActivationButtonVisibility(
745    const chromeos::CellularNetwork* cellular,
746    DictionaryValue* dictionary) {
747  if (cellular->needs_new_plan()) {
748    dictionary->SetBoolean("showBuyButton", true);
749  } else if (cellular->activation_state() !=
750                 chromeos::ACTIVATION_STATE_ACTIVATING &&
751             cellular->activation_state() !=
752                 chromeos::ACTIVATION_STATE_ACTIVATED) {
753    dictionary->SetBoolean("showActivateButton", true);
754  }
755}
756
757void InternetOptionsHandler::LoginCallback(const ListValue* args) {
758  std::string service_path;
759  std::string password;
760
761  if (args->GetSize() != 2 ||
762      !args->GetString(0, &service_path) ||
763      !args->GetString(1, &password)) {
764    NOTREACHED();
765    return;
766  }
767
768  chromeos::NetworkLibrary* cros =
769      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
770  cros->ConnectToWifiNetwork(service_path);
771}
772
773void InternetOptionsHandler::LoginCertCallback(const ListValue* args) {
774  std::string service_path;
775  std::string identity;
776  std::string certpath;
777  if (args->GetSize() < 3 ||
778      !args->GetString(0, &service_path) ||
779      !args->GetString(1, &certpath) ||
780      !args->GetString(2, &identity)) {
781    return;
782  }
783  chromeos::NetworkLibrary* cros =
784      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
785  chromeos::WifiNetwork* network = cros->FindWifiNetworkByPath(service_path);
786  if (network) {
787    std::string passphrase;
788    if (args->GetSize() == 4 && args->GetString(3, &passphrase))
789      network->SetPassphrase(passphrase);
790    cros->ConnectToWifiNetwork(network);
791  }
792}
793
794void InternetOptionsHandler::LoginToOtherCallback(const ListValue* args) {
795  std::string security;
796  std::string ssid;
797  std::string password;
798
799  if (args->GetSize() != 3 ||
800      !args->GetString(0, &security) ||
801      !args->GetString(1, &ssid) ||
802      !args->GetString(2, &password)) {
803    NOTREACHED();
804    return;
805  }
806
807  chromeos::ConnectionSecurity sec = chromeos::SECURITY_UNKNOWN;
808  if (security == "none") {
809    sec = chromeos::SECURITY_NONE;
810  } else if (security == "wep") {
811    sec = chromeos::SECURITY_WEP;
812  } else if (security == "wpa") {
813    sec = chromeos::SECURITY_WPA;
814  } else if (security == "rsn") {
815    sec = chromeos::SECURITY_RSN;
816  }
817
818  chromeos::NetworkLibrary* cros =
819      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
820
821  cros->ConnectToWifiNetwork(sec, ssid, password, std::string(), std::string());
822}
823
824void InternetOptionsHandler::CreateModalPopup(views::WindowDelegate* view) {
825  DCHECK(!use_settings_ui_);
826  views::Window* window = browser::CreateViewsWindow(GetNativeWindow(),
827                                                     gfx::Rect(),
828                                                     view);
829  window->SetIsAlwaysOnTop(true);
830  window->Show();
831}
832
833gfx::NativeWindow InternetOptionsHandler::GetNativeWindow() const {
834  // TODO(beng): This is an improper direct dependency on Browser. Route this
835  // through some sort of delegate.
836  Browser* browser = BrowserList::FindBrowserWithProfile(web_ui_->GetProfile());
837  return browser->window()->GetNativeHandle();
838}
839
840void InternetOptionsHandler::ButtonClickCallback(const ListValue* args) {
841  std::string str_type;
842  std::string service_path;
843  std::string command;
844  if (args->GetSize() != 3 ||
845      !args->GetString(0, &str_type) ||
846      !args->GetString(1, &service_path) ||
847      !args->GetString(2, &command)) {
848    NOTREACHED();
849    return;
850  }
851
852  int type = atoi(str_type.c_str());
853  if (type == chromeos::TYPE_ETHERNET) {
854    chromeos::NetworkLibrary* cros =
855        chromeos::CrosLibrary::Get()->GetNetworkLibrary();
856    const chromeos::EthernetNetwork* ether = cros->ethernet_network();
857    PopulateDictionaryDetails(ether, cros);
858  } else if (type == chromeos::TYPE_WIFI) {
859    HandleWifiButtonClick(service_path, command);
860  } else if (type == chromeos::TYPE_CELLULAR) {
861    HandleCellularButtonClick(service_path, command);
862  } else if (type == chromeos::TYPE_VPN) {
863    HandleVPNButtonClick(service_path, command);
864  } else {
865    NOTREACHED();
866  }
867}
868
869void InternetOptionsHandler::HandleWifiButtonClick(
870    const std::string& service_path,
871    const std::string& command) {
872  chromeos::NetworkLibrary* cros =
873      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
874  chromeos::WifiNetwork* wifi = NULL;
875  if (command == "forget") {
876    if (!chromeos::UserManager::Get()->current_user_is_owner()) {
877      LOG(WARNING) << "Non-owner tried to forget a network.";
878      return;
879    }
880    cros->ForgetWifiNetwork(service_path);
881  } else if (!use_settings_ui_ && service_path == kOtherNetworksFakePath) {
882    // Other wifi networks.
883    CreateModalPopup(new chromeos::NetworkConfigView(chromeos::TYPE_WIFI));
884  } else if ((wifi = cros->FindWifiNetworkByPath(service_path))) {
885    if (command == "connect") {
886      // Connect to wifi here. Open password page if appropriate.
887      if (wifi->IsPassphraseRequired()) {
888        if (use_settings_ui_) {
889          if (wifi->encryption() == chromeos::SECURITY_8021X) {
890            PopulateDictionaryDetails(wifi, cros);
891          } else {
892            DictionaryValue dictionary;
893            dictionary.SetString("servicePath", wifi->service_path());
894            web_ui_->CallJavascriptFunction(
895                "options.InternetOptions.showPasswordEntry", dictionary);
896          }
897        } else {
898          CreateModalPopup(new chromeos::NetworkConfigView(wifi));
899        }
900      } else {
901        cros->ConnectToWifiNetwork(wifi);
902      }
903    } else if (command == "disconnect") {
904      cros->DisconnectFromNetwork(wifi);
905    } else if (command == "options") {
906      PopulateDictionaryDetails(wifi, cros);
907    }
908  }
909}
910
911void InternetOptionsHandler::HandleCellularButtonClick(
912    const std::string& service_path,
913    const std::string& command) {
914  chromeos::NetworkLibrary* cros =
915      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
916  chromeos::CellularNetwork* cellular = NULL;
917  if (service_path == kOtherNetworksFakePath) {
918    chromeos::ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
919  } else if ((cellular = cros->FindCellularNetworkByPath(service_path))) {
920    if (command == "connect") {
921      cros->ConnectToCellularNetwork(cellular);
922    } else if (command == "disconnect") {
923      cros->DisconnectFromNetwork(cellular);
924    } else if (command == "activate") {
925      Browser* browser = BrowserList::GetLastActive();
926      if (browser)
927        browser->OpenMobilePlanTabAndActivate();
928    } else if (command == "options") {
929      PopulateDictionaryDetails(cellular, cros);
930    }
931  }
932}
933
934void InternetOptionsHandler::HandleVPNButtonClick(
935    const std::string& service_path,
936    const std::string& command) {
937  chromeos::NetworkLibrary* cros =
938      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
939  chromeos::VirtualNetwork* network = NULL;
940  // TODO(altimofeev): verify if service_path in condition is correct.
941  if (!use_settings_ui_ && service_path == kOtherNetworksFakePath) {
942    // Other VPN networks.
943    CreateModalPopup(new chromeos::NetworkConfigView(chromeos::TYPE_VPN));
944  } else if ((network = cros->FindVirtualNetworkByPath(service_path))) {
945    if (command == "connect") {
946      // Connect to VPN here. Open password page if appropriate.
947      if (network->NeedMoreInfoToConnect()) {
948        if (use_settings_ui_) {
949          // TODO(altimofeev): implement this.
950        } else {
951          CreateModalPopup(new chromeos::NetworkConfigView(network));
952        }
953      } else {
954        cros->ConnectToVirtualNetwork(network);
955      }
956    } else if (command == "disconnect") {
957      cros->DisconnectFromNetwork(network);
958    } else if (command == "options") {
959      PopulateDictionaryDetails(network, cros);
960    }
961  }
962}
963void InternetOptionsHandler::RefreshCellularPlanCallback(
964    const ListValue* args) {
965  std::string service_path;
966  if (args->GetSize() != 1 ||
967      !args->GetString(0, &service_path)) {
968    NOTREACHED();
969    return;
970  }
971  chromeos::NetworkLibrary* cros =
972      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
973  const chromeos::CellularNetwork* cellular =
974      cros->FindCellularNetworkByPath(service_path);
975  if (cellular)
976    cellular->RefreshDataPlansIfNeeded();
977}
978
979ListValue* InternetOptionsHandler::GetNetwork(
980    const std::string& service_path,
981    const SkBitmap& icon,
982    const std::string& name,
983    bool connecting,
984    bool connected,
985    bool connectable,
986    chromeos::ConnectionType connection_type,
987    bool remembered,
988    chromeos::ActivationState activation_state,
989    bool needs_new_plan) {
990  ListValue* network = new ListValue();
991
992  // 802.1X networks can be connected but not have saved credentials, and
993  // hence be "not configured".  Give preference to the "connected" and
994  // "connecting" states.  http://crosbug.com/14459
995  int connection_state = IDS_STATUSBAR_NETWORK_DEVICE_DISCONNECTED;
996  if (connected)
997    connection_state = IDS_STATUSBAR_NETWORK_DEVICE_CONNECTED;
998  else if (connecting)
999    connection_state = IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING;
1000  else if (!connectable)
1001    connection_state = IDS_STATUSBAR_NETWORK_DEVICE_NOT_CONFIGURED;
1002  std::string status = l10n_util::GetStringUTF8(connection_state);
1003  if (connection_type == chromeos::TYPE_CELLULAR) {
1004    if (needs_new_plan) {
1005      status = l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_NO_PLAN_LABEL);
1006    } else if (activation_state != chromeos::ACTIVATION_STATE_ACTIVATED) {
1007      status.append(" / ");
1008      status.append(
1009          chromeos::CellularNetwork::ActivationStateToString(activation_state));
1010    }
1011  }
1012
1013  // To keep the consistency with JS implementation, do not change the order
1014  // locally.
1015  // TODO(kochi): Use dictionaly for future maintainability.
1016  // 0) service path
1017  network->Append(Value::CreateStringValue(service_path));
1018  // 1) name
1019  network->Append(Value::CreateStringValue(name));
1020  // 2) status
1021  network->Append(Value::CreateStringValue(status));
1022  // 3) type
1023  network->Append(Value::CreateIntegerValue(static_cast<int>(connection_type)));
1024  // 4) connected
1025  network->Append(Value::CreateBooleanValue(connected));
1026  // 5) connecting
1027  network->Append(Value::CreateBooleanValue(connecting));
1028  // 6) icon data url
1029  network->Append(Value::CreateStringValue(icon.isNull() ? "" :
1030      web_ui_util::GetImageDataUrl(icon)));
1031  // 7) remembered
1032  network->Append(Value::CreateBooleanValue(remembered));
1033  // 8) activation state
1034  network->Append(Value::CreateIntegerValue(
1035                    static_cast<int>(activation_state)));
1036  // 9) needs new plan
1037  network->Append(Value::CreateBooleanValue(needs_new_plan));
1038  // 10) connectable
1039  network->Append(Value::CreateBooleanValue(connectable));
1040  return network;
1041}
1042
1043ListValue* InternetOptionsHandler::GetWiredList() {
1044  chromeos::NetworkLibrary* cros =
1045      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
1046  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
1047  ListValue* list = new ListValue();
1048
1049  // If ethernet is not enabled, then don't add anything.
1050  if (cros->ethernet_enabled()) {
1051    const chromeos::EthernetNetwork* ethernet_network =
1052        cros->ethernet_network();
1053    const SkBitmap* icon = rb.GetBitmapNamed(IDR_STATUSBAR_WIRED_BLACK);
1054    const SkBitmap* bottom_right_badge = !ethernet_network ||
1055        (!ethernet_network->connecting() && !ethernet_network->connected()) ?
1056            rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_DISCONNECTED) : NULL;
1057    const SkBitmap* bottom_left_badge =
1058        chromeos::NetworkMenu::BadgeForPrivateNetworkStatus(ethernet_network);
1059    if (ethernet_network) {
1060      list->Append(GetNetwork(
1061          ethernet_network->service_path(),
1062          chromeos::NetworkMenu::IconForDisplay(icon, bottom_right_badge, NULL,
1063                                                bottom_left_badge),
1064          l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET),
1065          ethernet_network->connecting(),
1066          ethernet_network->connected(),
1067          ethernet_network->connectable(),
1068          chromeos::TYPE_ETHERNET,
1069          false,
1070          chromeos::ACTIVATION_STATE_UNKNOWN,
1071          false));
1072    }
1073  }
1074  return list;
1075}
1076
1077ListValue* InternetOptionsHandler::GetWirelessList() {
1078  chromeos::NetworkLibrary* cros =
1079      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
1080  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
1081  ListValue* list = new ListValue();
1082
1083  const chromeos::Network* active_network = cros->active_network();
1084  bool has_vpn = active_network && cros->virtual_network();
1085  bool vpn_on_wireless = has_vpn &&
1086      active_network->type() == chromeos::TYPE_WIFI;
1087  const chromeos::WifiNetworkVector& wifi_networks = cros->wifi_networks();
1088  for (chromeos::WifiNetworkVector::const_iterator it =
1089      wifi_networks.begin(); it != wifi_networks.end(); ++it) {
1090    const SkBitmap* icon =
1091        chromeos::NetworkMenu::IconForNetworkStrength(*it, true);
1092    const SkBitmap* bottom_right_badge = (*it)->encrypted() ?
1093        rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE) : NULL;
1094    const SkBitmap* bottom_left_badge =
1095        vpn_on_wireless && active_network == (*it) ?
1096        chromeos::NetworkMenu::BadgeForPrivateNetworkStatus(NULL) : NULL;
1097    list->Append(GetNetwork(
1098        (*it)->service_path(),
1099        chromeos::NetworkMenu::IconForDisplay(icon, bottom_right_badge, NULL,
1100                                              bottom_left_badge),
1101        (*it)->name(),
1102        (*it)->connecting(),
1103        (*it)->connected(),
1104        (*it)->connectable(),
1105        chromeos::TYPE_WIFI,
1106        false,
1107        chromeos::ACTIVATION_STATE_UNKNOWN,
1108        false));
1109  }
1110
1111  // Add "Other WiFi network..." if wifi is enabled.
1112  if (cros->wifi_enabled()) {
1113    list->Append(GetNetwork(
1114        kOtherNetworksFakePath,
1115        *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS0_BLACK),
1116        l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_OTHER_WIFI_NETWORKS),
1117        false,
1118        false,
1119        true,
1120        chromeos::TYPE_WIFI,
1121        false,
1122        chromeos::ACTIVATION_STATE_UNKNOWN,
1123        false));
1124  }
1125
1126  bool vpn_on_cellular = has_vpn &&
1127                         active_network->type() == chromeos::TYPE_CELLULAR;
1128  const chromeos::CellularNetworkVector cellular_networks =
1129      cros->cellular_networks();
1130  for (chromeos::CellularNetworkVector::const_iterator it =
1131      cellular_networks.begin(); it != cellular_networks.end(); ++it) {
1132    const SkBitmap* icon =
1133        chromeos::NetworkMenu::IconForNetworkStrength(*it, true);
1134    const SkBitmap* bottom_right_badge =
1135        chromeos::NetworkMenu::BadgeForNetworkTechnology(*it);
1136    const SkBitmap* roaming_badge =
1137        chromeos::NetworkMenu::BadgeForRoamingStatus(*it);
1138    const SkBitmap* bottom_left_badge =
1139        vpn_on_cellular && active_network == (*it) ?
1140        chromeos::NetworkMenu::BadgeForPrivateNetworkStatus(NULL) : NULL;
1141    list->Append(GetNetwork(
1142        (*it)->service_path(),
1143        chromeos::NetworkMenu::IconForDisplay(icon, bottom_right_badge,
1144                                              roaming_badge, bottom_left_badge),
1145        (*it)->name(),
1146        (*it)->connecting(),
1147        (*it)->connected(),
1148        (*it)->connectable(),
1149        chromeos::TYPE_CELLULAR,
1150        false,
1151        (*it)->activation_state(),
1152        (*it)->SupportsDataPlan() && (*it)->restricted_pool()));
1153  }
1154
1155  const chromeos::NetworkDevice* cellular_device = cros->FindCellularDevice();
1156  if (cellular_device && cellular_device->support_network_scan() &&
1157      cros->cellular_enabled()) {
1158    list->Append(GetNetwork(
1159        kOtherNetworksFakePath,
1160        *rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS0_BLACK),
1161        l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_OTHER_CELLULAR_NETWORKS),
1162        false,
1163        false,
1164        true,
1165        chromeos::TYPE_CELLULAR,
1166        false,
1167        chromeos::ACTIVATION_STATE_ACTIVATED,
1168        false));
1169  }
1170
1171  return list;
1172}
1173
1174ListValue* InternetOptionsHandler::GetRememberedList() {
1175  chromeos::NetworkLibrary* cros =
1176      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
1177  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
1178  ListValue* list = new ListValue();
1179
1180  const chromeos::WifiNetworkVector& remembered_wifi_networks =
1181      cros->remembered_wifi_networks();
1182  const chromeos::Network* active_network = cros->active_network();
1183  bool vpn_on_wireless = active_network && cros->virtual_network() &&
1184                         active_network->type() == chromeos::TYPE_WIFI;
1185
1186  for (chromeos::WifiNetworkVector::const_iterator rit =
1187           remembered_wifi_networks.begin();
1188       rit != remembered_wifi_networks.end(); ++rit) {
1189    chromeos::WifiNetwork* remembered = *rit;
1190    chromeos::Network* network = cros->FindNetworkFromRemembered(remembered);
1191
1192    const SkBitmap* icon = network ?
1193        chromeos::NetworkMenu::IconForNetworkStrength(
1194            static_cast<chromeos::WifiNetwork*>(network), true) :
1195        rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_BARS0_BLACK);
1196    // Place the secure badge on the icon if the remembered network is
1197    // encrypted (the matching detected network, if any, will have the same
1198    // encrypted property by definition).
1199    const SkBitmap* bottom_right_badge = remembered->encrypted() ?
1200        rb.GetBitmapNamed(IDR_STATUSBAR_NETWORK_SECURE) : NULL;
1201    const SkBitmap* bottom_left_badge =
1202        vpn_on_wireless && active_network == network ?
1203        chromeos::NetworkMenu::BadgeForPrivateNetworkStatus(NULL) : NULL;
1204    list->Append(GetNetwork(
1205        remembered->service_path(),
1206        chromeos::NetworkMenu::IconForDisplay(icon, bottom_right_badge, NULL,
1207                                              bottom_left_badge),
1208        remembered->name(),
1209        network ? network->connecting() : false,
1210        network ? network->connected() : false,
1211        true,
1212        chromeos::TYPE_WIFI,
1213        true,
1214        chromeos::ACTIVATION_STATE_UNKNOWN,
1215        false));
1216  }
1217  return list;
1218}
1219
1220void InternetOptionsHandler::FillNetworkInfo(
1221    DictionaryValue* dictionary, chromeos::NetworkLibrary* cros) {
1222  dictionary->SetBoolean("accessLocked", cros->IsLocked());
1223  dictionary->Set("wiredList", GetWiredList());
1224  dictionary->Set("wirelessList", GetWirelessList());
1225  dictionary->Set("rememberedList", GetRememberedList());
1226  dictionary->SetBoolean("wifiAvailable", cros->wifi_available());
1227  dictionary->SetBoolean("wifiEnabled", cros->wifi_enabled());
1228  dictionary->SetBoolean("cellularAvailable", cros->cellular_available());
1229  dictionary->SetBoolean("cellularEnabled", cros->cellular_enabled());
1230}
1231