Disable UI in chrome://settings/internet and details popup for policy-managed networks.

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

 // Copyright (c) 2011 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 52 matching lines @@
 const char kNetworkInfoKeyConnectable[] = "connectable";
 const char kNetworkInfoKeyConnected[] = "connected";
 const char kNetworkInfoKeyConnecting[] = "connecting";
 const char kNetworkInfoKeyIconURL[] = "iconURL";
 const char kNetworkInfoKeyNeedsNewPlan[] = "needs_new_plan";
 const char kNetworkInfoKeyNetworkName[] = "networkName";
 const char kNetworkInfoKeyNetworkStatus[] = "networkStatus";
 const char kNetworkInfoKeyNetworkType[] = "networkType";
 const char kNetworkInfoKeyRemembered[] = "remembered";
 const char kNetworkInfoKeyServicePath[] = "servicePath";
+const char kNetworkInfoKeyPolicyManaged[] = "policyManaged";
 
 // A helper class for building network information dictionaries to be sent to
 // the webui code.
 class NetworkInfoDictionary {
  public:
   // Initializes the dictionary with default values.
   NetworkInfoDictionary();
 
   // Copies in service path, connect{ing|ed|able} flags and connection type from
   // the provided network object. Also chooses an appropriate icon based on the
@@ skipping 33 matching lines @@
   }
   void set_shared(bool shared) {
     shared_ = shared;
   }
   void set_activation_state(chromeos::ActivationState activation_state) {
     activation_state_ = activation_state;
   }
   void set_needs_new_plan(bool needs_new_plan) {
     needs_new_plan_ = needs_new_plan;
   }
+  void set_policy_managed(bool policy_managed) {
+    policy_managed_ = policy_managed;
+  }
 
   // Builds the DictionaryValue representation from the previously set
   // parameters. Ownership of the returned pointer is transferred to the caller.
   DictionaryValue* BuildDictionary();
 
  private:
   // Values to be filled into the dictionary.
   std::string service_path_;
   std::string icon_url_;
   std::string name_;
   bool connecting_;
   bool connected_;
   bool connectable_;
   chromeos::ConnectionType connection_type_;
   bool remembered_;
   bool shared_;
   chromeos::ActivationState activation_state_;
   bool needs_new_plan_;
+  bool policy_managed_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkInfoDictionary);
 };
 
 NetworkInfoDictionary::NetworkInfoDictionary() {
   set_connecting(false);
   set_connected(false);
   set_connectable(false);
   set_remembered(false);
   set_shared(false);
   set_activation_state(chromeos::ACTIVATION_STATE_UNKNOWN);
   set_needs_new_plan(false);
+  set_policy_managed(false);
 }
 
 NetworkInfoDictionary::NetworkInfoDictionary(const chromeos::Network* network) {
   set_service_path(network->service_path());
   set_icon(chromeos::NetworkMenuIcon::GetBitmap(network));
   set_name(network->name());
   set_connecting(network->connecting());
   set_connected(network->connected());
   set_connectable(network->connectable());
   set_connection_type(network->type());
   set_remembered(false);
   set_shared(false);
   set_needs_new_plan(false);
+  set_policy_managed(chromeos::NetworkUIData::IsManaged(network));
 }
 
 NetworkInfoDictionary::NetworkInfoDictionary(
     const chromeos::Network* network,
     const chromeos::Network* remembered) {
   set_service_path(remembered->service_path());
   set_icon(
       chromeos::NetworkMenuIcon::GetBitmap(network ? network : remembered));
   set_name(remembered->name());
   set_connecting(network ? network->connecting() : false);
   set_connected(network ? network->connected() : false);
   set_connectable(true);
   set_connection_type(remembered->type());
   set_remembered(true);
   set_shared(remembered->profile_type() == chromeos::PROFILE_SHARED);
   set_needs_new_plan(false);
+  set_policy_managed(
+      network ? chromeos::NetworkUIData::IsManaged(network) : false);
 }
 
 DictionaryValue* NetworkInfoDictionary::BuildDictionary() {
   std::string status;
 
   if (remembered_) {
     if (shared_)
       status = l10n_util::GetStringUTF8(IDS_OPTIONS_SETTINGS_SHARED_NETWORK);
   } else {
     // 802.1X networks can be connected but not have saved credentials, and
@@ skipping 25 matching lines @@
   network_info->SetBoolean(kNetworkInfoKeyConnected, connected_);
   network_info->SetBoolean(kNetworkInfoKeyConnecting, connecting_);
   network_info->SetString(kNetworkInfoKeyIconURL, icon_url_);
   network_info->SetBoolean(kNetworkInfoKeyNeedsNewPlan, needs_new_plan_);
   network_info->SetString(kNetworkInfoKeyNetworkName, name_);
   network_info->SetString(kNetworkInfoKeyNetworkStatus, status);
   network_info->SetInteger(kNetworkInfoKeyNetworkType,
                            static_cast<int>(connection_type_));
   network_info->SetBoolean(kNetworkInfoKeyRemembered, remembered_);
   network_info->SetString(kNetworkInfoKeyServicePath, service_path_);
+  network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, policy_managed_);
 
   return network_info.release();
 }
 
 }  // namespace
 
 InternetOptionsHandler::InternetOptionsHandler() {
   registrar_.Add(this, chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_ENTER_PIN_ENDED,
@@ skipping 50 matching lines @@
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_ACTIVATE));
   localized_strings->SetString("buyplan_button",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_BUY_PLAN));
 
   localized_strings->SetString("changeProxyButton",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_CHANGE_PROXY_BUTTON));
 
