Support Managed NetworkState format dictionaries for controlled settings.

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 26 matching lines @@
 #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_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
+#include "chromeos/network/onc/onc_utils.h"
 #include "components/onc/onc_constants.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 "grit/ui_chromeos_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/chromeos/network/network_icon.h"
@@ skipping 62 matching lines @@
 const char kSetPreferNetworkMessage[] = "setPreferNetwork";
 const char kSetServerHostname[] = "setServerHostname";
 const char kSetSimCardLockMessage[] = "setSimCardLock";
 const char kShowMorePlanInfoMessage[] = "showMorePlanInfo";
 
 // These are strings used to communicate with JavaScript.
 const char kTagActivate[] = "activate";
 const char kTagActivationState[] = "activationState";
 const char kTagAddConnection[] = "add";
 const char kTagApn[] = "apn";
-const char kTagAutoConnect[] = "autoConnect";
 const char kTagCarrierSelectFlag[] = "showCarrierSelect";
 const char kTagCarrierUrl[] = "carrierUrl";
 const char kTagCellularAvailable[] = "cellularAvailable";
 const char kTagCellularEnabled[] = "cellularEnabled";
 const char kTagCellularSupportsScan[] = "cellularSupportsScan";
 const char kTagConfigure[] = "configure";
 const char kTagConnect[] = "connect";
 const char kTagControlledBy[] = "controlledBy";
 const char kTagDeviceConnected[] = "deviceConnected";
 const char kTagDisconnect[] = "disconnect";
-const char kTagErrorState[] = "errorState";
+const char kTagErrorMessage[] = "errorMessage";
 const char kTagForget[] = "forget";
-const char kTagIdentity[] = "identity";
 const char kTagLanguage[] = "language";
 const char kTagLastGoodApn[] = "lastGoodApn";
 const char kTagLocalizedName[] = "localizedName";
 const char kTagName[] = "name";
 const char kTagNameServersGoogle[] = "nameServersGoogle";
 const char kTagNameServerType[] = "nameServerType";
 const char kTagNetworkId[] = "networkId";
 const char kTagOptions[] = "options";
 const char kTagPassword[] = "password";
 const char kTagPolicy[] = "policy";
 const char kTagPreferred[] = "preferred";
 const char kTagProviderType[] = "providerType";
 const char kTagProviderApnList[] = "providerApnList";
 const char kTagRecommended[] = "recommended";
 const char kTagRecommendedValue[] = "recommendedValue";
 const char kTagRemembered[] = "remembered";
 const char kTagRememberedList[] = "rememberedList";
 const char kTagRestrictedPool[] = "restrictedPool";
 const char kTagRoamingState[] = "roamingState";
 const char kTagServerHostname[] = "serverHostname";
 const char kTagCarriers[] = "carriers";
 const char kTagCurrentCarrierIndex[] = "currentCarrierIndex";
 const char kTagShared[] = "shared";
 const char kTagShowActivateButton[] = "showActivateButton";
-const char kTagShowStaticIPConfig[] = "showStaticIPConfig";
 const char kTagShowViewAccountButton[] = "showViewAccountButton";
 const char kTagSimCardLockEnabled[] = "simCardLockEnabled";
 const char kTagSupportUrl[] = "supportUrl";
 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";
@@ skipping 110 matching lines @@
   std::string name_servers;
   if (shill_properties.GetStringWithoutPathExpansion(
       name_servers_key, &name_servers)) {
     ip_info_dict->SetString(kIpConfigNameServers, name_servers);
     VLOG(2) << "Found " << name_servers_key << ": " << name_servers;
   }
 
   return ip_info_dict.release();
 }
 
