Remove additional dependencies from InternetOptionsHandler

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>
 #include <vector>
 
 #include "ash/system/chromeos/network/network_connect.h"
 #include "ash/system/chromeos/network/network_icon.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/net/onc_utils.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
-#include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 38 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 60 matching lines @@
 const char kTagTrue[] = "true";
 const char kTagUsername[] = "username";
 const char kTagValue[] = "value";
 const char kTagVpnList[] = "vpnList";
 const char kTagWifiAvailable[] = "wifiAvailable";
 const char kTagWifiEnabled[] = "wifiEnabled";
 const char kTagWimaxAvailable[] = "wimaxAvailable";
 const char kTagWimaxEnabled[] = "wimaxEnabled";
 const char kTagWiredList[] = "wiredList";
 const char kTagWirelessList[] = "wirelessList";
-const char kTagLoggedInUserNone[] = "none";
-const char kTagLoggedInUserRegular[] = "regular";
-const char kTagLoggedInUserOwner[] = "owner";
-const char kTagLoggedInUserGuest[] = "guest";
-const char kTagLoggedInUserRetailMode[] = "retail-mode";
-const char kTagLoggedInUserPublicAccount[] = "public-account";
-const char kTagLoggedInUserLocallyManaged[] = "locally-managed";
-const char kTagLoggedInUserKioskApp[] = "kiosk-app";
 
 const int kPreferredPriority = 1;
 
 void ShillError(const std::string& function,
                 const std::string& error_name,
                 scoped_ptr<base::DictionaryValue> error_data) {
   // UpdateConnectionData may send requests for stale services; ignore
   // these errors.
   if (function == "UpdateConnectionData" &&
       error_name == network_handler::kDBusFailedError)
@@ skipping 12 matching lines @@
                         base::Value* value) {
   NET_LOG_EVENT("SetNetworkProperty: " + property, service_path);
   base::DictionaryValue properties;
   properties.SetWithoutPathExpansion(property, value);
   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
       service_path, properties,
       base::Bind(&base::DoNothing),
       base::Bind(&ShillError, "SetNetworkProperty"));
 }
 