+  localized_strings->SetString("managedNetwork",
+      l10n_util::GetStringUTF16(IDS_OPTIONS_SETTINGS_MANAGED_NETWORK));
+
   localized_strings->SetString("wifiNetworkTabLabel",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_TAB_WIFI));
   localized_strings->SetString("vpnTabLabel",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_TAB_VPN));
   localized_strings->SetString("cellularPlanTabLabel",
       l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_TAB_PLAN));
   localized_strings->SetString("cellularConnTabLabel",
@@ skipping 565 matching lines @@
         network->service_path());
   }
 
   DictionaryValue dictionary;
   std::string hardware_address;
   chromeos::NetworkIPConfigVector ipconfigs = cros_->GetIPConfigs(
       network->device_path(), &hardware_address,
       chromeos::NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
   if (!hardware_address.empty())
     dictionary.SetString("hardwareAddress", hardware_address);
+
+  scoped_ptr<DictionaryValue> ipconfig_dhcp;
+  scoped_ptr<DictionaryValue> ipconfig_static;
   for (chromeos::NetworkIPConfigVector::const_iterator it = ipconfigs.begin();
        it != ipconfigs.end(); ++it) {
     const chromeos::NetworkIPConfig& ipconfig = *it;
     scoped_ptr<DictionaryValue> ipconfig_dict(new DictionaryValue());
     ipconfig_dict->SetString("address", ipconfig.address);
     ipconfig_dict->SetString("subnetAddress", ipconfig.netmask);
     ipconfig_dict->SetString("gateway", ipconfig.gateway);
     ipconfig_dict->SetString("dns", ipconfig.name_servers);
     if (ipconfig.type == chromeos::IPCONFIG_TYPE_DHCP)
-      dictionary.Set("ipconfigDHCP", ipconfig_dict.release());
+      ipconfig_dhcp.reset(ipconfig_dict.release());
     else if (ipconfig.type == chromeos::IPCONFIG_TYPE_IPV4)
-      dictionary.Set("ipconfigStatic", ipconfig_dict.release());
+      ipconfig_static.reset(ipconfig_dict.release());
   }
 
+  chromeos::NetworkPropertyUIData ipconfig_dhcp_ui_data(network, NULL);
+  SetValueDictionary(&dictionary, "ipconfigDHCP", ipconfig_dhcp.release(),
+                     ipconfig_dhcp_ui_data);
+  chromeos::NetworkPropertyUIData ipconfig_static_ui_data(network, NULL);
+  SetValueDictionary(&dictionary, "ipconfigStatic", ipconfig_static.release(),
+                     ipconfig_static_ui_data);
+
   chromeos::ConnectionType type = network->type();
   dictionary.SetInteger("type", type);
   dictionary.SetString("servicePath", network->service_path());
   dictionary.SetBoolean("connecting", network->connecting());
   dictionary.SetBoolean("connected", network->connected());
   dictionary.SetString("connectionState", network->GetStateString());
 
   // Only show proxy for remembered networks.
   chromeos::NetworkProfileType network_profile = network->profile_type();
   dictionary.SetBoolean("showProxy", network_profile != chromeos::PROFILE_NONE);
 
   // Hide the dhcp/static radio if not ethernet or wifi (or if not enabled)
   bool staticIPConfig = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableStaticIPConfig);
   dictionary.SetBoolean("showStaticIPConfig", staticIPConfig &&
       (type == chromeos::TYPE_WIFI || type == chromeos::TYPE_ETHERNET));
 
+  chromeos::NetworkPropertyUIData preferred_ui_data(
+      network, chromeos::NetworkUIData::kPropertyPreferred);
   if (network_profile == chromeos::PROFILE_USER) {
     dictionary.SetBoolean("showPreferred", true);
-    dictionary.SetBoolean("preferred", network->preferred());
+    SetValueDictionary(&dictionary, "preferred",
+                       Value::CreateBooleanValue(network->preferred()),
+                       preferred_ui_data);
   } else {
     dictionary.SetBoolean("showPreferred", false);
-    dictionary.SetBoolean("preferred", false);
+    SetValueDictionary(&dictionary, "preferred",
+                       Value::CreateBooleanValue(network->preferred()),
+                       preferred_ui_data);
   }
-  dictionary.SetBoolean("autoConnect", network->auto_connect());
+  chromeos::NetworkPropertyUIData auto_connect_ui_data(
+      network, chromeos::NetworkUIData::kPropertyAutoConnect);
+  SetValueDictionary(&dictionary, "autoConnect",
+                     Value::CreateBooleanValue(network->auto_connect()),
+                     auto_connect_ui_data);
 
   if (type == chromeos::TYPE_WIFI) {
     dictionary.SetBoolean("deviceConnected", cros_->wifi_connected());
     const chromeos::WifiNetwork* wifi =
         cros_->FindWifiNetworkByPath(network->service_path());
     if (!wifi) {
       LOG(WARNING) << "Cannot find network " << network->service_path();
     } else {
       PopulateWifiDetails(wifi, &dictionary);
     }
@@ skipping 72 matching lines @@
   dictionary->SetBoolean("needsPlan", cellular->needs_new_plan());
 
   dictionary->Set("apn", CreateDictionaryFromCellularApn(cellular->apn()));
   dictionary->Set("lastGoodApn",
                   CreateDictionaryFromCellularApn(cellular->last_good_apn()));
 
   // Device settings.
   const chromeos::NetworkDevice* device =
       cros_->FindNetworkDeviceByPath(cellular->device_path());
   if (device) {
+    chromeos::NetworkPropertyUIData cellular_propety_ui_data(cellular, NULL);
     dictionary->SetString("manufacturer", device->manufacturer());
     dictionary->SetString("modelId", device->model_id());
     dictionary->SetString("firmwareRevision", device->firmware_revision());
     dictionary->SetString("hardwareRevision", device->hardware_revision());
     dictionary->SetString("prlVersion",
                           base::StringPrintf("%u", device->prl_version()));
     dictionary->SetString("meid", device->meid());
     dictionary->SetString("imei", device->imei());
     dictionary->SetString("mdn", device->mdn());
     dictionary->SetString("imsi", device->imsi());
     dictionary->SetString("esn", device->esn());
     dictionary->SetString("min", device->min());
     dictionary->SetBoolean("gsm",
         device->technology_family() == chromeos::TECHNOLOGY_FAMILY_GSM);
-    dictionary->SetBoolean("simCardLockEnabled",
-        device->sim_pin_required() == chromeos::SIM_PIN_REQUIRED);
+    SetValueDictionary(
+        dictionary, "simCardLockEnabled",
+        Value::CreateBooleanValue(
+            device->sim_pin_required() == chromeos::SIM_PIN_REQUIRED),
+        cellular_propety_ui_data);
 
     chromeos::MobileConfig* config = chromeos::MobileConfig::GetInstance();
     if (config->IsReady()) {
       std::string carrier_id = cros_->GetCellularHomeCarrierId();
       const chromeos::MobileConfig::Carrier* carrier =
           config->GetCarrier(carrier_id);
       if (carrier && !carrier->top_up_url().empty())
         dictionary->SetString("carrierUrl", carrier->top_up_url());
     }
 
     const chromeos::CellularApnList& apn_list = device->provider_apn_list();
     ListValue* apn_list_value = new ListValue();
     for (chromeos::CellularApnList::const_iterator it = apn_list.begin();
          it != apn_list.end(); ++it) {
       apn_list_value->Append(CreateDictionaryFromCellularApn(*it));
     }
-    dictionary->Set("providerApnList", apn_list_value);
+    SetValueDictionary(dictionary, "providerApnList", apn_list_value,
+                       cellular_propety_ui_data);
   }
 
   SetActivationButtonVisibility(cellular, dictionary);
 }
 
 void InternetOptionsHandler::PopulateVPNDetails(
     const chromeos::VirtualNetwork* vpn,
     DictionaryValue* dictionary) {
   dictionary->SetString("service_name", vpn->name());
   bool remembered = (vpn->profile_type() != chromeos::PROFILE_NONE);
@@ skipping 266 matching lines @@
   dictionary->Set("wirelessList", GetWirelessList());
   dictionary->Set("vpnList", GetVPNList());
   dictionary->Set("rememberedList", GetRememberedList());
   dictionary->SetBoolean("wifiAvailable", cros_->wifi_available());
   dictionary->SetBoolean("wifiBusy", cros_->wifi_busy());
   dictionary->SetBoolean("wifiEnabled", cros_->wifi_enabled());
   dictionary->SetBoolean("cellularAvailable", cros_->cellular_available());
   dictionary->SetBoolean("cellularBusy", cros_->cellular_busy());
   dictionary->SetBoolean("cellularEnabled", cros_->cellular_enabled());
 }
+
+void InternetOptionsHandler::SetValueDictionary(
+    DictionaryValue* settings,
+    const char* key,
+    base::Value* value,
+    const chromeos::NetworkPropertyUIData& ui_data) {
+  DictionaryValue* value_dict = new DictionaryValue();
+  // DictionaryValue::Set() takes ownership of |value|.
+  if (value)
+    value_dict->Set("value", value);
+  const base::Value* default_value = ui_data.default_value();
+  if (default_value)
+    value_dict->Set("default", default_value->DeepCopy());
+  if (ui_data.managed())
+    value_dict->SetString("controlledBy", "policy");
+  else if (ui_data.recommended())
+    value_dict->SetString("controlledBy", "recommended");
+  settings->Set(key, value_dict);
+}