-// Decorate dictionary |value_dict| with policy information from |ui_data|.
-void DecorateValueDictionary(const NetworkPropertyUIData& ui_data,
-                             const base::Value& value,
-                             base::DictionaryValue* value_dict) {
-  const base::Value* recommended_value = ui_data.default_value();
-  if (ui_data.IsManaged())
-    value_dict->SetString(kTagControlledBy, kTagPolicy);
-  else if (recommended_value && recommended_value->Equals(&value))
-    value_dict->SetString(kTagControlledBy, kTagRecommended);
-
-  if (recommended_value)
-    value_dict->Set(kTagRecommendedValue, recommended_value->DeepCopy());
-}
-
 // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does and
 // store it under |key| in |settings|. Takes ownership of |value|.
-void SetValueDictionary(base::DictionaryValue* settings,
-                        const char* key,
+void SetValueDictionary(const char* key,
                         base::Value* value,
-                        const NetworkPropertyUIData& ui_data) {
+                        const NetworkPropertyUIData& ui_data,
+                        base::DictionaryValue* settings) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   // DictionaryValue::Set() takes ownership of |value|.
   dict->Set(kTagValue, value);
   settings->Set(key, dict);
-  DecorateValueDictionary(ui_data, *value, dict);
+
+  const base::Value* recommended_value = ui_data.default_value();
+  if (ui_data.IsManaged())
+    dict->SetString(kTagControlledBy, kTagPolicy);
+  else if (recommended_value && recommended_value->Equals(value))
+    dict->SetString(kTagControlledBy, kTagRecommended);
+
+  if (recommended_value)
+    dict->Set(kTagRecommendedValue, recommended_value->DeepCopy());
 }
 