-std::string LoggedInUserTypeToJSString(LoginState::LoggedInUserType type) {
-  switch (type) {
-    case LoginState::LOGGED_IN_USER_NONE:
-      return kTagLoggedInUserNone;
-    case LoginState::LOGGED_IN_USER_REGULAR:
-      return kTagLoggedInUserRegular;
-    case LoginState::LOGGED_IN_USER_OWNER:
-      return kTagLoggedInUserOwner;
-    case LoginState::LOGGED_IN_USER_GUEST:
-      return kTagLoggedInUserGuest;
-    case LoginState::LOGGED_IN_USER_RETAIL_MODE:
-      return kTagLoggedInUserRetailMode;
-    case LoginState::LOGGED_IN_USER_PUBLIC_ACCOUNT:
-      return kTagLoggedInUserPublicAccount;
-    case LoginState::LOGGED_IN_USER_LOCALLY_MANAGED:
-      return kTagLoggedInUserLocallyManaged;
-    case LoginState::LOGGED_IN_USER_KIOSK_APP:
-      return kTagLoggedInUserKioskApp;
-  }
-  NOTREACHED();
-  return std::string();
-}
-
 // Builds a dictionary with network information and an icon used for the
 // NetworkList on the settings page. Ownership of the returned pointer is
 // transferred to the caller.
 base::DictionaryValue* BuildNetworkDictionary(
     const NetworkState* network,
     float icon_scale_factor,
     const PrefService* profile_prefs) {
   scoped_ptr<base::DictionaryValue> network_info =
       network_util::TranslateNetworkStateToONC(network);
 
@@ skipping 273 matching lines @@
   // These default to empty and are only set if device != NULL.
   std::string carrier_id;
   std::string mdn;
 
   // Device settings.
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           cellular->device_path());
   if (device) {
     const base::DictionaryValue& device_properties = device->properties();
-    const NetworkPropertyUIData cellular_property_ui_data(
-        cellular->ui_data().onc_source());
+    ::onc::ONCSource onc_source;
+    NetworkHandler::Get()->managed_network_configuration_handler()->
+        FindPolicyByGUID(LoginState::Get()->primary_user_hash(),
+                         cellular->guid(), &onc_source);
+    const NetworkPropertyUIData cellular_property_ui_data(onc_source);
     SetValueDictionary(dictionary,
                        kTagSimCardLockEnabled,
                        new base::FundamentalValue(device->sim_lock_enabled()),
                        cellular_property_ui_data);
 
     carrier_id = device->home_provider_id();
     device_properties.GetStringWithoutPathExpansion(shill::kMdnProperty, &mdn);
 
     MobileConfig* config = MobileConfig::GetInstance();
     if (config->IsReady()) {
@@ skipping 14 matching lines @@
           base::DictionaryValue* apn = new base::DictionaryValue;
           CreateDictionaryFromCellularApn(dict, apn);
           apn_list_value->Append(apn);
         }
       }
     }
     SetValueDictionary(dictionary,
                        kTagProviderApnList,
                        apn_list_value,
                        cellular_property_ui_data);
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
-            chromeos::switches::kEnableCarrierSwitching)) {
-      const base::ListValue* supported_carriers;
-      if (device_properties.GetListWithoutPathExpansion(
-              shill::kSupportedCarriersProperty, &supported_carriers)) {
-        dictionary->Set(kTagCarriers, supported_carriers->DeepCopy());
-        dictionary->SetInteger(
-            kTagCurrentCarrierIndex,
-            FindCurrentCarrierIndex(supported_carriers, device));
-      } else {
-        // In case of any error, set the current carrier tag to -1 indicating
-        // to the JS code to fallback to a single carrier.
-        dictionary->SetInteger(kTagCurrentCarrierIndex, -1);
-      }
+    const base::ListValue* supported_carriers;
+    if (device_properties.GetListWithoutPathExpansion(
+            shill::kSupportedCarriersProperty, &supported_carriers)) {
+      dictionary->Set(kTagCarriers, supported_carriers->DeepCopy());
+      dictionary->SetInteger(
+          kTagCurrentCarrierIndex,
+          FindCurrentCarrierIndex(supported_carriers, device));
+    } else {
+      // In case of any error, set the current carrier tag to -1 indicating
+      // to the JS code to fallback to a single carrier.
+      dictionary->SetInteger(kTagCurrentCarrierIndex, -1);
     }
   }
 
   // Don't show any account management related buttons if the activation
   // state is unknown or no payment portal URL is available.
   std::string support_url;
   if (cellular->activation_state() == shill::kActivationStateUnknown ||
       !dictionary->GetString(kTagSupportUrl, &support_url) ||
       support_url.empty()) {
     VLOG(2) << "No support URL is available. Don't display buttons.";
@@ skipping 136 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);
   internet_options_strings::RegisterLocalizedStrings(localized_strings);
 
+  // TODO(stevenjb): Find a better way to populate initial data before
+  // InitializePage() gets called.
   std::string owner;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
   localized_strings->SetString("ownerUserId", base::UTF8ToUTF16(owner));
+  bool logged_in_as_owner = LoginState::Get()->GetLoggedInUserType() ==
+                            LoginState::LOGGED_IN_USER_OWNER;
+  localized_strings->SetBoolean("loggedInAsOwner", logged_in_as_owner);
 
   base::DictionaryValue* network_dictionary = new base::DictionaryValue;
   FillNetworkInfo(network_dictionary);
   localized_strings->Set("networkData", network_dictionary);
 }
 
 void InternetOptionsHandler::InitializePage() {
   base::DictionaryValue dictionary;
   dictionary.SetString(::onc::network_type::kCellular,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_BARS_DARK));
   dictionary.SetString(::onc::network_type::kWiFi,
       GetIconDataUrl(IDR_AURA_UBER_TRAY_NETWORK_ARCS_DARK));
   dictionary.SetString(::onc::network_type::kVPN,
       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 318 matching lines @@
 }
 
 void InternetOptionsHandler::NetworkPropertiesUpdated(
     const NetworkState* network) {
   if (!web_ui())
     return;
   RefreshNetworkData();
   UpdateConnectionData(network->path());
 }
 
-void InternetOptionsHandler::LoggedInStateChanged() {
-  UpdateLoggedInUserType();
-}
-
-void InternetOptionsHandler::UpdateLoggedInUserType() {
-  if (!web_ui())
-    return;
-  base::StringValue login_type(
-      LoggedInUserTypeToJSString(LoginState::Get()->GetLoggedInUserType()));
-  web_ui()->CallJavascriptFunction(kUpdateLoggedInUserTypeFunction, login_type);
-}
-
 void InternetOptionsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& 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) {
     // We make an assumption (which is valid for now) that the SIM
@@ skipping 462 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos