network_list.js should reflect the correct logged in user type.

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

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 117 matching lines @@
 const char kRefreshNetworkDataFunction[] =
     "options.network.NetworkList.refreshNetworkData";
 const char kSetDefaultNetworkIconsFunction[] =
     "options.network.NetworkList.setDefaultNetworkIcons";
 const char kShowDetailedInfoFunction[] =
     "options.internet.DetailsInternetPage.showDetailedInfo";
 const char kUpdateConnectionDataFunction[] =
     "options.internet.DetailsInternetPage.updateConnectionData";
 const char kUpdateCarrierFunction[] =
     "options.internet.DetailsInternetPage.updateCarrier";
+const char kUpdateLoggedInUserTypeFunction[] =
+    "options.network.NetworkList.updateLoggedInUserType";
 const char kUpdateSecurityTabFunction[] =
     "options.internet.DetailsInternetPage.updateSecurityTab";
 
 // These are used to register message handlers with JavaScript.
 const char kBuyDataPlanMessage[] = "buyDataPlan";
 const char kChangePinMessage[] = "changePin";
 const char kDisableCellularMessage[] = "disableCellular";
 const char kDisableWifiMessage[] = "disableWifi";
 const char kDisableWimaxMessage[] = "disableWimax";
 const char kEnableCellularMessage[] = "enableCellular";
@@ skipping 186 matching lines @@
     id = IDS_CHROMEOS_NETWORK_STATE_ACTIVATION_FAILURE;
   else if (state == flimflam::kStatePortal)
     id = IDS_CHROMEOS_NETWORK_STATE_PORTAL;
   else if (state == flimflam::kStateOnline)
     id = IDS_CHROMEOS_NETWORK_STATE_ONLINE;
   else
     id = IDS_CHROMEOS_NETWORK_STATE_UNRECOGNIZED;
   return l10n_util::GetStringUTF8(id);
 }
 
+std::string LoggedInUserTypeToString(
+    LoginState::LoggedInUserType type) {
+  switch (type) {
+    case LoginState::LOGGED_IN_USER_NONE:
+      return "none";
+    case LoginState::LOGGED_IN_USER_REGULAR:
+      return "regular";
+    case LoginState::LOGGED_IN_USER_OWNER:
+      return "owner";
+    case LoginState::LOGGED_IN_USER_GUEST:
+      return "guest";
+    case LoginState::LOGGED_IN_USER_RETAIL_MODE:
+      return "retail-mode";
+    case LoginState::LOGGED_IN_USER_PUBLIC_ACCOUNT:
+      return "public-account";
+    case LoginState::LOGGED_IN_USER_LOCALLY_MANAGED:
+      return "locally-managed";
+    case LoginState::LOGGED_IN_USER_KIOSK_APP:
+      return "kiosk-app";
+    default:
+      return "";
+  }
+}
+
 std::string EncryptionString(const std::string& security,
                              const std::string& eap_method) {
   if (security == flimflam::kSecurityNone)
     return "";
   if (security == flimflam::kSecurityWpa)
     return "WPA";
   if (security == flimflam::kSecurityWep)
     return "WEP";
   if (security == flimflam::kSecurityRsn)
     return "RSN";
@@ skipping 416 matching lines @@
 
 }  // namespace
 
 InternetOptionsHandler::InternetOptionsHandler()
     : weak_factory_(this) {
   registrar_.Add(this, chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_ENTER_PIN_ENDED,
                  content::NotificationService::AllSources());
   NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
+  LoginState::Get()->AddObserver(this);
 }
 
 InternetOptionsHandler::~InternetOptionsHandler() {
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
         this, FROM_HERE);
   }
+  if (LoginState::Get()->IsInitialized())
+    LoginState::Get()->RemoveObserver(this);
 }
 
 void InternetOptionsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
 
     // Main settings page.
 
@@ skipping 163 matching lines @@
   dictionary.SetString(kTagCellular,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK));
   dictionary.SetString(kTagWifi,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK));
   dictionary.SetString(kTagVpn,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_VPN));
   web_ui()->CallJavascriptFunction(kSetDefaultNetworkIconsFunction,
                                    dictionary);
   NetworkHandler::Get()->network_state_handler()->RequestScan();
   RefreshNetworkData();
+  UpdateLoggedInUserType();
 }
 
 void InternetOptionsHandler::RegisterMessages() {
   // Setup handlers specific to this panel.
   web_ui()->RegisterMessageCallback(kNetworkCommandMessage,
       base::Bind(&InternetOptionsHandler::NetworkCommandCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kRefreshNetworksMessage,
       base::Bind(&InternetOptionsHandler::RefreshNetworksCallback,
                  base::Unretained(this)));
@@ skipping 328 matching lines @@
 }
 
 void InternetOptionsHandler::NetworkPropertiesUpdated(
     const NetworkState* network) {
   if (!web_ui())
     return;
   RefreshNetworkData();
   UpdateConnectionData(network->path());
 }
 
+void InternetOptionsHandler::LoggedInStateChanged(
+    LoginState::LoggedInState state) {
+  UpdateLoggedInUserType();
+}
+
+void InternetOptionsHandler::UpdateLoggedInUserType() {
+  if (web_ui()) {

[stevenjb, 2013/09/10 16:58:05]

nit: if (!web_ui()) return;

[armansito, 2013/09/10 21:55:19]

Done.

+    base::StringValue login_type(
+        LoggedInUserTypeToString(LoginState::Get()->GetLoggedInUserType()));
+    web_ui()->CallJavascriptFunction(
+        kUpdateLoggedInUserTypeFunction, login_type);
+  }
+}
+
 void InternetOptionsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   OptionsPageUIHandler::Observe(type, source, details);
   if (type == chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED) {
     base::FundamentalValue require_pin(*content::Details<bool>(details).ptr());
     web_ui()->CallJavascriptFunction(
         kUpdateSecurityTabFunction, require_pin);
   } else if (type == chrome::NOTIFICATION_ENTER_PIN_ENDED) {
@@ skipping 707 matching lines @@
       cellular && cellular->support_network_scan());
 
   dictionary->SetBoolean(kTagWimaxAvailable,
                          handler->IsTechnologyAvailable(flimflam::kTypeWimax));
   dictionary->SetBoolean(kTagWimaxEnabled,
                          handler->IsTechnologyEnabled(flimflam::kTypeWimax));
 }
 
 }  // namespace options
 }  // namespace chromeos