-// Creates a decorated dictionary like SetValueDictionary does, but extended for
-// the Autoconnect property, which respects additionally global network policy.
-void SetAutoconnectValueDictionary(bool network_is_private,
-                                   ::onc::ONCSource onc_source,
-                                   bool current_autoconnect,
-                                   const NetworkPropertyUIData& ui_data,
-                                   base::DictionaryValue* settings) {
+const char* GetOncSourceString(::onc::ONCSource onc_source) {
+  if (onc_source == ::onc::ONC_SOURCE_DEVICE_POLICY)
+    return ::onc::kAugmentationDevicePolicy;
+  return ::onc::kAugmentationUserPolicy;
+}
+
+// Creates a GetManagedProperties style dictionary and adds it to |settings|.
+// |default_value| represents either the recommended value if |recommended|
+// is true, or the enforced value if |recommended| is false.
+// Note(stevenjb): This is bridge code until we use GetManagedProperties to
+// retrieve Shill properties.
+void SetManagedValueDictionary(const char* key,
+                               const base::Value* value,
+                               ::onc::ONCSource onc_source,
+                               bool recommended,
+                               const base::Value* default_value,
+                               base::DictionaryValue* settings) {
   base::DictionaryValue* dict = new base::DictionaryValue();
-  base::Value* value = new base::FundamentalValue(current_autoconnect);
-  // DictionaryValue::Set() takes ownership of |value|.
-  dict->Set(kTagValue, value);
-  settings->Set(kTagAutoConnect, dict);
-  if (onc_source != ::onc::ONC_SOURCE_USER_POLICY &&
-      onc_source != ::onc::ONC_SOURCE_DEVICE_POLICY) {
-    // Autoconnect can be controlled by the GlobalNetworkConfiguration of the
-    // ONC policy.
-    bool only_policy_autoconnect =
-        onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect(network_is_private);
-    if (only_policy_autoconnect) {
-      dict->SetString(kTagControlledBy, kTagPolicy);
-      return;
+  settings->Set(key, dict);
+  dict->Set(::onc::kAugmentationActiveSetting, value->DeepCopy());
+
+  if (onc_source == ::onc::ONC_SOURCE_NONE)
+    return;
+
+  if (recommended) {
+    // If an ONC property is 'Recommended' it can be edited by the user.
+    std::string editable = onc_source == ::onc::ONC_SOURCE_DEVICE_POLICY
+                               ? ::onc::kAugmentationDeviceEditable
+                               : ::onc::kAugmentationUserEditable;
+    dict->Set(editable, new base::FundamentalValue(true));
+  }
+  if (default_value) {
+    std::string policy_source = GetOncSourceString(onc_source);
+    dict->Set(policy_source, default_value->DeepCopy());
+    if (recommended && !value->Equals(default_value)) {

[pneubeck (no reviews), 2014/08/06 19:52:06]

nit: to get some more debugging support, maybe add DCHECKs for the pointer
arguments that should be not null to the beginning of this function.

I would expect, |value| and |settings| to be not NULL.

[stevenjb, 2014/08/06 20:22:52]

DCHECK(value) seems reasonable, I can see that mistake being made maybe, but
|settings| seems redundant.

+      dict->SetString(::onc::kAugmentationUserSetting, value->DeepCopy());
+      dict->SetString(::onc::kAugmentationEffectiveSetting,
+                      ::onc::kAugmentationUserSetting);
+    } else {
+      dict->SetString(::onc::kAugmentationEffectiveSetting, policy_source);
     }
   }
-  DecorateValueDictionary(ui_data, *value, dict);
 }
 
 std::string CopyStringFromDictionary(const base::DictionaryValue& source,
                                      const std::string& src_key,
                                      const std::string& dest_key,
                                      base::DictionaryValue* dest) {
   std::string string_value;
   if (source.GetStringWithoutPathExpansion(src_key, &string_value))
     dest->SetStringWithoutPathExpansion(dest_key, string_value);
   return string_value;
@@ skipping 35 matching lines @@
       onc::FindPolicyForActiveUser(vpn->guid(), &onc_source);
 
   NetworkPropertyUIData hostname_ui_data;
   hostname_ui_data.ParseOncProperty(
       onc_source,
       onc,
       ::onc::network_config::VpnProperty(::onc::vpn::kHost));
   std::string provider_host;
   provider_properties->GetStringWithoutPathExpansion(
       shill::kHostProperty, &provider_host);
-  SetValueDictionary(dictionary, kTagServerHostname,
+  SetValueDictionary(kTagServerHostname,
                      new base::StringValue(provider_host),
-                     hostname_ui_data);
+                     hostname_ui_data,
+                     dictionary);
 }
 
 // Given a list of supported carrier's by the device, return the index of
 // the carrier the device is currently using.
 int FindCurrentCarrierIndex(const base::ListValue* carriers,
                             const DeviceState* device) {
   DCHECK(carriers);
   DCHECK(device);
   bool gsm = (device->technology_family() == shill::kTechnologyFamilyGsm);
   int index = 0;
   for (base::ListValue::const_iterator it = carriers->begin();
        it != carriers->end(); ++it, ++index) {
     std::string value;
     if (!(*it)->GetAsString(&value))
       continue;
     // For GSM devices the device name will be empty, so simply select
     // the Generic UMTS carrier option if present.
     if (gsm && (value == shill::kCarrierGenericUMTS))
       return index;
     // For other carriers, the service name will match the carrier name.
     if (value == device->carrier())
       return index;
   }
   return -1;
 }
 
-void PopulateWimaxDetails(const NetworkState* wimax,
-                          const base::DictionaryValue& shill_properties,
-                          base::DictionaryValue* dictionary) {
-  CopyStringFromDictionary(
-      shill_properties, shill::kEapIdentityProperty, kTagIdentity, dictionary);
-}
-
 void CreateDictionaryFromCellularApn(const base::DictionaryValue* apn,
                                      base::DictionaryValue* dictionary) {
   CopyStringFromDictionary(*apn, shill::kApnProperty, kTagApn, dictionary);
   CopyStringFromDictionary(
       *apn, shill::kApnNetworkIdProperty, kTagNetworkId, dictionary);
   CopyStringFromDictionary(
       *apn, shill::kApnUsernameProperty, kTagUsername, dictionary);
   CopyStringFromDictionary(
       *apn, shill::kApnPasswordProperty, kTagPassword, dictionary);
   CopyStringFromDictionary(*apn, shill::kApnNameProperty, kTagName, dictionary);
@@ skipping 51 matching lines @@
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           cellular->device_path());
   if (device) {
     const base::DictionaryValue& device_properties = device->properties();
     ::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,
+    SetValueDictionary(kTagSimCardLockEnabled,
                        new base::FundamentalValue(device->sim_lock_enabled()),
-                       cellular_property_ui_data);
+                       cellular_property_ui_data,
+                       dictionary);
 
     carrier_id = device->home_provider_id();
     device_properties.GetStringWithoutPathExpansion(shill::kMdnProperty, &mdn);
 
     MobileConfig* config = MobileConfig::GetInstance();
     if (config->IsReady()) {
       const MobileConfig::Carrier* carrier = config->GetCarrier(carrier_id);
       if (carrier && !carrier->top_up_url().empty())
         dictionary->SetString(kTagCarrierUrl, carrier->top_up_url());
     }
 
     base::ListValue* apn_list_value = new base::ListValue();
     const base::ListValue* apn_list;
     if (device_properties.GetListWithoutPathExpansion(
             shill::kCellularApnListProperty, &apn_list)) {
       for (base::ListValue::const_iterator iter = apn_list->begin();
            iter != apn_list->end();
            ++iter) {
         const base::DictionaryValue* dict;
         if ((*iter)->GetAsDictionary(&dict)) {
           base::DictionaryValue* apn = new base::DictionaryValue;
           CreateDictionaryFromCellularApn(dict, apn);
           apn_list_value->Append(apn);
         }
       }
     }
-    SetValueDictionary(dictionary,
-                       kTagProviderApnList,
+    SetValueDictionary(kTagProviderApnList,
                        apn_list_value,
-                       cellular_property_ui_data);
+                       cellular_property_ui_data,
+                       dictionary);
     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.
@@ skipping 59 matching lines @@
   // TODO(stevenjb): Once we eliminate all references to Shill properties,
   // we can switch to using managed_network_configuration_handler which
   // includes Device properties for Cellular (and skip the call to
   // onc::TranslateShillServiceToONCPart). For now we copy them over here.
   scoped_ptr<base::DictionaryValue> shill_properties_with_device(
       shill_properties.DeepCopy());
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           network->device_path());
   if (device) {
-    shill_properties_with_device->Set(shill::kDeviceProperty,
-                                      device->properties().DeepCopy());
+    shill_properties_with_device->SetWithoutPathExpansion(
+        shill::kDeviceProperty, device->properties().DeepCopy());
+    // Get the hardware MAC address from the DeviceState.
+    // (Note: this is done in ManagedNetworkConfigurationHandler but not
+    //  in NetworkConfigurationHandler).
+    if (!device->mac_address().empty()) {
+      shill_properties_with_device->SetStringWithoutPathExpansion(
+          shill::kAddressProperty, device->mac_address());
+    }
   }
   scoped_ptr<base::DictionaryValue> dictionary =
       onc::TranslateShillServiceToONCPart(
           *shill_properties_with_device, &onc::kNetworkWithStateSignature);
 
   dictionary->SetString(kNetworkInfoKeyServicePath, network->path());
   dictionary->SetString(
-      kTagErrorState,
+      kTagErrorMessage,
       ash::network_connect::ErrorString(network->error(), network->path()));
 
   dictionary->SetBoolean(kTagRemembered, !network->profile_path().empty());
   bool shared = !network->IsPrivate();
   dictionary->SetBoolean(kTagShared, shared);
 
   const std::string& type = network->type();
 
   const NetworkState* connected_network =
       NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
           NetworkTypePattern::Primitive(type));
   dictionary->SetBoolean(kTagDeviceConnected, connected_network != NULL);
 
-  if (type == shill::kTypeWimax)
-    PopulateWimaxDetails(network, shill_properties, dictionary.get());
-  else if (type == shill::kTypeCellular)
+  if (type == shill::kTypeCellular)
     PopulateCellularDetails(network, shill_properties, dictionary.get());
   else if (type == shill::kTypeVPN)
     PopulateVPNDetails(network, shill_properties, dictionary.get());
 
   return dictionary.Pass();
 }
 
 // Helper methods for SetIPConfigProperties
 bool AppendPropertyKeyIfPresent(const std::string& key,
                                 const base::DictionaryValue& old_properties,
@@ skipping 605 matching lines @@
 
   // IP config
   scoped_ptr<base::DictionaryValue> ipconfig_dhcp(new base::DictionaryValue);
   ipconfig_dhcp->SetString(kIpConfigAddress, network->ip_address());
   ipconfig_dhcp->SetString(kIpConfigNetmask, network->GetNetmask());
   ipconfig_dhcp->SetString(kIpConfigGateway, network->gateway());
   std::string ipconfig_name_servers = network->GetDnsServersAsString();
   ipconfig_dhcp->SetString(kIpConfigNameServers, ipconfig_name_servers);
   ipconfig_dhcp->SetString(kIpConfigWebProxyAutoDiscoveryUrl,
                            network->web_proxy_auto_discovery_url().spec());
-  SetValueDictionary(dictionary.get(),
-                     kDictionaryIpConfig,
+  SetValueDictionary(kDictionaryIpConfig,
                      ipconfig_dhcp.release(),
-                     property_ui_data);
+                     property_ui_data,
+                     dictionary.get());
 
   std::string name_server_type = kNameServerTypeAutomatic;
   int automatic_ip_config = 0;
   scoped_ptr<base::DictionaryValue> static_ip_dict(
       BuildIPInfoDictionary(shill_properties, true, &automatic_ip_config));
   dictionary->SetBoolean(kIpConfigAutoConfig, automatic_ip_config == 0);
   DCHECK(automatic_ip_config == 3 || automatic_ip_config == 0)
       << "UI doesn't support automatic specification of individual "
       << "static IP parameters.";
   scoped_ptr<base::DictionaryValue> saved_ip_dict(
       BuildIPInfoDictionary(shill_properties, false, NULL));
   dictionary->Set(kDictionarySavedIp, saved_ip_dict.release());
 
   // Determine what kind of name server setting we have by comparing the
   // StaticIP and Google values with the ipconfig values.
   std::string static_ip_nameservers;
   static_ip_dict->GetString(kIpConfigNameServers, &static_ip_nameservers);
   if (!static_ip_nameservers.empty() &&
       static_ip_nameservers == ipconfig_name_servers) {
     name_server_type = kNameServerTypeUser;
   }
   if (ipconfig_name_servers == kGoogleNameServers) {
     name_server_type = kNameServerTypeGoogle;
   }
-  SetValueDictionary(dictionary.get(),
-                     kDictionaryStaticIp,
+  SetValueDictionary(kDictionaryStaticIp,
                      static_ip_dict.release(),
-                     property_ui_data);
+                     property_ui_data,
+                     dictionary.get());
 
   dictionary->SetString(kTagNameServerType, name_server_type);
   dictionary->SetString(kTagNameServersGoogle, kGoogleNameServers);
 
-  // Enable static ip config for Ethernet or WiFi.
-  bool staticIPConfig = network->Matches(NetworkTypePattern::Ethernet()) ||
-                        network->Matches(NetworkTypePattern::WiFi());
-  dictionary->SetBoolean(kTagShowStaticIPConfig, staticIPConfig);
-
   int priority = 0;
   shill_properties.GetIntegerWithoutPathExpansion(
       shill::kPriorityProperty, &priority);
   bool preferred = priority > 0;
-  SetValueDictionary(dictionary.get(), kTagPreferred,
+  SetValueDictionary(kTagPreferred,
                      new base::FundamentalValue(preferred),
-                     property_ui_data);
+                     property_ui_data,
+                     dictionary.get());
 
-  NetworkPropertyUIData auto_connect_ui_data(onc_source);
   std::string onc_path_to_auto_connect;
   if (network->Matches(NetworkTypePattern::WiFi())) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkShowDetailsWifi"));
     if (network->IsConnectedState()) {
       content::RecordAction(
           base::UserMetricsAction("Options_NetworkShowDetailsWifiConnected"));
     }
     onc_path_to_auto_connect =
         ::onc::network_config::WifiProperty(::onc::wifi::kAutoConnect);
   } else if (network->Matches(NetworkTypePattern::VPN())) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkShowDetailsVPN"));
     if (network->IsConnectedState()) {
       content::RecordAction(
           base::UserMetricsAction("Options_NetworkShowDetailsVPNConnected"));
     }
     onc_path_to_auto_connect = ::onc::network_config::VpnProperty(
         ::onc::vpn::kAutoConnect);
   } else if (network->Matches(NetworkTypePattern::Cellular())) {
     content::RecordAction(
         base::UserMetricsAction("Options_NetworkShowDetailsCellular"));
     if (network->IsConnectedState()) {
       content::RecordAction(base::UserMetricsAction(
           "Options_NetworkShowDetailsCellularConnected"));
     }
   }
+
   if (!onc_path_to_auto_connect.empty()) {
-    auto_connect_ui_data.ParseOncProperty(
-        onc_source, onc, onc_path_to_auto_connect);
+    bool auto_connect = false;
+    shill_properties.GetBooleanWithoutPathExpansion(
+        shill::kAutoConnectProperty, &auto_connect);
+
+    scoped_ptr<base::Value> auto_connect_value(
+        new base::FundamentalValue(auto_connect));
+    ::onc::ONCSource auto_connect_onc_source = onc_source;
+    bool auto_connect_recommended =
+        auto_connect_onc_source != ::onc::ONC_SOURCE_NONE &&
+        onc::IsRecommendedValue(onc, onc_path_to_auto_connect);
+    // |auto_connect_default_value| will contain either a recommended value
+    // if |auto_connect_recommended| is true, or an enforced value otherwise.
+    const base::Value* auto_connect_default_value = NULL;
+    onc->Get(onc_path_to_auto_connect, &auto_connect_default_value);
+
+    // Autoconnect can be controlled by the GlobalNetworkConfiguration of the
+    // ONC policy.
+    if (auto_connect_onc_source == ::onc::ONC_SOURCE_NONE &&
+        onc::PolicyAllowsOnlyPolicyNetworksToAutoconnect(
+            network->IsPrivate())) {
+      auto_connect_recommended = false;
+      auto_connect_onc_source = network->IsPrivate()
+                                    ? ::onc::ONC_SOURCE_USER_POLICY
+                                    : ::onc::ONC_SOURCE_DEVICE_POLICY;
+      if (auto_connect) {
+        LOG(WARNING) << "Policy prevents autoconnect, but value is True.";
+        auto_connect_value.reset(new base::FundamentalValue(false));
+      }
+    }
+    SetManagedValueDictionary(shill::kAutoConnectProperty,
+                              auto_connect_value.get(),
+                              auto_connect_onc_source,
+                              auto_connect_recommended,
+                              auto_connect_default_value,
+                              dictionary.get());
   }
-  bool auto_connect = false;
-  shill_properties.GetBooleanWithoutPathExpansion(
-      shill::kAutoConnectProperty, &auto_connect);
-  SetAutoconnectValueDictionary(network->IsPrivate(),
-                                onc_source,
-                                auto_connect,
-                                auto_connect_ui_data,
-                                dictionary.get());
 
   // Show details dialog
   web_ui()->CallJavascriptFunction(kShowDetailedInfoFunction, *dictionary);
 }
 
 gfx::NativeWindow InternetOptionsHandler::GetNativeWindow() const {
   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
 }
 
 float InternetOptionsHandler::GetScaleFactor() const {
@@ skipping 180 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos